Add bff

como_bin/src/main.rs

@@ -1,22 +1,33 @@
 use std::env::{self, current_dir};
 
+mod error;
 mod gqlx;
 mod graphql;
 mod services;
 
+use async_graphql_axum::{GraphQLRequest, GraphQLResponse};
 use axum::{
     extract::Extension,
-    http::Method,
+    http::{Method, StatusCode},
     response::{Html, IntoResponse},
-    routing::get,
+    routing::{get, post},
     Json, Router,
 };
+use axum_extra::extract::{cookie::Key, PrivateCookieJar};
 
 use async_graphql::{
     http::{playground_source, GraphQLPlaygroundConfig},
     EmptySubscription, Request, Response, Schema,
 };
+use axum_sessions::{
+    async_session::MemoryStore,
+    extractors::{ReadableSession, WritableSession},
+    SessionLayer,
+};
+use error::AppError;
 use graphql::CibusSchema;
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
 use services::users_service;
 use sqlx::PgPool;
 use tower_http::{cors::CorsLayer, trace::TraceLayer};
@@ -24,8 +35,22 @@ use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
 use crate::graphql::{MutationRoot, QueryRoot};
 
-async fn graphql_handler(schema: Extension<CibusSchema>, req: Json<Request>) -> Json<Response> {
-    schema.execute(req.0).await.into()
+async fn graphql_handler(
+    schema: Extension<CibusSchema>,
+    session: ReadableSession,
+    req: GraphQLRequest,
+) -> Result<GraphQLResponse, StatusCode> {
+    let mut req = req.into_inner();
+    if let Some(user_id) = session.get::<String>("userId") {
+        req = req.data(user_id);
+        return Ok(schema.execute(req).await.into());
+    } else if let Some(on) = &req.operation_name {
+        if on == "IntrospectionQuery" {
+            return Ok(schema.execute(req).await.into());
+        }
+    }
+
+    Err(StatusCode::FORBIDDEN)
 }
 
 async fn graphql_playground() -> impl IntoResponse {
@@ -63,18 +88,29 @@ async fn main() -> anyhow::Result<()> {
     // Schema
     println!("Building schema");
     let schema = Schema::build(QueryRoot, MutationRoot, EmptySubscription)
-        .data(users_service::UserService::new(pool))
+        .data(users_service::UserService::new(pool.clone()))
         .finish();
 
     // CORS
     let cors = vec!["http://localhost:3000".parse().unwrap()];
 
+    // Key
+    let key = Key::generate();
+
+    let store = MemoryStore::new();
+    let session_layer = SessionLayer::new(store, key.master());
+
     // Webserver
     tracing::info!("Building router");
     let app = Router::new()
         .route("/", get(graphql_playground).post(graphql_handler))
-        .layer(Extension(schema))
+        .route("/auth/login", post(login))
+        .route("/auth/register", post(register))
         .layer(TraceLayer::new_for_http())
+        .layer(Extension(schema))
+        .layer(Extension(key))
+        .layer(Extension(pool))
+        .layer(session_layer)
         .layer(
             CorsLayer::new()
                 .allow_origin(cors)
@@ -90,3 +126,50 @@ async fn main() -> anyhow::Result<()> {
 
     Ok(())
 }
+
+#[derive(Serialize, Deserialize)]
+pub struct Credentials {
+    pub username: String,
+    pub password: String,
+}
+
+async fn login(
+    Json(credentials): Json<Credentials>,
+    Extension(pool): Extension<PgPool>,
+    mut session: WritableSession,
+) -> Result<Json<Value>, error::AppError> {
+    let us = users_service::UserService::new(pool);
+    match us
+        .validate_user(credentials.username, credentials.password)
+        .await
+        .map_err(|e| {
+            tracing::error!("could not validate user: {}", e);
+
+            AppError::InternalServerError
+        })? {
+        Some(user_id) => {
+            if let Err(e) = session.insert("userId", user_id.clone()) {
+                tracing::error!("could not insert session: {}", e);
+                return Err(AppError::InternalServerError);
+            }
+
+            Ok(Json(json!({ "userId": user_id })))
+        }
+        None => Err(AppError::WrongCredentials),
+    }
+}
+async fn register(
+    Json(credentials): Json<Credentials>,
+    Extension(pool): Extension<PgPool>,
+) -> Result<Json<Value>, error::AppError> {
+    let us = users_service::UserService::new(pool)
+        .add_user(credentials.username, credentials.password)
+        .await
+        .map_err(|e| {
+            tracing::error!("could not add user: {}", e);
+
+            AppError::InternalServerError
+        })?;
+
+    Ok(Json(json!({ "userId": us })))
+}