Die Tabellen Benutzer, Rollen und Gruppen hinzugefügt

src/domain/rolle/entity/rolle.rs

@@ -5,5 +5,5 @@ pub struct Rolle {
     pub id: Id,
     pub created_at: Time,
     pub updated_at: Time,
-    pub name: String,
+    pub rollenname: String,
 }

src/domain/rolle/model.rs

@@ -2,5 +2,6 @@ mod rolle;
 mod rolle_create_input;
 mod rolle_update_input;
 
+pub use rolle::Gruppe;
 pub use rolle::Rolle;
 pub use rolle_create_input::RolleCreateInput;

src/domain/rolle/model/rolle.rs

@@ -2,17 +2,35 @@ use async_graphql::SimpleObject;
 
 use crate::scalar::{Id, Time};
 
-#[derive(Debug, SimpleObject)]
+#[derive(Debug, SimpleObject, sqlx::FromRow)]
 pub struct Rolle {
     /// Die ID einer Rolle
     pub id: Id,
 
-    /// Wann die Rolle erstellt wurde
+    /// Zeit wann die Rolle erstellt wurde
     pub created_at: Time,
 
-    /// Wann die Rolle geändert wurde
+    /// Zeit wann die Rolle geändert wurde
     pub updated_at: Time,
 
     /// Der Name einer Rolle
-    pub name: String,
+    pub rollenname: String,
+
+    pub gruppen: Vec<Gruppe>,
+}
+
+/// TODO: Migration in ein separates Modul
+#[derive(Debug, SimpleObject, sqlx::Type)]
+pub struct Gruppe {
+    /// Die ID einer Gruppe
+    pub id: Id,
+
+    /// Zeit wann die Gruppe erstellt wurde
+    pub created_at: Time,
+
+    ///Zeit wann die Gruppe geändert wurde
+    pub updated_at: Time,
+
+    /// Der Name einer Gruppe
+    pub gruppenname: String,
 }

src/domain/rolle/model/rolle_create_input.rs

@@ -3,5 +3,5 @@ use async_graphql::InputObject;
 #[derive(InputObject)]
 pub struct RolleCreateInput {
     /// Der Name einer Rolle
-    pub name: String,
+    pub rollenname: String,
 }

src/domain/rolle/model/rolle_update_input.rs

@@ -8,5 +8,5 @@ pub struct RolleUpdateInput {
     pub id: Id,
 
     /// Der Name einer Rolle
-    pub name: String,
+    pub rollenname: String,
 }

src/domain/rolle/repository/create_rolle.rs

@@ -1,23 +1,24 @@
 use anyhow::Error;
 
 use super::Repository;
-// use crate::domain::rolle::model;
-use crate::{database::Queryer, domain::rolle::entity};
+use crate::database::Queryer;
+use crate::domain::rolle::entity;
+use crate::scalar::Id;
 
 impl Repository {
     pub async fn create_rolle<'c, C: Queryer<'c>>(
         &self,
         db: C,
         rolle: &entity::Rolle,
-    ) -> Result<entity::Rolle, Error> {
+    ) -> Result<Id, Error> {
         const QUERY: &str = "insert into rolle (id, created_at, updated_at,
-                              name) values ($1, $2, $3, $4) returning *";
+                              name) values ($1, $2, $3, $4) returning id";
 
-        match sqlx::query_as::<_, entity::Rolle>(QUERY)
+        match sqlx::query_scalar::<_, Id>(QUERY)
             .bind(rolle.id)
             .bind(rolle.created_at)
             .bind(rolle.updated_at)
-            .bind(&rolle.name)
+            .bind(&rolle.rollenname)
             .fetch_one(db)
             .await
         {
@@ -25,7 +26,7 @@ impl Repository {
                 tracing::error!("{}", &err);
                 Err(err.into())
             }
-            Ok(user) => Ok(user),
+            Ok(id) => Ok(id),
         }
     }
 }

src/domain/rolle/repository/find_rolle_by_id.rs

@@ -0,0 +1,47 @@
+use anyhow::Error;
+
+use super::Repository;
+use crate::database::Queryer;
+use crate::domain::rolle::model::{self};
+use crate::scalar::Id;
+
+impl Repository {
+    pub async fn find_rolle_by_id<'c, C: Queryer<'c>>(
+        &self,
+        db: C,
+        id: Id,
+    ) -> Result<model::Rolle, Error> {
+        const QUERY: &str = r#"
+             select
+               r.id, r.created_at, r.updated_at, r.rollenname,
+              (g.id, g.created_at, g.updated_at, g.gruppenname) as "gruppen!: Vec<model::Gruppe>"
+             from rollen as r
+             join rollen_gruppen as rg on rg.rolle_id = r.id
+             join gruppen as g on rg.gruppe_id = g.id
+             where r.id = $1;
+         "#;
+
+        let row = sqlx::query_as::<_, model::Rolle>(QUERY)
+            .bind(id)
+            .fetch_one(db)
+            .await?;
+
+        // let row = sqlx::query_as!(
+        //     model::Rolle,
+        //     r#"
+        //      select
+        //        r.id, r.created_at, r.updated_at, r.rollenname,
+        //       (g.id, g.created_at, g.updated_at, g.gruppenname) as "gruppen!: Vec<model::Gruppe>"
+        //      from rollen as r
+        //      join rollen_gruppen as rg on rg.rolle_id = r.id
+        //      join gruppen as g on rg.gruppe_id = g.id
+        //      where r.id = $1;
+        //  "#,
+        //     id
+        // )
+        // .fetch_one(db)
+        // .await?;
+
+        Ok(row)
+    }
+}

src/domain/rolle/service/create_user.rs

@@ -3,11 +3,11 @@ use chrono::Utc;
 use ulid::Ulid;
 
 use super::Service;
-use crate::domain::rolle::entity;
 use crate::domain::rolle::model::RolleCreateInput;
+use crate::domain::rolle::{entity, model};
 
 impl Service {
-    pub async fn create_rolle(&self, input: RolleCreateInput) -> Result<entity::Rolle, Error> {
+    pub async fn create_rolle(&self, input: RolleCreateInput) -> Result<model::Rolle, Error> {
         // let username_exists = self.check_username_exists(&self.db, &input.name).await?;
         // if username_exists {
         //     return Err(Error::UsernameAlreadyExists.into());
@@ -15,12 +15,13 @@ impl Service {
 
         let rolle_input = entity::Rolle {
             id: Ulid::new().into(),
-            name: input.name,
+            rollenname: input.rollenname,
             created_at: Utc::now(),
             updated_at: Utc::now(),
         };
 
-        let rolle = self.repo.create_rolle(&self.db, &rolle_input).await?;
+        let created_id = self.repo.create_rolle(&self.db, &rolle_input).await?;
+        let rolle = self.repo.find_rolle_by_id(&self.db, created_id).await?;
         Ok(rolle)
     }
 }