Init

6 files changed, 237 insertions, 0 deletions

diff --git a/src/config.rs b/src/config.rs
new file mode 100644
index 0000000..cbea92e
--- /dev/null
+++ b/src/config.rs
@@ -0,0 +1,23 @@
+use config::ConfigError;
+use lazy_static::lazy_static;
+use serde::Deserialize;
+
+#[derive(Deserialize)]
+pub struct Configuration {
+    pub rust_log: String,
+    pub database_url: String,
+    pub jwt_secret: String,
+    pub allowed_host: String,
+}
+
+impl Configuration {
+    pub fn new() -> Result<Self, ConfigError> {
+        let builder = config::Config::builder().add_source(config::Environment::default());
+
+        builder.build()?.try_deserialize()
+    }
+}
+
+lazy_static! {
+    pub static ref CONFIG: Configuration = Configuration::new().expect("Config can be loaded");
+}
diff --git a/src/errors.rs b/src/errors.rs
new file mode 100644
index 0000000..e0a70b5
--- /dev/null
+++ b/src/errors.rs
@@ -0,0 +1,70 @@
+use axum::{
+    http::StatusCode,
+    response::{IntoResponse, Response},
+    Json,
+};
+use serde_json::json;
+
+/// All errors raised by the web app
+pub enum AppError {
+    /// Database error
+    Database,
+    /// Generic bad request. It is handled with a message value
+    BadRequest(String),
+    /// Not found error
+    NotFound(String),
+    /// Raised when a token is not good created
+    TokenCreation,
+    /// Raised when a passed token is not valid
+    InvalidToken,
+    /// Raised if an user wants to do something can't do
+    Unauthorized,
+}
+
+/// Use `AppError` as response for an endpoint
+impl IntoResponse for AppError {
+    /// Matches `AppError` into a tuple of status and error message.
+    /// The response will be a JSON in the format of:
+    /// ```json
+    /// { "error": "<message>" }
+    /// ```
+    fn into_response(self) -> Response {
+        let (status, error_message) = match self {
+            AppError::Database => (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "Error with database connection".to_string(),
+            ),
+            AppError::BadRequest(value) => (StatusCode::BAD_REQUEST, value),
+            AppError::NotFound(value) => (StatusCode::NOT_FOUND, value),
+            AppError::TokenCreation => (
+                StatusCode::INTERNAL_SERVER_ERROR,
+                "Token creation error".to_string(),
+            ),
+            AppError::InvalidToken => (StatusCode::BAD_REQUEST, "Invalid token".to_string()),
+            AppError::Unauthorized => (
+                StatusCode::UNAUTHORIZED,
+                "Can't perform this action".to_string(),
+            ),
+        };
+
+        let body = Json(json!({
+            "error": error_message,
+        }));
+
+        (status, body).into_response()
+    }
+}
+
+/// Raise a generic error from a string
+impl From<std::string::String> for AppError {
+    fn from(error: std::string::String) -> AppError {
+        AppError::BadRequest(error)
+    }
+}
+
+/// Raise a generic io error
+impl From<std::io::Error> for AppError {
+    fn from(error: std::io::Error) -> Self {
+        AppError::BadRequest(error.to_string())
+    }
+}
diff --git a/src/graphql.rs b/src/graphql.rs
new file mode 100644
index 0000000..12b6db3
--- /dev/null
+++ b/src/graphql.rs
@@ -0,0 +1,45 @@
+use async_graphql::{
+    http::GraphiQLSource, Context, EmptyMutation, EmptySubscription, Object, Schema,
+};
+use async_graphql_axum::GraphQL;
+use axum::{
+    response::{self, IntoResponse},
+    routing::get,
+    Router,
+};
+
+struct Query;
+
+#[Object]
+impl Query {
+    async fn api_version(&self) -> &'static str {
+        "1.0"
+    }
+
+    /// Returns the sum of a and b
+    async fn add<'ctx>(
+        &self,
+        _ctx: &Context<'ctx>,
+        #[graphql(desc = "First value")] a: i32,
+        #[graphql(desc = "Second value")] b: Option<i32>,
+    ) -> i32 {
+        match b {
+            Some(x) => a + x,
+            None => a,
+        }
+    }
+}
+
+pub async fn graphiql() -> impl IntoResponse {
+    response::Html(
+        GraphiQLSource::build()
+            .endpoint("/")
+            .subscription_endpoint("/ws")
+            .finish(),
+    )
+}
+
+pub fn create_route() -> Router {
+    let schema = Schema::new(Query, EmptyMutation, EmptySubscription);
+    Router::new().route("/", get(graphiql).post_service(GraphQL::new(schema)))
+}
diff --git a/src/logger.rs b/src/logger.rs
new file mode 100644
index 0000000..3f3ff0f
--- /dev/null
+++ b/src/logger.rs
@@ -0,0 +1,11 @@
+use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
+
+/// Setup tracing subscriber logger
+pub fn setup() {
+    tracing_subscriber::registry()
+        .with(tracing_subscriber::EnvFilter::new(
+            crate::config::CONFIG.rust_log.clone(),
+        ))
+        .with(tracing_subscriber::fmt::layer())
+        .init();
+}
diff --git a/src/main.rs b/src/main.rs
new file mode 100644
index 0000000..8643d71
--- /dev/null
+++ b/src/main.rs
@@ -0,0 +1,65 @@
+mod config;
+mod errors;
+mod graphql;
+mod logger;
+mod routes;
+use std::{net::SocketAddr, time::Duration};
+
+use crate::config::CONFIG;
+use axum::{
+    http::{header, Request},
+    Router,
+};
+use tokio::net::TcpListener;
+use tower_http::{
+    classify::ServerErrorsFailureClass, sensitive_headers::SetSensitiveHeadersLayer,
+    trace::TraceLayer,
+};
+
+use tracing::Span;
+
+/// Create the app: setup everything and returns a `Router`
+async fn create_app() -> Router {
+    logger::setup();
+    // let _ = db::setup().await;
+
+    Router::new()
+        .nest("/graphql", graphql::create_route())
+        .fallback(crate::routes::page_404)
+        // Mark the `Authorization` request header as sensitive so it doesn't
+        // show in logs.
+        .layer(SetSensitiveHeadersLayer::new(std::iter::once(
+            header::AUTHORIZATION,
+        )))
+        // Use a layer for `TraceLayer`
+        .layer(
+            TraceLayer::new_for_http()
+                .on_request(|request: &Request<_>, _span: &Span| {
+                    tracing::info!("{} {}", request.method(), request.uri());
+                })
+                .on_failure(
+                    |error: ServerErrorsFailureClass, latency: Duration, _span: &Span| {
+                        tracing::error!("{} | {} s", error, latency.as_secs());
+                    },
+                ),
+        )
+}
+
+#[tokio::main(flavor = "current_thread")]
+async fn main() {
+    let app = create_app().await;
+
+    let host = &CONFIG.allowed_host;
+
+    let addr = match host.parse::<SocketAddr>() {
+        Ok(addr) => addr,
+        Err(e) => {
+            panic!("`{}` {}", host, e);
+        }
+    };
+    tracing::info!("Listening on {}", addr);
+
+    axum::serve(TcpListener::bind(&addr).await.unwrap(), app)
+        .await
+        .unwrap();
+}
diff --git a/src/routes.rs b/src/routes.rs
new file mode 100644
index 0000000..a269bc4
--- /dev/null
+++ b/src/routes.rs
@@ -0,0 +1,23 @@
+use crate::errors::AppError;
+use axum::{
+    http::StatusCode,
+    response::{IntoResponse, Response},
+    Json,
+};
+use serde::Serialize;
+
+pub async fn page_404() -> impl IntoResponse {
+    AppError::NotFound("Route not found".to_string())
+}
+
+/// Extension of `Json` which returns the CREATED status code
+pub struct JsonCreate<T>(pub T);
+
+impl<T> IntoResponse for JsonCreate<T>
+where
+    T: Serialize,
+{
+    fn into_response(self) -> Response {
+        (StatusCode::CREATED, Json(self.0)).into_response()
+    }
+}