create gruppen, rollen, etc...

src/domain/benutzer.rs

@@ -0,0 +1,5 @@
+pub mod dataloader;
+pub mod entity;
+pub mod model;
+pub mod repository;
+pub mod service;

src/domain/benutzer/entity.rs

@@ -0,0 +1,3 @@
+pub mod benutzer;
+
+pub use benutzer::Benutzer;

src/domain/benutzer/entity/benutzer.rs

@@ -0,0 +1,8 @@
+use crate::scalar::Id;
+
+pub struct Benutzer {
+    pub id: Id,
+    pub kennung: String,
+    pub nachname: String,
+    pub vorname: String,
+}

src/domain/benutzer/model.rs

@@ -0,0 +1,5 @@
+pub mod benutzer;
+pub mod benutzer_create_input;
+
+pub use benutzer::Benutzer;
+pub use benutzer_create_input::BenutzerCreateInput;

src/domain/benutzer/model/benutzer.rs

@@ -0,0 +1,48 @@
+use async_graphql::{ComplexObject, Context, FieldResult, SimpleObject};
+
+use crate::{
+    dataloader::LoaderContext,
+    domain::{gruppe::model::Gruppe, rolle::model::Rolle},
+    models::gruppe_ansicht::GruppeAnsicht,
+    scalar::Id,
+};
+
+#[derive(sqlx::FromRow, SimpleObject)]
+#[graphql(complex)]
+pub struct Benutzer {
+    /// Die UUID eines Benutzers
+    pub id: Id,
+
+    /// Die Kennung des Benutzers
+    pub kennung: String,
+
+    /// Der Vorname des Benutzers
+    pub vorname: String,
+
+    /// Der Nachname des Benutzers
+    pub nachname: String,
+}
+
+#[ComplexObject]
+impl Benutzer {
+    /// Die Rollen des Benutzers
+    pub async fn rollen<'ctx>(&self, ctx: &Context<'ctx>) -> FieldResult<Option<Vec<Rolle>>> {
+        let loader = ctx.data::<LoaderContext>()?;
+        Ok(loader.rollen.load_one(self.id).await?)
+    }
+
+    /// Die Gruppen des Benutzers
+    pub async fn gruppen<'ctx>(&self, ctx: &Context<'ctx>) -> FieldResult<Option<Vec<Gruppe>>> {
+        let loader = ctx.data::<LoaderContext>()?;
+        Ok(loader.gruppen.load_one(self.id).await?)
+    }
+
+    /// Die Gruppen eines Benutzer kumulativ mit den Gruppen aus den Rollen
+    pub async fn gruppen_kumulativ<'ctx>(
+        &self,
+        ctx: &Context<'ctx>,
+    ) -> FieldResult<Option<Vec<GruppeAnsicht>>> {
+        let loader = ctx.data::<LoaderContext>()?;
+        Ok(loader.benutzer_gruppen_kumulativ.load_one(self.id).await?)
+    }
+}

src/domain/benutzer/model/benutzer_create_input.rs

@@ -0,0 +1,12 @@
+use crate::scalar::Id;
+use async_graphql::InputObject;
+
+#[derive(InputObject)]
+pub struct BenutzerCreateInput {
+    // #[graphql(validator(min_length = 6, max_length = 8))]
+    pub kennung: String,
+    pub vorname: String,
+    pub nachname: String,
+    pub rollen: Option<Vec<Id>>,
+    pub gruppen: Option<Vec<Id>>,
+}

src/domain/benutzer/repository.rs

@@ -0,0 +1,18 @@
+mod alle_benutzer;
+pub mod create_benutzer;
+pub mod find_gruppen;
+
+#[derive(Debug, Clone)]
+pub struct Repository {}
+
+impl Repository {
+    pub fn new() -> Repository {
+        Repository {}
+    }
+}
+
+impl Default for Repository {
+    fn default() -> Self {
+        Self::new()
+    }
+}

src/domain/benutzer/repository/alle_benutzer.rs

@@ -0,0 +1,23 @@
+use anyhow::Error;
+
+use super::Repository;
+use crate::database::Queryer;
+use crate::domain::benutzer::model;
+
+impl Repository {
+    pub async fn alle_benutzer<'c, C: Queryer<'c>>(
+        &self,
+        db: C,
+    ) -> Result<Vec<model::Benutzer>, Error> {
+        const QUERY: &str = r#"
+            SELECT *
+            FROM benutzer
+        "#;
+
+        let benutzer = sqlx::query_as::<_, model::Benutzer>(QUERY)
+            .fetch_all(db)
+            .await?;
+
+        Ok(benutzer)
+    }
+}

src/domain/benutzer/repository/create_benutzer.rs

@@ -0,0 +1,31 @@
+use anyhow::Error;
+
+use super::Repository;
+use crate::database::Queryer;
+use crate::domain::benutzer::entity;
+use crate::domain::benutzer::model;
+use crate::scalar::Id;
+
+impl Repository {
+    pub async fn create_benutzer<'c, C: Queryer<'c>>(
+        &self,
+        db: C,
+        benutzer: &entity::Benutzer,
+    ) -> Result<model::Benutzer, Error> {
+        const QUERY: &str = r#"
+            INSERT INTO benutzer (id, kennung, nachname, vorname)
+            VALUES ($1, $2, $3, $4)
+            RETURNING id, kennung, nachname, vorname;
+        "#;
+
+        let benutzer = sqlx::query_as::<_, model::Benutzer>(QUERY)
+            .bind::<Id>(benutzer.id)
+            .bind(&benutzer.kennung)
+            .bind(&benutzer.nachname)
+            .bind(&benutzer.vorname)
+            .fetch_one(db)
+            .await?;
+
+        Ok(benutzer)
+    }
+}

src/domain/benutzer/repository/find_gruppen.rs

@@ -0,0 +1,40 @@
+use anyhow::Error;
+use async_graphql::Context;
+
+use crate::domain::gruppe::model::Gruppe;
+
+use super::Repository;
+
+impl Repository {
+    pub async fn find_gruppen<'a>(&self, ctx: &'a Context<'_>) -> Result<Vec<Gruppe>, Error> {
+        //     let rows = sqlx::query!(
+        //         r#"
+        //             SELECT
+        //                 bg.benutzer_id,
+        //                 g.id,
+        //                 g.gruppenname,
+        //                 g.erstellt_am
+        //             LEFT JOIN benutzer_gruppen AS bg ON g.id = bg.gruppe_id
+        //             WHERE bg.benutzer_id = ANY($1);
+        //         "#,
+        //         keys
+        //     )
+        //     .fetch_all(&self.pool)
+        //     .await?
+        //     .into_iter()
+        //     .map(|row| {
+        //         (
+        //             row.benutzer_id,
+        //             Gruppe {
+        //                 id: row.id,
+        //                 gruppenname: row.gruppenname,
+        //                 erstellt_am: row.erstellt_am,
+        //                 geaendert_am: row.geaendert_am,
+        //             },
+        //         )
+        //     })
+        //     .into_group_map();
+        // }
+        todo!()
+    }
+}

src/domain/benutzer/service.rs

@@ -0,0 +1,18 @@
+mod alle_benutzer;
+pub mod create_benutzer;
+
+use super::repository::Repository;
+use crate::database::DB;
+
+#[derive(Debug)]
+pub struct Service {
+    repo: Repository,
+    pub db: DB,
+}
+
+impl Service {
+    pub fn new(db: DB) -> Self {
+        let repo = Repository::new();
+        Self { repo, db }
+    }
+}

src/domain/benutzer/service/alle_benutzer.rs

@@ -0,0 +1,11 @@
+use async_graphql::FieldResult;
+
+use crate::domain::benutzer::model::Benutzer;
+
+use super::Service;
+
+impl Service {
+    pub async fn alle_benutzer(&self) -> FieldResult<Vec<Benutzer>> {
+        Ok(self.repo.alle_benutzer(&self.db).await?)
+    }
+}

src/domain/benutzer/service/create_benutzer.rs

@@ -0,0 +1,25 @@
+use async_graphql::FieldResult;
+use ulid::Ulid;
+
+use crate::domain::benutzer::{
+    entity,
+    model::{Benutzer, BenutzerCreateInput},
+};
+
+use super::Service;
+
+impl Service {
+    pub async fn create_benutzer(&self, input: BenutzerCreateInput) -> FieldResult<Benutzer> {
+        let benutzer_entity = entity::Benutzer {
+            id: Ulid::new().into(),
+            kennung: input.kennung,
+            nachname: input.nachname,
+            vorname: input.vorname,
+        };
+
+        Ok(self
+            .repo
+            .create_benutzer(&self.db, &benutzer_entity)
+            .await?)
+    }
+}

src/domain/gruppe.rs

@@ -0,0 +1,5 @@
+pub mod dataloader;
+pub mod entity;
+pub mod model;
+pub mod repository;
+pub mod service;

src/domain/gruppe/dataloader.rs

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

src/domain/gruppe/dataloader/gruppen.rs

@@ -0,0 +1,24 @@
+use async_graphql::dataloader::*;
+use async_graphql::*;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use crate::domain::gruppe::model::Gruppe;
+use crate::domain::gruppe::service::Service;
+use crate::scalar::Id;
+
+pub struct GruppenLoader {
+    pub pool: sqlx::PgPool,
+}
+
+impl Loader<Id> for GruppenLoader {
+    type Value = Vec<Gruppe>;
+    type Error = Arc<sqlx::Error>;
+
+    async fn load(&self, keys: &[Id]) -> Result<HashMap<Id, Self::Value>, Self::Error> {
+        let rows = Service::new(self.pool.clone())
+            .gruppe_dataloader(keys)
+            .await?;
+        Ok(rows)
+    }
+}

src/domain/gruppe/entity.rs

@@ -0,0 +1,2 @@
+pub mod gruppe;
+pub use gruppe::Gruppe;

src/domain/gruppe/entity/gruppe.rs

@@ -0,0 +1,8 @@
+use crate::scalar::{Id, Time};
+
+pub struct Gruppe {
+    pub id: Id,
+    pub gruppenname: String,
+    pub erstellt_am: Option<Time>,
+    pub geaendert_am: Option<Time>,
+}

src/domain/gruppe/model.rs

@@ -0,0 +1,7 @@
+pub mod gruppe;
+pub mod gruppe_erstelle_input;
+pub mod gruppe_update_input;
+
+pub use gruppe::Gruppe;
+pub use gruppe_erstelle_input::GruppeErstelleInput;
+pub use gruppe_update_input::GruppeUpdateInput;

src/domain/gruppe/model/gruppe.rs

@@ -0,0 +1,22 @@
+use async_graphql::{ComplexObject, SimpleObject};
+
+use crate::scalar::{Id, Time};
+
+#[derive(sqlx::FromRow, SimpleObject, Clone, Debug)]
+#[graphql(complex)]
+pub struct Gruppe {
+    /// Die UUIDl einer Gruppe
+    pub id: Id,
+
+    /// Der Gruppenname
+    pub gruppenname: String,
+
+    /// Wann die Gruppe erstellt wurde
+    pub erstellt_am: Time,
+
+    /// Wann die Gruppe geaendert wurde
+    pub geaendert_am: Time,
+}
+
+#[ComplexObject]
+impl Gruppe {}

src/domain/gruppe/model/gruppe_erstelle_input.rs

@@ -0,0 +1,7 @@
+use async_graphql::InputObject;
+
+#[derive(InputObject)]
+pub struct GruppeErstelleInput {
+    /// Der Name einer Gruppe
+    pub gruppenname: String,
+}

src/domain/gruppe/model/gruppe_update_input.rs

@@ -0,0 +1,7 @@
+use async_graphql::InputObject;
+
+#[derive(InputObject)]
+pub struct GruppeUpdateInput {
+    /// Der Name einer Gruppe
+    pub gruppenname: String,
+}

src/domain/gruppe/repository.rs

@@ -0,0 +1,19 @@
+mod gruppe_alle;
+mod gruppe_dataloader;
+mod gruppe_erstellen;
+mod gruppe_update;
+
+#[derive(Debug, Clone)]
+pub struct Repository {}
+
+impl Repository {
+    pub fn new() -> Repository {
+        Repository {}
+    }
+}
+
+impl Default for Repository {
+    fn default() -> Self {
+        Self::new()
+    }
+}

src/domain/gruppe/repository/gruppe_alle.rs

@@ -0,0 +1,21 @@
+use anyhow::Error;
+
+use super::Repository;
+use crate::{database::Queryer, domain::gruppe::model};
+
+impl Repository {
+    pub async fn gruppe_alle<'c, C: Queryer<'c>>(
+        &self,
+        db: C,
+    ) -> Result<Vec<model::Gruppe>, Error> {
+        const QUERY: &str = r#"
+            SELECT * FROM gruppen
+        "#;
+
+        let gruppen = sqlx::query_as::<_, model::Gruppe>(QUERY)
+            .fetch_all(db)
+            .await?;
+
+        Ok(gruppen)
+    }
+}

src/domain/gruppe/repository/gruppe_dataloader.rs

@@ -0,0 +1,49 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use itertools::Itertools;
+
+use super::Repository;
+use crate::database::Queryer;
+use crate::domain::gruppe::model::Gruppe;
+use crate::scalar::Id;
+
+impl Repository {
+    pub async fn gruppe_dataloader<'c, C: Queryer<'c>>(
+        &self,
+        db: C,
+        keys: &[Id],
+    ) -> Result<HashMap<Id, Vec<Gruppe>>, Arc<sqlx::Error>> {
+        let rows = sqlx::query!(
+            r#"
+                SELECT
+                    bg.benutzer_id,
+                    g.id,
+                    g.gruppenname,
+                    g.erstellt_am,
+                    g.geaendert_am
+                FROM gruppen AS g
+                LEFT JOIN benutzer_gruppen AS bg ON g.id = bg.gruppe_id
+                WHERE bg.benutzer_id = ANY($1);
+            "#,
+            keys
+        )
+        .fetch_all(db)
+        .await?
+        .into_iter()
+        .map(|row| {
+            (
+                row.benutzer_id,
+                Gruppe {
+                    id: row.id,
+                    gruppenname: row.gruppenname,
+                    erstellt_am: row.erstellt_am,
+                    geaendert_am: row.geaendert_am,
+                },
+            )
+        })
+        .into_group_map();
+
+        Ok(rows)
+    }
+}

src/domain/gruppe/repository/gruppe_erstellen.rs

@@ -0,0 +1,29 @@
+use anyhow::Error;
+
+use super::Repository;
+use crate::database::Queryer;
+use crate::domain::gruppe::{entity, model};
+
+impl Repository {
+    pub async fn gruppe_erstellen<'c, C: Queryer<'c>>(
+        &self,
+        db: C,
+        gruppe: &entity::Gruppe,
+    ) -> Result<model::Gruppe, Error> {
+        const QUERY: &str = r#"
+            INSERT INTO gruppen (id, erstellt_am, geaendert_am, gruppenname) VALUES (
+                $1, $2, $3, $4
+            ) RETURNING id, erstellt_am, geaendert_am, gruppenname;
+        "#;
+
+        let gruppe = sqlx::query_as::<_, model::Gruppe>(QUERY)
+            .bind(gruppe.id)
+            .bind(gruppe.erstellt_am)
+            .bind(gruppe.geaendert_am)
+            .bind(&gruppe.gruppenname)
+            .fetch_one(db)
+            .await?;
+
+        Ok(gruppe)
+    }
+}

src/domain/gruppe/repository/gruppe_update.rs

@@ -0,0 +1,28 @@
+use anyhow::Error;
+
+use super::Repository;
+use crate::database::Queryer;
+use crate::domain::gruppe::{entity, model};
+
+impl Repository {
+    pub async fn gruppe_update<'c, C: Queryer<'c>>(
+        &self,
+        db: C,
+        gruppe: &entity::Gruppe,
+    ) -> Result<model::Gruppe, Error> {
+        const QUERY: &str = r#"
+            UPDATE gruppen
+            SET geaendert_am = $2, ruppenname = $3 WHERE gruppeid = $1
+            RETURNING id, geaendert_am, gruppenname, gruppenname;
+        "#;
+
+        let gruppe = sqlx::query_as::<_, model::Gruppe>(QUERY)
+            .bind(gruppe.id)
+            .bind(gruppe.geaendert_am)
+            .bind(&gruppe.gruppenname)
+            .fetch_one(db)
+            .await?;
+
+        Ok(gruppe)
+    }
+}

src/domain/gruppe/service.rs

@@ -0,0 +1,20 @@
+mod gruppe_alle;
+mod gruppe_dataloader;
+mod gruppe_erstellen;
+mod gruppe_update;
+
+use super::repository::Repository;
+use crate::database::DB;
+
+#[derive(Debug)]
+pub struct Service {
+    repo: Repository,
+    pub db: DB,
+}
+
+impl Service {
+    pub fn new(db: DB) -> Self {
+        let repo = Repository::new();
+        Self { repo, db }
+    }
+}

src/domain/gruppe/service/gruppe_alle.rs

@@ -0,0 +1,12 @@
+use anyhow::Error;
+
+use crate::domain::gruppe::model;
+
+use super::Service;
+
+impl Service {
+    pub async fn gruppe_alle(&self) -> Result<Vec<model::Gruppe>, Error> {
+        let gruppe = self.repo.gruppe_alle(&self.db).await?;
+        Ok(gruppe)
+    }
+}

src/domain/gruppe/service/gruppe_dataloader.rs

@@ -0,0 +1,15 @@
+use std::{collections::HashMap, sync::Arc};
+
+use crate::{domain::gruppe::model::Gruppe, scalar::Id};
+
+use super::Service;
+
+impl Service {
+    pub async fn gruppe_dataloader(
+        &self,
+        keys: &[Id],
+    ) -> Result<HashMap<Id, Vec<Gruppe>>, Arc<sqlx::Error>> {
+        let grupen_dataloader = self.repo.gruppe_dataloader(&self.db, keys).await?;
+        Ok(grupen_dataloader)
+    }
+}

src/domain/gruppe/service/gruppe_erstellen.rs

@@ -0,0 +1,26 @@
+use anyhow::Error;
+use chrono::Utc;
+use ulid::Ulid;
+
+use super::Service;
+use crate::domain::gruppe::{
+    entity,
+    model::{self, GruppeErstelleInput},
+};
+
+impl Service {
+    pub async fn gruppe_erstellen(
+        &self,
+        input: GruppeErstelleInput,
+    ) -> Result<model::Gruppe, Error> {
+        let gruppe_input = entity::Gruppe {
+            id: Ulid::new().into(),
+            gruppenname: input.gruppenname,
+            erstellt_am: Some(Utc::now()),
+            geaendert_am: Some(Utc::now()),
+        };
+
+        let gruppe = self.repo.gruppe_erstellen(&self.db, &gruppe_input).await?;
+        Ok(gruppe)
+    }
+}

src/domain/gruppe/service/gruppe_update.rs

@@ -0,0 +1,23 @@
+use anyhow::Error;
+use chrono::Utc;
+use ulid::Ulid;
+
+use super::Service;
+use crate::domain::gruppe::{
+    entity,
+    model::{self, GruppeUpdateInput},
+};
+
+impl Service {
+    pub async fn gruppe_update(&self, input: GruppeUpdateInput) -> Result<model::Gruppe, Error> {
+        let gruppe_input = entity::Gruppe {
+            id: Ulid::new().into(),
+            gruppenname: input.gruppenname,
+            erstellt_am: None,
+            geaendert_am: Some(Utc::now()),
+        };
+
+        let gruppe = self.repo.gruppe_erstellen(&self.db, &gruppe_input).await?;
+        Ok(gruppe)
+    }
+}

src/domain/rolle.rs

@@ -1,5 +1,5 @@
+pub mod dataloader;
 pub mod entity;
 pub mod model;
-pub mod mutation;
 pub mod repository;
 pub mod service;

src/domain/rolle/dataloader.rs

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

src/domain/rolle/dataloader/rollen.rs

@@ -0,0 +1,51 @@
+use async_graphql::dataloader::*;
+use async_graphql::*;
+use itertools::Itertools;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use crate::domain::rolle::model::Rolle;
+use crate::scalar::Id;
+
+pub struct RollenLoader {
+    pub pool: sqlx::PgPool,
+}
+
+impl Loader<Id> for RollenLoader {
+    type Value = Vec<Rolle>;
+    type Error = Arc<sqlx::Error>;
+
+    async fn load(&self, keys: &[Id]) -> Result<HashMap<Id, Self::Value>, Self::Error> {
+        let rows = sqlx::query!(
+            r#"
+                SELECT
+                    br.benutzer_id,
+                    r.id,
+                    r.rollenname,
+                    r.erstellt_am,
+                    r.geaendert_am
+                FROM rollen AS r
+                LEFT JOIN benutzer_rollen AS br ON r.id = br.rolle_id
+                WHERE br.benutzer_id = ANY($1);
+            "#,
+            keys
+        )
+        .fetch_all(&self.pool)
+        .await?
+        .into_iter()
+        .map(|row| {
+            (
+                row.benutzer_id,
+                Rolle {
+                    id: row.id,
+                    rollenname: row.rollenname,
+                    erstellt_am: row.erstellt_am,
+                    geaendert_am: row.geaendert_am,
+                },
+            )
+        })
+        .into_group_map();
+
+        Ok(rows)
+    }
+}

src/domain/rolle/entity/rolle.rs

@@ -1,9 +1,8 @@
 use crate::scalar::{Id, Time};
 
-#[derive(sqlx::FromRow)]
 pub struct Rolle {
     pub id: Id,
-    pub created_at: Time,
-    pub updated_at: Time,
     pub rollenname: String,
+    pub erstellt_am: Time,
+    pub geaendert_am: Time,
 }

src/domain/rolle/model.rs

@@ -2,6 +2,5 @@ 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

@@ -1,36 +1,33 @@
-use async_graphql::SimpleObject;
+use async_graphql::{ComplexObject, Context, FieldResult, SimpleObject};
 
-use crate::scalar::{Id, Time};
+use crate::{
+    dataloader::LoaderContext,
+    domain::gruppe::model::Gruppe,
+    scalar::{Id, Time},
+};
 
-#[derive(Debug, SimpleObject, sqlx::FromRow)]
+/// Um die Administration zu erleichtern werden Gruppen in die Rollen hinzugefuegt
+#[derive(sqlx::FromRow, SimpleObject, Debug, Clone)]
+#[graphql(complex)]
 pub struct Rolle {
-    /// Die ID einer Rolle
+    /// Die  uuid einer Rolle
     pub id: Id,
 
-    /// Zeit wann die Rolle erstellt wurde
-    pub created_at: Time,
-
-    /// Zeit wann die Rolle geändert wurde
-    pub updated_at: Time,
-
-    /// Der Name einer Rolle
+    /// Der Rollenname
     pub rollenname: String,
 
-    pub gruppen: Vec<Gruppe>,
+    /// Wann die Rolle erstellt wurde
+    pub erstellt_am: Time,
+
+    /// Wann die Rolle geaendert wurde
+    pub geaendert_am: Time,
 }
 
-/// 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,
+#[ComplexObject]
+impl Rolle {
+    /// Die Gruppen in einer Rolle
+    pub async fn gruppen<'ctx>(&self, ctx: &Context<'ctx>) -> FieldResult<Option<Vec<Gruppe>>> {
+        let loader = ctx.data::<LoaderContext>()?;
+        Ok(loader.gruppen.load_one(self.id).await?)
+    }
 }

src/domain/rolle/repository.rs

@@ -2,6 +2,7 @@ mod create_rolle;
 mod delete_rolle;
 mod find_all_rolle;
 mod find_rolle_by_id;
+mod rollen_dataloader;
 mod update_rolle;
 
 #[derive(Debug, Clone)]

src/domain/rolle/repository/create_rolle.rs

@@ -16,8 +16,8 @@ impl Repository {
 
         match sqlx::query_scalar::<_, Id>(QUERY)
             .bind(rolle.id)
-            .bind(rolle.created_at)
-            .bind(rolle.updated_at)
+            .bind(rolle.erstellt_am)
+            .bind(rolle.geaendert_am)
             .bind(&rolle.rollenname)
             .fetch_one(db)
             .await

src/domain/rolle/repository/rollen_dataloader.rs

@@ -0,0 +1,49 @@
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use itertools::Itertools;
+
+use super::Repository;
+use crate::database::Queryer;
+use crate::domain::rolle::model::Rolle;
+use crate::scalar::Id;
+
+impl Repository {
+    pub async fn rollen_dataloader<'c, C: Queryer<'c>>(
+        &self,
+        db: C,
+        keys: &[Id],
+    ) -> Result<HashMap<Id, Vec<Rolle>>, Arc<sqlx::Error>> {
+        let rows = sqlx::query!(
+            r#"
+                SELECT
+                    br.benutzer_id,
+                    r.id,
+                    r.rollenname,
+                    r.erstellt_am,
+                    r.geaendert_am
+                FROM rollen AS r
+                LEFT JOIN benutzer_rollen AS br ON r.id = br.rolle_id
+                WHERE br.benutzer_id = ANY($1);
+            "#,
+            keys
+        )
+        .fetch_all(db)
+        .await?
+        .into_iter()
+        .map(|row| {
+            (
+                row.benutzer_id,
+                Rolle {
+                    id: row.id,
+                    rollenname: row.rollenname,
+                    erstellt_am: row.erstellt_am,
+                    geaendert_am: row.geaendert_am,
+                },
+            )
+        })
+        .into_group_map();
+
+        Ok(rows)
+    }
+}

src/domain/rolle/service/create_user.rs

@@ -16,8 +16,8 @@ impl Service {
         let rolle_input = entity::Rolle {
             id: Ulid::new().into(),
             rollenname: input.rollenname,
-            created_at: Utc::now(),
-            updated_at: Utc::now(),
+            erstellt_am: Utc::now(),
+            geaendert_am: Utc::now(),
         };
 
         let created_id = self.repo.create_rolle(&self.db, &rolle_input).await?;