Added apis

Cargo.lock

@@ -189,6 +189,7 @@ dependencies = [
  "static_assertions",
  "tempfile",
  "thiserror",
+ "uuid",
 ]
 
 [[package]]
@@ -640,7 +641,7 @@ dependencies = [
 ]
 
 [[package]]
-name = "como_bin"
+name = "como_api"
 version = "0.1.0"
 dependencies = [
  "anyhow",
@@ -652,6 +653,38 @@ dependencies = [
  "axum-sessions",
  "como_core",
  "como_domain",
+ "como_gql",
+ "como_infrastructure",
+ "cookie",
+ "dotenv",
+ "rand_core",
+ "serde",
+ "serde_json",
+ "sqlx 0.6.1",
+ "tokio",
+ "tower",
+ "tower-http",
+ "tracing",
+ "tracing-subscriber",
+ "uuid",
+]
+
+[[package]]
+name = "como_bin"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "argon2",
+ "async-graphql",
+ "async-graphql-axum",
+ "axum",
+ "axum-extra",
+ "axum-sessions",
+ "clap",
+ "como_api",
+ "como_core",
+ "como_domain",
+ "como_gql",
  "como_infrastructure",
  "cookie",
  "dotenv",
@@ -674,6 +707,7 @@ dependencies = [
  "async-trait",
  "axum",
  "clap",
+ "como_domain",
  "dotenv",
  "mockall",
  "rust-argon2",
@@ -693,11 +727,39 @@ name = "como_domain"
 version = "0.1.0"
 dependencies = [
  "anyhow",
+ "async-graphql",
  "serde",
  "serde_json",
  "uuid",
 ]
 
+[[package]]
+name = "como_gql"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "argon2",
+ "async-graphql",
+ "async-graphql-axum",
+ "axum",
+ "axum-extra",
+ "axum-sessions",
+ "como_core",
+ "como_domain",
+ "como_infrastructure",
+ "cookie",
+ "dotenv",
+ "rand_core",
+ "serde",
+ "serde_json",
+ "sqlx 0.6.1",
+ "tokio",
+ "tower-http",
+ "tracing",
+ "tracing-subscriber",
+ "uuid",
+]
+
 [[package]]
 name = "como_infrastructure"
 version = "0.1.0"

Cargo.toml

@@ -1,2 +1,9 @@
 [workspace]
-members = ["como_bin", "como_core", "como_domain", "como_infrastructure"]
+members = [
+  "como_bin",
+  "como_core",
+  "como_domain",
+  "como_infrastructure",
+  "como_gql",
+  "como_api",
+]

como_api/Cargo.toml

@@ -0,0 +1,39 @@
+[package]
+name = "como_api"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+como_gql = { path = "../como_gql" }
+como_core = { path = "../como_core" }
+como_domain = { path = "../como_domain" }
+como_infrastructure = { path = "../como_infrastructure" }
+
+async-graphql = "4.0.6"
+async-graphql-axum = "*"
+axum = "0.5.13"
+axum-extra = { version = "*", features = ["cookie", "cookie-private"] }
+axum-sessions = { version = "*" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0.68"
+
+tokio = { version = "1.20.1", features = ["full"] }
+uuid = { version = "1.1.2", features = ["v4", "fast-rng"] }
+sqlx = { version = "0.6", features = [
+  "runtime-tokio-rustls",
+  "postgres",
+  "migrate",
+  "uuid",
+  "offline",
+] }
+anyhow = "1.0.60"
+dotenv = "0.15.0"
+tracing = "0.1.36"
+tracing-subscriber = { version = "0.3.15", features = ["env-filter"] }
+argon2 = "0.4"
+rand_core = { version = "0.6", features = ["std"] }
+cookie = { version = "0.16", features = ["secure", "percent-encode"] }
+tower = { version = "0.4", features = ["timeout"] }
+tower-http = { version = "0.3", features = ["trace", "cors"] }

como_api/src/controllers/graphql.rs

@@ -0,0 +1,11 @@
+use axum::{routing::get, Router};
+use como_gql::{graphql_handler, graphql_playground};
+use como_infrastructure::register::ServiceRegister;
+
+pub struct GraphQLController;
+
+impl GraphQLController {
+    pub fn new_router(_service_register: ServiceRegister) -> Router {
+        Router::new().route("/", get(graphql_playground).post(graphql_handler))
+    }
+}

como_api/src/controllers/mod.rs

@@ -0,0 +1 @@
+pub mod graphql;

como_api/src/lib.rs

@@ -0,0 +1,2 @@
+mod controllers;
+pub mod router;

como_api/src/router.rs

@@ -0,0 +1,44 @@
+use anyhow::Context;
+use axum::{
+    http::{HeaderValue, Method},
+    Router,
+};
+use como_infrastructure::register::ServiceRegister;
+use tower::ServiceBuilder;
+use tower_http::{cors::CorsLayer, trace::TraceLayer};
+
+use crate::controllers::graphql::GraphQLController;
+
+pub struct Api;
+
+impl Api {
+    pub async fn new(
+        port: u32,
+        cors_origin: &str,
+        service_register: ServiceRegister,
+    ) -> anyhow::Result<()> {
+        let router = Router::new()
+            .nest(
+                "/graphql",
+                GraphQLController::new_router(service_register.clone()),
+            )
+            .layer(ServiceBuilder::new().layer(TraceLayer::new_for_http()))
+            .layer(
+                CorsLayer::new()
+                    .allow_origin(
+                        cors_origin
+                            .parse::<HeaderValue>()
+                            .context("could not parse cors origin as header")?,
+                    )
+                    .allow_headers([axum::http::header::CONTENT_TYPE])
+                    .allow_methods([Method::GET, Method::POST, Method::OPTIONS]),
+            );
+
+        axum::Server::bind(&format!("0.0.0.0:{}", port).parse().unwrap())
+            .serve(router.into_make_service())
+            .await
+            .context("error while starting API")?;
+
+        Ok(())
+    }
+}

como_bin/Cargo.toml

@@ -6,9 +6,11 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+como_gql = { path = "../como_gql" }
 como_core = { path = "../como_core" }
 como_domain = { path = "../como_domain" }
 como_infrastructure = { path = "../como_infrastructure" }
+como_api = { path = "../como_api" }
 
 async-graphql = "4.0.6"
 async-graphql-axum = "*"
@@ -34,3 +36,4 @@ tower-http = { version = "0.3.4", features = ["full"] }
 argon2 = "0.4"
 rand_core = { version = "0.6", features = ["std"] }
 cookie = { version = "0.16", features = ["secure", "percent-encode"] }
+clap = { version = "3", features = ["derive", "env"] }

como_bin/build.rs

@@ -1,6 +0,0 @@
-// generated by `sqlx migrate build-script`
-fn main() {
-    // trigger recompilation when a new migration is added
-    println!("cargo:rerun-if-changed=migrations");
-}
-

como_bin/sqlx-data.json

@@ -1,56 +0,0 @@
-{
-  "db": "PostgreSQL",
-  "3b4484c5ccfd4dcb887c4e978fe6e45d4c9ecc2a73909be207dced79ddf17d87": {
-    "describe": {
-      "columns": [
-        {
-          "name": "id",
-          "ordinal": 0,
-          "type_info": "Uuid"
-        }
-      ],
-      "nullable": [
-        false
-      ],
-      "parameters": {
-        "Left": [
-          "Varchar",
-          "Varchar"
-        ]
-      }
-    },
-    "query": "\n            INSERT INTO users (username, password_hash) \n            VALUES ( $1, $2 ) \n            RETURNING id\n            "
-  },
-  "d3f222cf6c3d9816705426fdbed3b13cb575bb432eb1f33676c0b414e67aecaf": {
-    "describe": {
-      "columns": [
-        {
-          "name": "id",
-          "ordinal": 0,
-          "type_info": "Uuid"
-        },
-        {
-          "name": "username",
-          "ordinal": 1,
-          "type_info": "Varchar"
-        },
-        {
-          "name": "password_hash",
-          "ordinal": 2,
-          "type_info": "Varchar"
-        }
-      ],
-      "nullable": [
-        false,
-        false,
-        false
-      ],
-      "parameters": {
-        "Left": [
-          "Text"
-        ]
-      }
-    },
-    "query": "\n            SELECT * from users\n            where username=$1\n            "
-  }
-}

como_bin/src/gqlx/mod.rs

@@ -1,2 +0,0 @@
-pub mod users;
-

como_bin/src/main.rs

@@ -1,11 +1,9 @@
-use std::env::{self, current_dir};
+use std::{
+    env::{self, current_dir},
+    sync::Arc,
+};
 
 mod error;
-mod gqlx;
-mod graphql;
-mod services;
-
-use async_graphql_axum::{GraphQLRequest, GraphQLResponse};
 use axum::{
     extract::Extension,
     http::{Method, StatusCode},
@@ -14,57 +12,31 @@ use axum::{
     Json, Router,
 };
 use axum_extra::extract::cookie::Key;
+use clap::Parser;
 
-use async_graphql::{
+use anyhow::Context;
-    http::{playground_source, GraphQLPlaygroundConfig},
-    EmptySubscription, Schema,
-};
 use axum_sessions::{
     async_session::MemoryStore,
     extractors::{ReadableSession, WritableSession},
     SessionLayer,
 };
-use error::AppError;
+use como_api::router::Api;
-use graphql::CibusSchema;
+use como_infrastructure::{
+    configs::AppConfig, database::ConnectionPoolManager, register::ServiceRegister,
+};
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
-use services::users_service;
 use sqlx::PgPool;
 use tower_http::{cors::CorsLayer, trace::TraceLayer};
 use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
 
-use crate::graphql::{MutationRoot, QueryRoot};
-
-async fn graphql_handler(
-    schema: Extension<CibusSchema>,
-    session: ReadableSession,
-    req: GraphQLRequest,
-) -> Result<GraphQLResponse, StatusCode> {
-    let 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 {
-    Html(playground_source(GraphQLPlaygroundConfig::new("/")))
-}
-
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
-    // Environment
     tracing::info!("Loading dotenv");
     dotenv::dotenv()?;
 
-    // Logging
+    let config = Arc::new(AppConfig::parse());
+
     tracing_subscriber::registry()
         .with(tracing_subscriber::EnvFilter::new(
             std::env::var("RUST_LOG").unwrap_or_else(|_| {
@@ -75,102 +47,13 @@ async fn main() -> anyhow::Result<()> {
         .with(tracing_subscriber::fmt::layer())
         .init();
 
-    // Database
+    let pool = ConnectionPoolManager::new_pool(&config.database_url, true).await?;
-    tracing::info!("Creating pool");
-    let db_url = env::var("DATABASE_URL")?;
-    let pool = PgPool::connect(&db_url).await?;
 
-    // Database Migrate
+    let service_register = ServiceRegister::new(pool, config.clone());
-    tracing::info!("Migrating db");
-    sqlx::migrate!("db/migrations").run(&pool).await?;
 
-    tracing::info!("current path: {}", current_dir()?.to_string_lossy());
+    Api::new(3001, &config.cors_origin, service_register.clone())
-
-    // Schema
-    println!("Building schema");
-    let schema = Schema::build(QueryRoot, MutationRoot, EmptySubscription)
-        .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))
-        .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)
-                .allow_headers([axum::http::header::CONTENT_TYPE])
-                .allow_methods([Method::GET, Method::POST, Method::OPTIONS]),
-        );
-
-    tracing::info!("Starting webserver");
-    axum::Server::bind(&"0.0.0.0:3001".parse().unwrap())
-        .serve(app.into_make_service())
         .await
-        .unwrap();
+        .context("could not initialize API")?;
 
     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 })))
-}

como_bin/src/services/mod.rs

@@ -1 +0,0 @@
-pub mod users_service;

como_bin/src/services/users_service.rs

@@ -1,78 +0,0 @@
-use anyhow::anyhow;
-use argon2::{password_hash::SaltString, Argon2, PasswordHash, PasswordHasher, PasswordVerifier};
-use rand_core::OsRng;
-use sqlx::{Pool, Postgres};
-
-pub struct UserService {
-    pgx: Pool<Postgres>,
-}
-
-impl UserService {
-    pub fn new(pgx: Pool<Postgres>) -> Self {
-        Self { pgx }
-    }
-
-    pub async fn add_user(&self, username: String, password: String) -> anyhow::Result<String> {
-        let hashed_password = self.hash_password(password)?;
-
-        let rec = sqlx::query!(
-            r#"
-            INSERT INTO users (username, password_hash) 
-            VALUES ( $1, $2 ) 
-            RETURNING id
-            "#,
-            username,
-            hashed_password
-        )
-        .fetch_one(&self.pgx)
-        .await?;
-
-        Ok(rec.id.to_string())
-    }
-
-    pub async fn validate_user(
-        &self,
-        username: String,
-        password: String,
-    ) -> anyhow::Result<Option<String>> {
-        let rec = sqlx::query!(
-            r#"
-            SELECT * from users
-            where username=$1
-            "#,
-            username,
-        )
-        .fetch_optional(&self.pgx)
-        .await?;
-
-        match rec {
-            Some(user) => match self.validate_password(password, user.password_hash)? {
-                true => Ok(Some(user.id.to_string())),
-                false => Ok(None),
-            },
-            None => Ok(None),
-        }
-    }
-
-    fn hash_password(&self, password: String) -> anyhow::Result<String> {
-        let salt = SaltString::generate(&mut OsRng);
-        let argon2 = Argon2::default();
-
-        let password_hash = argon2
-            .hash_password(password.as_bytes(), &salt)
-            .map_err(|e| anyhow!(e))?
-            .to_string();
-
-        Ok(password_hash)
-    }
-
-    fn validate_password(&self, password: String, hashed_password: String) -> anyhow::Result<bool> {
-        let argon2 = Argon2::default();
-
-        let parsed_hash = PasswordHash::new(&hashed_password).map_err(|e| anyhow!(e))?;
-        match argon2.verify_password(password.as_bytes(), &parsed_hash) {
-            Ok(..) => Ok(true),
-            Err(..) => Ok(false),
-        }
-    }
-}

como_core/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+como_domain = { path = "../como_domain" }
 tokio = { version = "1", features = ["full"] }
 axum = "0.5.1"
 

como_core/src/items/mod.rs

@@ -1,8 +1,11 @@
 use std::sync::Arc;
 
 use async_trait::async_trait;
+use como_domain::item::{requests::CreateItemDto, responses::CreatedItemDto};
 
 pub type DynItemService = Arc<dyn ItemService + Send + Sync>;
 
 #[async_trait]
-pub trait ItemService {}
+pub trait ItemService {
+    async fn add_item(&self, item: CreateItemDto) -> anyhow::Result<CreatedItemDto>;
+}

como_core/src/users/mod.rs

@@ -5,4 +5,11 @@ use async_trait::async_trait;
 pub type DynUserService = Arc<dyn UserService + Send + Sync>;
 
 #[async_trait]
-pub trait UserService {}
+pub trait UserService {
+    async fn add_user(&self, username: String, password: String) -> anyhow::Result<String>;
+    async fn validate_user(
+        &self,
+        username: String,
+        password: String,
+    ) -> anyhow::Result<Option<String>>;
+}

como_domain/Cargo.toml

@@ -6,6 +6,7 @@ edition = "2021"
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [dependencies]
+async-graphql = { version = "4.0.6", features = ["uuid"] }
 anyhow = "1.0.60"
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0.68"

como_domain/src/item/mod.rs

@@ -1,10 +1,11 @@
 pub mod requests;
 pub mod responses;
 
+use async_graphql::{Enum, InputObject, SimpleObject};
 use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize, Clone, PartialEq, Eq, Enum, Copy)]
 pub enum ItemState {
     Created,
     Done,
@@ -12,7 +13,7 @@ pub enum ItemState {
     Deleted,
 }
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, InputObject, SimpleObject)]
 pub struct ItemDto {
     pub id: Uuid,
     pub title: String,

como_domain/src/item/requests.rs

@@ -1,6 +1,7 @@
+use async_graphql::InputObject;
 use serde::{Deserialize, Serialize};
 
-#[derive(Debug, Serialize, Deserialize)]
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, InputObject)]
 pub struct CreateItemDto {
     pub name: String,
 }

como_gql/Cargo.toml

@@ -0,0 +1,36 @@
+[package]
+name = "como_gql"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+como_core = { path = "../como_core" }
+como_domain = { path = "../como_domain" }
+como_infrastructure = { path = "../como_infrastructure" }
+
+async-graphql = "4.0.6"
+async-graphql-axum = "*"
+axum = "0.5.13"
+axum-extra = { version = "*", features = ["cookie", "cookie-private"] }
+axum-sessions = { version = "*" }
+serde = { version = "1.0", features = ["derive"] }
+serde_json = "1.0.68"
+tokio = { version = "1.20.1", features = ["full"] }
+uuid = { version = "1.1.2", features = ["v4", "fast-rng"] }
+sqlx = { version = "0.6", features = [
+  "runtime-tokio-rustls",
+  "postgres",
+  "migrate",
+  "uuid",
+  "offline",
+] }
+anyhow = "1.0.60"
+dotenv = "0.15.0"
+tracing = "0.1.36"
+tracing-subscriber = { version = "0.3.15", features = ["env-filter"] }
+tower-http = { version = "0.3.4", features = ["full"] }
+argon2 = "0.4"
+rand_core = { version = "0.6", features = ["std"] }
+cookie = { version = "0.16", features = ["secure", "percent-encode"] }

como_gql/src/graphql.rs

@@ -1,8 +1,8 @@
-use async_graphql::{Context, EmptySubscription, Object, Schema};
+use async_graphql::{Context, EmptySubscription, Object, Schema, SimpleObject};
 
-use como_domain::item::{requests::CreateItemDto, responses::CreatedItemDto};
+use como_domain::item::{requests::CreateItemDto, responses::CreatedItemDto, ItemState};
-
+use como_infrastructure::register::ServiceRegister;
-use crate::services::users_service::UserService;
+use uuid::Uuid;
 
 pub type CibusSchema = Schema<QueryRoot, MutationRoot, EmptySubscription>;
 
@@ -16,9 +16,12 @@ impl MutationRoot {
         username: String,
         password: String,
     ) -> anyhow::Result<bool> {
-        let user_service = ctx.data_unchecked::<UserService>();
+        let service_register = ctx.data_unchecked::<ServiceRegister>();
 
-        let valid = user_service.validate_user(username, password).await?;
+        let valid = service_register
+            .user_service
+            .validate_user(username, password)
+            .await?;
         let returnvalid = match valid {
             Some(..) => true,
             None => false,
@@ -33,9 +36,12 @@ impl MutationRoot {
         username: String,
         password: String,
     ) -> anyhow::Result<String> {
-        let user_service = ctx.data_unchecked::<UserService>();
+        let service_register = ctx.data_unchecked::<ServiceRegister>();
 
-        let user_id = user_service.add_user(username, password).await?;
+        let user_id = service_register
+            .user_service
+            .add_user(username, password)
+            .await?;
 
         Ok(user_id)
     }
@@ -45,7 +51,11 @@ impl MutationRoot {
         ctx: &Context<'_>,
         item: CreateItemDto,
     ) -> anyhow::Result<CreatedItemDto> {
-        let services_register = ctx.data_unchecked::<ServiceRegister>()
+        let services_register = ctx.data_unchecked::<ServiceRegister>();
+
+        let created_item = services_register.item_service.add_item(item).await?;
+
+        Ok(created_item)
     }
 }
 
@@ -53,5 +63,7 @@ pub struct QueryRoot;
 
 #[Object]
 impl QueryRoot {
-    async fn get_upcoming(&self, _ctx: &Context<'_>) -> Vec<Event> {}
+    async fn hello(&self, ctx: &Context<'_>) -> String {
+        "hello".into()
+    }
 }

como_gql/src/lib.rs

@@ -0,0 +1,42 @@
+use async_graphql_axum::{GraphQLRequest, GraphQLResponse};
+use axum::{
+    extract::Extension,
+    http::{Method, StatusCode},
+    response::{Html, IntoResponse},
+    routing::{get, post},
+    Json, Router,
+};
+use axum_extra::extract::cookie::Key;
+
+use async_graphql::{
+    http::{playground_source, GraphQLPlaygroundConfig},
+    EmptySubscription, Schema,
+};
+use axum_sessions::{
+    async_session::MemoryStore,
+    extractors::{ReadableSession, WritableSession},
+    SessionLayer,
+};
+use graphql::CibusSchema;
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
+use sqlx::PgPool;
+use tower_http::{cors::CorsLayer, trace::TraceLayer};
+use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
+
+use crate::graphql::{MutationRoot, QueryRoot};
+pub mod graphql;
+
+pub async fn graphql_handler(
+    schema: Extension<CibusSchema>,
+    session: ReadableSession,
+    req: GraphQLRequest,
+) -> Result<GraphQLResponse, StatusCode> {
+    let req = req.into_inner();
+
+    Ok(schema.execute(req).await.into())
+}
+
+pub async fn graphql_playground() -> impl IntoResponse {
+    Html(playground_source(GraphQLPlaygroundConfig::new("/")))
+}

como_infrastructure/src/register.rs

@@ -20,12 +20,12 @@ pub struct ServiceRegister {
 }
 
 impl ServiceRegister {
-    pub fn new(_pool: ConnectionPool, _config: AppConfig) -> Self {
+    pub fn new(pool: ConnectionPool, _config: Arc<AppConfig>) -> Self {
         info!("creating services");
 
         let item_service = Arc::new(DefaultItemService::new()) as DynItemService;
         let project_service = Arc::new(DefaultProjectService::new()) as DynProjectService;
-        let user_service = Arc::new(DefaultUserService::new()) as DynUserService;
+        let user_service = Arc::new(DefaultUserService::new(pool.clone())) as DynUserService;
 
         info!("services created succesfully");
 

como_infrastructure/src/services/item_service.rs

@@ -1,4 +1,6 @@
+use axum::async_trait;
 use como_core::items::ItemService;
+use como_domain::item::{requests::CreateItemDto, responses::CreatedItemDto};
 
 pub struct DefaultItemService {}
 
@@ -8,4 +10,9 @@ impl DefaultItemService {
     }
 }
 
-impl ItemService for DefaultItemService {}
+#[async_trait]
+impl ItemService for DefaultItemService {
+    async fn add_item(&self, _item: CreateItemDto) -> anyhow::Result<CreatedItemDto> {
+        todo!()
+    }
+}

como_infrastructure/src/services/user_service.rs

@@ -1,11 +1,83 @@
+use argon2::{password_hash::SaltString, Argon2, PasswordHash, PasswordHasher, PasswordVerifier};
+use axum::async_trait;
 use como_core::users::UserService;
+use rand_core::OsRng;
 
-pub struct DefaultUserService {}
+use crate::database::ConnectionPool;
+
+pub struct DefaultUserService {
+    pool: ConnectionPool,
+}
 
 impl DefaultUserService {
-    pub fn new() -> Self {
+    pub fn new(pool: ConnectionPool) -> Self {
-        Self {}
+        Self { pool }
+    }
+
+    fn hash_password(&self, password: String) -> anyhow::Result<String> {
+        let salt = SaltString::generate(&mut OsRng);
+        let argon2 = Argon2::default();
+
+        let password_hash = argon2
+            .hash_password(password.as_bytes(), &salt)
+            .map_err(|e| anyhow::anyhow!(e))?
+            .to_string();
+
+        Ok(password_hash)
+    }
+
+    fn validate_password(&self, password: String, hashed_password: String) -> anyhow::Result<bool> {
+        let argon2 = Argon2::default();
+
+        let parsed_hash = PasswordHash::new(&hashed_password).map_err(|e| anyhow::anyhow!(e))?;
+        match argon2.verify_password(password.as_bytes(), &parsed_hash) {
+            Ok(..) => Ok(true),
+            Err(..) => Ok(false),
+        }
     }
 }
 
-impl UserService for DefaultUserService {}
+#[async_trait]
+impl UserService for DefaultUserService {
+    async fn add_user(&self, username: String, password: String) -> anyhow::Result<String> {
+        let hashed_password = self.hash_password(password)?;
+
+        let rec = sqlx::query!(
+            r#"
+            INSERT INTO users (username, password_hash) 
+            VALUES ( $1, $2 ) 
+            RETURNING id
+            "#,
+            username,
+            hashed_password
+        )
+        .fetch_one(&self.pool)
+        .await?;
+
+        Ok(rec.id.to_string())
+    }
+
+    async fn validate_user(
+        &self,
+        username: String,
+        password: String,
+    ) -> anyhow::Result<Option<String>> {
+        let rec = sqlx::query!(
+            r#"
+            SELECT * from users
+            where username=$1
+            "#,
+            username,
+        )
+        .fetch_optional(&self.pool)
+        .await?;
+
+        match rec {
+            Some(user) => match self.validate_password(password, user.password_hash)? {
+                true => Ok(Some(user.id.to_string())),
+                false => Ok(None),
+            },
+            None => Ok(None),
+        }
+    }
+}