diff --git a/migrations/20240530183519_init.down.sql b/migrations/20240530183519_init.down.sql
index b3180c1..927abf1 100644
--- a/migrations/20240530183519_init.down.sql
+++ b/migrations/20240530183519_init.down.sql
@@ -1 +1,3 @@
-DROP DOMAIN ULID CASCADE;
+DROP DOMAIN ulid CASCADE;
+DROP EXTENSION IF EXISTS ltree;
+DROP EXTENSION IF EXISTS "uuid-ossp";
diff --git a/migrations/20240530183519_init.up.sql b/migrations/20240530183519_init.up.sql
index 7376d6c..c8820b9 100644
--- a/migrations/20240530183519_init.up.sql
+++ b/migrations/20240530183519_init.up.sql
@@ -1 +1,3 @@
-CREATE DOMAIN ULID AS CHAR(26);
+CREATE DOMAIN ulid AS CHAR(26);
+CREATE EXTENSION IF NOT EXISTS ltree;
+CREATE EXTENSION IF NOT EXISTS "uuid-ossp";
diff --git a/migrations/20240530193528_hersteller.up.sql b/migrations/20240530193528_hersteller.up.sql
index 3f31597..bc1e778 100644
--- a/migrations/20240530193528_hersteller.up.sql
+++ b/migrations/20240530193528_hersteller.up.sql
@@ -1,6 +1,6 @@
 CREATE TABLE IF NOT EXISTS hersteller (
     hersteller_id UUID PRIMARY KEY,
-    id CHAR(26) UNIQUE NOT NULL,
+    id ULID UNIQUE NOT NULL,
     herstellername VARCHAR NOT NULL,
     erstellt_am TIMESTAMP WITH TIME ZONE NOT NULL,
     geaendert_am TIMESTAMP WITH TIME ZONE NOT NULL
diff --git a/migrations/20240621222501_gruppen.up.sql b/migrations/20240621222501_gruppen.up.sql
index 196dac2..5f79c4a 100644
--- a/migrations/20240621222501_gruppen.up.sql
+++ b/migrations/20240621222501_gruppen.up.sql
@@ -1,5 +1,6 @@
 CREATE TABLE IF NOT EXISTS gruppen (
-    id UUID PRIMARY KEY,
+    gruppe_id UUID PRIMARY KEY,
+    id ULID UNIQUE NOT NULL,
     gruppenname VARCHAR NOT NULL,
     erstellt_am TIMESTAMP WITH TIME ZONE NOT NULL,
     geaendert_am TIMESTAMP WITH TIME ZONE NOT NULL
diff --git a/migrations/20240621222504_rollen.up.sql b/migrations/20240621222504_rollen.up.sql
index 2612074..e7ecb1d 100644
--- a/migrations/20240621222504_rollen.up.sql
+++ b/migrations/20240621222504_rollen.up.sql
@@ -1,5 +1,6 @@
 CREATE TABLE IF NOT EXISTS rollen (
-    id UUID PRIMARY KEY,
+    rolle_id UUID PRIMARY KEY,
+    id ULID UNIQUE NOT NULL,
     rollenname VARCHAR NOT NULL,
     erstellt_am TIMESTAMP WITH TIME ZONE NOT NULL,
     geaendert_am TIMESTAMP WITH TIME ZONE NOT NULL
diff --git a/migrations/20240621223132_rollen_gruppen.up.sql b/migrations/20240621223132_rollen_gruppen.up.sql
index 1444497..2f6b4ef 100644
--- a/migrations/20240621223132_rollen_gruppen.up.sql
+++ b/migrations/20240621223132_rollen_gruppen.up.sql
@@ -5,12 +5,12 @@ CREATE TABLE IF NOT EXISTS rollen_gruppen (
     CONSTRAINT pk_rollen_gruppen PRIMARY KEY (rolle_id, gruppe_id),
 
     CONSTRAINT fk_rollen_gruppen_gruppe FOREIGN KEY (gruppe_id)
-    REFERENCES gruppen (id) MATCH SIMPLE
+    REFERENCES gruppen (gruppe_id) MATCH SIMPLE
     ON UPDATE CASCADE
     ON DELETE CASCADE,
 
     CONSTRAINT fk_rollen_gruppen_rolle FOREIGN KEY (rolle_id)
-    REFERENCES rollen (id) MATCH SIMPLE
+    REFERENCES rollen (rolle_id) MATCH SIMPLE
     ON UPDATE CASCADE
     ON DELETE CASCADE
 )
diff --git a/migrations/20241128220001_benutzer.up.sql b/migrations/20241128220001_benutzer.up.sql
index 3dc9f1a..4b5be59 100644
--- a/migrations/20241128220001_benutzer.up.sql
+++ b/migrations/20241128220001_benutzer.up.sql
@@ -1,5 +1,6 @@
 CREATE TABLE IF NOT EXISTS benutzer (
-    id UUID PRIMARY KEY,
+    benutzer_id UUID PRIMARY KEY,
+    id ULID UNIQUE NOT NULL,
     kennung VARCHAR NOT NULL,
     nachname VARCHAR NOT NULL,
     vorname VARCHAR NOT NULL,
diff --git a/migrations/20241128220014_benutzer_gruppen.up.sql b/migrations/20241128220014_benutzer_gruppen.up.sql
index 64dd843..c6aeca2 100644
--- a/migrations/20241128220014_benutzer_gruppen.up.sql
+++ b/migrations/20241128220014_benutzer_gruppen.up.sql
@@ -5,12 +5,12 @@ CREATE TABLE IF NOT EXISTS benutzer_gruppen (
     CONSTRAINT pk_benutzer_gruppen PRIMARY KEY (benutzer_id, gruppe_id),
 
     CONSTRAINT fk_benutzer_gruppen_benutzer FOREIGN KEY (benutzer_id)
-    REFERENCES benutzer (id) MATCH SIMPLE
+    REFERENCES benutzer (benutzer_id) MATCH SIMPLE
     ON UPDATE CASCADE
     ON DELETE CASCADE,
 
     CONSTRAINT fk_benutzer_gruppen_gruppe FOREIGN KEY (gruppe_id)
-    REFERENCES gruppen (id) MATCH SIMPLE
+    REFERENCES gruppen (gruppe_id) MATCH SIMPLE
     ON UPDATE CASCADE
     ON DELETE CASCADE
 )
diff --git a/migrations/20241128220018_benutzer_rollen.up.sql b/migrations/20241128220018_benutzer_rollen.up.sql
index 7e7cdc0..3b98a48 100644
--- a/migrations/20241128220018_benutzer_rollen.up.sql
+++ b/migrations/20241128220018_benutzer_rollen.up.sql
@@ -5,12 +5,12 @@ CREATE TABLE IF NOT EXISTS benutzer_rollen (
     CONSTRAINT pk_benutzer_rollen PRIMARY KEY (benutzer_id, rolle_id),
 
     CONSTRAINT fk_benutzer_rollen_benutzer FOREIGN KEY (benutzer_id)
-    REFERENCES benutzer (id) MATCH SIMPLE
+    REFERENCES benutzer (benutzer_id) MATCH SIMPLE
     ON UPDATE CASCADE
     ON DELETE CASCADE,
 
     CONSTRAINT fk_benutzer_rollen_rolle FOREIGN KEY (rolle_id)
-    REFERENCES rollen (id) MATCH SIMPLE
+    REFERENCES rollen (rolle_id) MATCH SIMPLE
     ON UPDATE CASCADE
     ON DELETE CASCADE
 )
diff --git a/migrations/20260528200947_struktur.down.sql b/migrations/20260528200947_struktur.down.sql
new file mode 100644
index 0000000..9b1b2b6
--- /dev/null
+++ b/migrations/20260528200947_struktur.down.sql
@@ -0,0 +1 @@
+DROP TABLE struktur;
diff --git a/migrations/20260528200947_struktur.up.sql b/migrations/20260528200947_struktur.up.sql
new file mode 100644
index 0000000..c128f1d
--- /dev/null
+++ b/migrations/20260528200947_struktur.up.sql
@@ -0,0 +1,8 @@
+CREATE TABLE IF NOT EXISTS strukturen (
+    id UUID PRIMARY KEY,
+    parent_id UUID REFERENCES strukturen (id),
+    dienststelle VARCHAR NOT NULL,
+    dienststelle_abk VARCHAR NOT NULL,
+    slug TEXT NOT NULL,
+    pfad LTREE
+);
diff --git a/src/domain.rs b/src/domain.rs
index 51f5645..5474880 100644
--- a/src/domain.rs
+++ b/src/domain.rs
@@ -1,4 +1,4 @@
-pub mod benutzer;
+// pub mod benutzer;
 pub mod gruppe;
 pub mod liegenschaft;
 pub mod rolle;
diff --git a/src/domain/benutzer/model/benutzer.rs b/src/domain/benutzer/model/benutzer.rs
index 16fa8dc..de67d55 100644
--- a/src/domain/benutzer/model/benutzer.rs
+++ b/src/domain/benutzer/model/benutzer.rs
@@ -3,14 +3,14 @@ use async_graphql::{ComplexObject, Context, FieldResult, SimpleObject};
 use crate::{
     dataloader::LoaderContext,
     domain::{gruppe::model::Gruppe, rolle::model::Rolle},
-    scalar::Id,
+    scalar::Ulid,
 };
 
 #[derive(sqlx::FromRow, SimpleObject)]
 #[graphql(complex)]
 pub struct Benutzer {
-    /// Die UUID eines Benutzers
-    pub id: Id,
+    /// Die ULid eines Benutzers
+    pub id: Ulid,
 
     /// Die Kennung des Benutzers
     pub kennung: String,
diff --git a/src/domain/benutzer/model/benutzer_create_input.rs b/src/domain/benutzer/model/benutzer_create_input.rs
index 3cf69d7..44c9f01 100644
--- a/src/domain/benutzer/model/benutzer_create_input.rs
+++ b/src/domain/benutzer/model/benutzer_create_input.rs
@@ -1,12 +1,13 @@
-use crate::scalar::Id;
 use async_graphql::InputObject;
 
+use crate::scalar::Ulid;
+
 #[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>>,
+    pub rollen: Option<Vec<Ulid>>,
+    pub gruppen: Option<Vec<Ulid>>,
 }
diff --git a/src/domain/benutzer/model/benutzer_gruppen_ansicht.rs b/src/domain/benutzer/model/benutzer_gruppen_ansicht.rs
index 273cc29..0ed7eaf 100644
--- a/src/domain/benutzer/model/benutzer_gruppen_ansicht.rs
+++ b/src/domain/benutzer/model/benutzer_gruppen_ansicht.rs
@@ -1,7 +1,7 @@
 use async_graphql::{ComplexObject, Enum, SimpleObject};
 use sqlx::Type;
 
-use crate::scalar::{Id, Time};
+use crate::scalar::{Time, Ulid};
 
 /// Aus welcher Quelle die Gruppe stammt.
 #[derive(Enum, Clone, Debug, Eq, Copy, PartialEq, Type)]
@@ -21,7 +21,7 @@ pub enum Herkunft {
 #[graphql(complex)]
 pub struct GruppeAnsicht {
     /// Die UUID einer Gruppe
-    pub id: Id,
+    pub id: Ulid,
 
     /// Der Gruppenname
     pub gruppenname: String,
diff --git a/src/domain/gruppe/dataloader/gruppen.rs b/src/domain/gruppe/dataloader/gruppen.rs
index ee6600f..1498b3d 100644
--- a/src/domain/gruppe/dataloader/gruppen.rs
+++ b/src/domain/gruppe/dataloader/gruppen.rs
@@ -5,17 +5,17 @@ use std::sync::Arc;
 
 use crate::domain::gruppe::model::Gruppe;
 use crate::domain::gruppe::service::Service;
-use crate::scalar::Id;
+use crate::scalar::Ulid;
 
 pub struct GruppenLoader {
     pub pool: sqlx::PgPool,
 }
 
-impl Loader<Id> for GruppenLoader {
+impl Loader<Ulid> for GruppenLoader {
     type Value = Vec<Gruppe>;
     type Error = Arc<sqlx::Error>;
 
-    async fn load(&self, keys: &[Id]) -> Result<HashMap<Id, Self::Value>, Self::Error> {
+    async fn load(&self, keys: &[Ulid]) -> Result<HashMap<Ulid, Self::Value>, Self::Error> {
         let rows = Service::new(self.pool.clone())
             .gruppe_dataloader(keys)
             .await?;
diff --git a/src/domain/gruppe/entity.rs b/src/domain/gruppe/entity.rs
index f351ba0..1dc20fd 100644
--- a/src/domain/gruppe/entity.rs
+++ b/src/domain/gruppe/entity.rs
@@ -1,2 +1,6 @@
 pub mod gruppe;
-pub use gruppe::Gruppe;
+
+pub use gruppe::GruppeDataloader;
+pub use gruppe::GruppeErstellen;
+pub use gruppe::GruppeLoeschen;
+pub use gruppe::GruppeUpdate;
diff --git a/src/domain/gruppe/entity/gruppe.rs b/src/domain/gruppe/entity/gruppe.rs
index a6b4678..4e1761b 100644
--- a/src/domain/gruppe/entity/gruppe.rs
+++ b/src/domain/gruppe/entity/gruppe.rs
@@ -1,8 +1,30 @@
-use crate::scalar::{Id, Time};
+use sqlx::FromRow;
 
-pub struct Gruppe {
-    pub id: Id,
+use crate::scalar::{Id, Time, Ulid};
+
+pub struct GruppeErstellen {
+    pub gruppe_id: Id,
+    pub id: Ulid,
     pub gruppenname: String,
-    pub erstellt_am: Option<Time>,
-    pub geaendert_am: Option<Time>,
+    pub erstellt_am: Time,
+    pub geaendert_am: Time,
+}
+
+pub struct GruppeLoeschen {
+    pub id: Ulid,
+}
+
+pub struct GruppeUpdate {
+    pub id: Ulid,
+    pub gruppenname: String,
+    pub geaendert_am: Time,
+}
+
+#[derive(Debug, FromRow)]
+pub struct GruppeDataloader {
+    pub r_ulid: Ulid,
+    pub g_ulid: Ulid,
+    pub gruppenname: String,
+    pub erstellt_am: Time,
+    pub geaendert_am: Time,
 }
diff --git a/src/domain/gruppe/model/gruppe.rs b/src/domain/gruppe/model/gruppe.rs
index 4ebb24f..126d287 100644
--- a/src/domain/gruppe/model/gruppe.rs
+++ b/src/domain/gruppe/model/gruppe.rs
@@ -1,12 +1,12 @@
 use async_graphql::{ComplexObject, SimpleObject};
 
-use crate::scalar::{Id, Time};
+use crate::scalar::{Time, Ulid};
 
 #[derive(sqlx::FromRow, SimpleObject, Clone, Debug)]
 #[graphql(complex)]
 pub struct Gruppe {
     /// Die UUID einer Gruppe
-    pub id: Id,
+    pub id: Ulid,
 
     /// Der Gruppenname
     pub gruppenname: String,
diff --git a/src/domain/gruppe/model/gruppe_loeschen_input.rs b/src/domain/gruppe/model/gruppe_loeschen_input.rs
index 8cdd858..acd8ea9 100644
--- a/src/domain/gruppe/model/gruppe_loeschen_input.rs
+++ b/src/domain/gruppe/model/gruppe_loeschen_input.rs
@@ -1,9 +1,9 @@
 use async_graphql::InputObject;
 
-use crate::scalar::Id;
+use crate::scalar::Ulid;
 
 #[derive(InputObject)]
 pub struct GruppeLoeschenInput {
-    /// Die ID einer Gruppe
-    pub id: Id,
+    /// Die ULID einer Gruppe
+    pub id: Ulid,
 }
diff --git a/src/domain/gruppe/model/gruppe_update_input.rs b/src/domain/gruppe/model/gruppe_update_input.rs
index 09094a5..8a87f9c 100644
--- a/src/domain/gruppe/model/gruppe_update_input.rs
+++ b/src/domain/gruppe/model/gruppe_update_input.rs
@@ -1,10 +1,10 @@
-use crate::scalar::Id;
+use crate::scalar::Ulid;
 use async_graphql::InputObject;
 
 #[derive(InputObject)]
 pub struct GruppeUpdateInput {
-    /// Die ID einer Gruppe
-    pub id: Id,
+    /// Die Ulid einer Gruppe
+    pub id: Ulid,
 
     /// Der Name einer Gruppe
     pub gruppenname: String,
diff --git a/src/domain/gruppe/repository/gruppe_dataloader.rs b/src/domain/gruppe/repository/gruppe_dataloader.rs
index 55ce765..17cb49f 100644
--- a/src/domain/gruppe/repository/gruppe_dataloader.rs
+++ b/src/domain/gruppe/repository/gruppe_dataloader.rs
@@ -1,48 +1,53 @@
+use itertools::Itertools;
 use std::collections::HashMap;
 use std::sync::Arc;
 
-use itertools::Itertools;
-
 use super::Repository;
+
 use crate::database::Queryer;
+use crate::domain::gruppe::entity::GruppeDataloader;
 use crate::domain::gruppe::model::Gruppe;
-use crate::scalar::Id;
+use crate::scalar::Ulid;
 
 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
-                    rg.rolle_id,
-                    g.id,
-                    g.gruppenname,
-                    g.erstellt_am,
-                    g.geaendert_am
-                FROM gruppen AS g
-                LEFT JOIN rollen_gruppen AS rg ON g.id = rg.gruppe_id
-                WHERE rg.rolle_id = ANY($1);
-            "#,
-            keys
-        )
-        .fetch_all(db)
-        .await?
-        .into_iter()
-        .map(|row| {
-            (
-                row.rolle_id,
-                Gruppe {
-                    id: row.id,
-                    gruppenname: row.gruppenname,
-                    erstellt_am: row.erstellt_am,
-                    geaendert_am: row.geaendert_am,
-                },
-            )
-        })
-        .into_group_map();
+        keys: &[Ulid],
+    ) -> Result<HashMap<Ulid, Vec<Gruppe>>, Arc<sqlx::Error>> {
+        const QUERY: &str = r#"
+            SELECT
+                rg.rolle_id as r_ulid,
+                g.id as g_ulid,
+                g.gruppenname,
+                g.erstellt_am,
+                g.geaendert_am
+            FROM gruppen AS g
+            LEFT JOIN rollen_gruppen AS rg ON g.gruppe_id = rg.gruppe_id
+            WHERE rg.rolle_id IN (
+                SELECT benutzer_id 
+                FROM benutzer 
+                WHERE id = ANY($1)
+            );
+       "#;
+
+        let rows = sqlx::query_as::<_, GruppeDataloader>(QUERY)
+            .bind(keys)
+            .fetch_all(db)
+            .await?
+            .into_iter()
+            .map(|row| {
+                (
+                    row.r_ulid,
+                    Gruppe {
+                        id: row.g_ulid,
+                        gruppenname: row.gruppenname,
+                        erstellt_am: row.erstellt_am,
+                        geaendert_am: row.geaendert_am,
+                    },
+                )
+            })
+            .into_group_map();
 
         Ok(rows)
     }
diff --git a/src/domain/gruppe/repository/gruppe_erstellen.rs b/src/domain/gruppe/repository/gruppe_erstellen.rs
index 825bc33..d79c3c3 100644
--- a/src/domain/gruppe/repository/gruppe_erstellen.rs
+++ b/src/domain/gruppe/repository/gruppe_erstellen.rs
@@ -8,19 +8,20 @@ impl Repository {
     pub async fn gruppe_erstellen<'c, C: Queryer<'c>>(
         &self,
         db: C,
-        gruppe: &entity::Gruppe,
+        gruppe: &entity::GruppeErstellen,
     ) -> 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;
+            INSERT INTO gruppen (gruppe_id, id, gruppenname, erstellt_am, geaendert_am) VALUES (
+                $1, $2, $3, $4, $5
+            ) RETURNING id, gruppenname, erstellt_am, geaendert_am;
         "#;
 
         let gruppe = sqlx::query_as::<_, model::Gruppe>(QUERY)
+            .bind(gruppe.gruppe_id)
             .bind(gruppe.id)
+            .bind(&gruppe.gruppenname)
             .bind(gruppe.erstellt_am)
             .bind(gruppe.geaendert_am)
-            .bind(&gruppe.gruppenname)
             .fetch_one(db)
             .await?;
 
diff --git a/src/domain/gruppe/repository/gruppe_loeschen.rs b/src/domain/gruppe/repository/gruppe_loeschen.rs
index 6a7806b..d5f0aec 100644
--- a/src/domain/gruppe/repository/gruppe_loeschen.rs
+++ b/src/domain/gruppe/repository/gruppe_loeschen.rs
@@ -8,7 +8,7 @@ impl Repository {
     pub async fn gruppe_loeschen<'c, C: Queryer<'c>>(
         &self,
         db: C,
-        gruppe: &entity::Gruppe,
+        gruppe: &entity::GruppeLoeschen,
     ) -> Result<model::Gruppe, Error> {
         const QUERY: &str = r#"
             DELETE FROM gruppen WHERE id=$1 RETURNING id, gruppenname, erstellt_am, geaendert_am;
diff --git a/src/domain/gruppe/repository/gruppe_update.rs b/src/domain/gruppe/repository/gruppe_update.rs
index 617091d..6f34ff4 100644
--- a/src/domain/gruppe/repository/gruppe_update.rs
+++ b/src/domain/gruppe/repository/gruppe_update.rs
@@ -8,12 +8,12 @@ impl Repository {
     pub async fn gruppe_update<'c, C: Queryer<'c>>(
         &self,
         db: C,
-        gruppe: &entity::Gruppe,
+        gruppe: &entity::GruppeUpdate,
     ) -> Result<model::Gruppe, Error> {
         const QUERY: &str = r#"
             UPDATE gruppen
             SET geaendert_am = $2, ruppenname = $3 WHERE gruppeid = $1
-            RETURNING id, geaendert_am, erstellt_am, gruppenname;
+            RETURNING id, gruppenname, geaendert_am, erstellt_am;
         "#;
 
         let gruppe = sqlx::query_as::<_, model::Gruppe>(QUERY)
diff --git a/src/domain/gruppe/service/gruppe_dataloader.rs b/src/domain/gruppe/service/gruppe_dataloader.rs
index 2773868..e8c7f64 100644
--- a/src/domain/gruppe/service/gruppe_dataloader.rs
+++ b/src/domain/gruppe/service/gruppe_dataloader.rs
@@ -1,14 +1,14 @@
 use std::{collections::HashMap, sync::Arc};
 
-use crate::{domain::gruppe::model::Gruppe, scalar::Id};
+use crate::{domain::gruppe::model::Gruppe, scalar::Ulid};
 
 use super::Service;
 
 impl Service {
     pub async fn gruppe_dataloader(
         &self,
-        keys: &[Id],
-    ) -> Result<HashMap<Id, Vec<Gruppe>>, Arc<sqlx::Error>> {
+        keys: &[Ulid],
+    ) -> Result<HashMap<Ulid, Vec<Gruppe>>, Arc<sqlx::Error>> {
         let gruppen_dataloader = self.repo.gruppe_dataloader(&self.db, keys).await?;
         Ok(gruppen_dataloader)
     }
diff --git a/src/domain/gruppe/service/gruppe_erstellen.rs b/src/domain/gruppe/service/gruppe_erstellen.rs
index 2b57283..fb3b2aa 100644
--- a/src/domain/gruppe/service/gruppe_erstellen.rs
+++ b/src/domain/gruppe/service/gruppe_erstellen.rs
@@ -1,23 +1,25 @@
+use super::Service;
+use crate::{
+    domain::gruppe::{
+        entity,
+        model::{self, GruppeErstelleInput},
+    },
+    scalar::Ulid,
+};
 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(),
+        let gruppe_input = entity::GruppeErstellen {
+            gruppe_id: ulid::Ulid::new().into(),
+            id: Ulid(ulid::Ulid::new().into()),
             gruppenname: input.gruppenname,
-            erstellt_am: Some(Utc::now()),
-            geaendert_am: Some(Utc::now()),
+            erstellt_am: Utc::now(),
+            geaendert_am: Utc::now(),
         };
 
         let gruppe = self.repo.gruppe_erstellen(&self.db, &gruppe_input).await?;
diff --git a/src/domain/gruppe/service/gruppe_loeschen.rs b/src/domain/gruppe/service/gruppe_loeschen.rs
index 822031b..6efc310 100644
--- a/src/domain/gruppe/service/gruppe_loeschen.rs
+++ b/src/domain/gruppe/service/gruppe_loeschen.rs
@@ -1,5 +1,4 @@
 use anyhow::Error;
-use chrono::Utc;
 
 use super::Service;
 use crate::domain::gruppe::{
@@ -12,12 +11,7 @@ impl Service {
         &self,
         input: GruppeLoeschenInput,
     ) -> Result<model::Gruppe, Error> {
-        let gruppe_input = entity::Gruppe {
-            id: input.id,
-            gruppenname: String::new(),
-            erstellt_am: None,
-            geaendert_am: Some(Utc::now()),
-        };
+        let gruppe_input = entity::GruppeLoeschen { id: input.id };
 
         let gruppe = self.repo.gruppe_loeschen(&self.db, &gruppe_input).await?;
         Ok(gruppe)
diff --git a/src/domain/gruppe/service/gruppe_update.rs b/src/domain/gruppe/service/gruppe_update.rs
index 964070b..6bbd6b5 100644
--- a/src/domain/gruppe/service/gruppe_update.rs
+++ b/src/domain/gruppe/service/gruppe_update.rs
@@ -1,6 +1,5 @@
 use anyhow::Error;
 use chrono::Utc;
-use ulid::Ulid;
 
 use super::Service;
 use crate::domain::gruppe::{
@@ -10,11 +9,10 @@ use crate::domain::gruppe::{
 
 impl Service {
     pub async fn gruppe_update(&self, input: GruppeUpdateInput) -> Result<model::Gruppe, Error> {
-        let gruppe_input = entity::Gruppe {
-            id: Ulid::new().into(),
+        let gruppe_input = entity::GruppeUpdate {
+            id: input.id,
             gruppenname: input.gruppenname,
-            erstellt_am: None,
-            geaendert_am: Some(Utc::now()),
+            geaendert_am: Utc::now(),
         };
 
         let gruppe = self.repo.gruppe_update(&self.db, &gruppe_input).await?;
diff --git a/src/domain/rolle/dataloader/rollen.rs b/src/domain/rolle/dataloader/rollen.rs
index 6340798..06f71c1 100644
--- a/src/domain/rolle/dataloader/rollen.rs
+++ b/src/domain/rolle/dataloader/rollen.rs
@@ -1,51 +1,23 @@
-use async_graphql::dataloader::*;
-use async_graphql::*;
-use itertools::Itertools;
+use async_graphql::dataloader::Loader;
 use std::collections::HashMap;
 use std::sync::Arc;
 
 use crate::domain::rolle::model::Rolle;
-use crate::scalar::Id;
+use crate::domain::rolle::service::Service;
+use crate::scalar::Ulid;
 
 pub struct RollenLoader {
     pub pool: sqlx::PgPool,
 }
 
-impl Loader<Id> for RollenLoader {
+impl Loader<Ulid> 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();
-
+    async fn load(&self, keys: &[Ulid]) -> Result<HashMap<Ulid, Self::Value>, Self::Error> {
+        let rows = Service::new(self.pool.clone())
+            .rolle_dataloader(keys)
+            .await?;
         Ok(rows)
     }
 }
diff --git a/src/domain/rolle/entity.rs b/src/domain/rolle/entity.rs
index 85a549e..29471d3 100644
--- a/src/domain/rolle/entity.rs
+++ b/src/domain/rolle/entity.rs
@@ -1,2 +1,6 @@
 pub mod rolle;
-pub use rolle::Rolle;
+
+pub use rolle::RolleErstellen;
+pub use rolle::RolleLoeschen;
+pub use rolle::RolleRow;
+pub use rolle::RolleUpdate;
diff --git a/src/domain/rolle/entity/rolle.rs b/src/domain/rolle/entity/rolle.rs
index 9d1e126..cd89e35 100644
--- a/src/domain/rolle/entity/rolle.rs
+++ b/src/domain/rolle/entity/rolle.rs
@@ -1,8 +1,30 @@
-use crate::scalar::{Id, Time};
+use sqlx::FromRow;
 
-pub struct Rolle {
-    pub id: Id,
+use crate::scalar::{Id, Time, Ulid};
+
+pub struct RolleErstellen {
+    pub rolle_id: Id,
+    pub id: Ulid,
     pub rollenname: String,
-    pub erstellt_am: Option<Time>,
-    pub geaendert_am: Option<Time>,
+    pub erstellt_am: Time,
+    pub geaendert_am: Time,
+}
+
+pub struct RolleLoeschen {
+    pub id: Ulid,
+}
+
+pub struct RolleUpdate {
+    pub id: Ulid,
+    pub rollenname: String,
+    pub geaendert_am: Time,
+}
+
+#[derive(Debug, FromRow)]
+pub struct RolleRow {
+    pub b_ulid: Ulid,
+    pub r_ulid: Ulid,
+    pub rollenname: String,
+    pub erstellt_am: Time,
+    pub geaendert_am: Time,
 }
diff --git a/src/domain/rolle/model/rolle.rs b/src/domain/rolle/model/rolle.rs
index d093c4b..67a4048 100644
--- a/src/domain/rolle/model/rolle.rs
+++ b/src/domain/rolle/model/rolle.rs
@@ -3,15 +3,15 @@ use async_graphql::{ComplexObject, Context, FieldResult, SimpleObject};
 use crate::{
     dataloader::LoaderContext,
     domain::gruppe::model::Gruppe,
-    scalar::{Id, Time},
+    scalar::{Time, Ulid},
 };
 
 /// Um die Administration zu erleichtern werden Gruppen in die Rollen hinzugefuegt
 #[derive(sqlx::FromRow, SimpleObject, Debug, Clone)]
 #[graphql(complex)]
 pub struct Rolle {
-    /// Die  uuid einer Rolle
-    pub id: Id,
+    /// Die ULID einer Rolle
+    pub id: Ulid,
 
     /// Der Rollenname
     pub rollenname: String,
diff --git a/src/domain/rolle/model/rolle_loeschen_input.rs b/src/domain/rolle/model/rolle_loeschen_input.rs
index 9e11987..eabb7ed 100644
--- a/src/domain/rolle/model/rolle_loeschen_input.rs
+++ b/src/domain/rolle/model/rolle_loeschen_input.rs
@@ -1,9 +1,9 @@
 use async_graphql::InputObject;
 
-use crate::scalar::Id;
+use crate::scalar::Ulid;
 
 #[derive(InputObject)]
 pub struct RolleLoeschenInput {
-    /// Die ID einer Rolle
-    pub id: Id,
+    /// Die Ulid einer Rolle
+    pub id: Ulid,
 }
diff --git a/src/domain/rolle/model/rolle_update_input.rs b/src/domain/rolle/model/rolle_update_input.rs
index 6689262..4338aae 100644
--- a/src/domain/rolle/model/rolle_update_input.rs
+++ b/src/domain/rolle/model/rolle_update_input.rs
@@ -1,10 +1,10 @@
-use crate::scalar::Id;
+use crate::scalar::Ulid;
 use async_graphql::InputObject;
 
 #[derive(InputObject)]
 pub struct RolleUpdateInput {
-    /// Die ID einer Rolle
-    pub id: Id,
+    /// Die Ulid einer Rolle
+    pub id: Ulid,
 
     /// Der Name einer Rolle
     pub rollenname: String,
diff --git a/src/domain/rolle/queries/rolle.rs b/src/domain/rolle/queries/rolle.rs
index f421ea3..4e9bb22 100644
--- a/src/domain/rolle/queries/rolle.rs
+++ b/src/domain/rolle/queries/rolle.rs
@@ -1,7 +1,7 @@
 use async_graphql::{Context, FieldResult, Object};
 use sqlx::postgres::PgPool;
 
-use crate::domain::rolle::model::Rolle;
+use crate::domain::rolle::{model::Rolle, service::Service};
 
 #[derive(Default)]
 pub struct RolleQuery {}
@@ -15,11 +15,8 @@ impl RolleQuery {
     // }
 
     async fn rollen(&self, ctx: &Context<'_>) -> FieldResult<Vec<Rolle>> {
-        let pool = ctx.data::<PgPool>()?;
-
-        let rollen = sqlx::query_as!(Rolle, "SELECT * FROM rollen")
-            .fetch_all(pool)
-            .await?;
+        let pool = ctx.data::<PgPool>()?.clone();
+        let rollen = Service::new(pool).rolle_alle().await?;
 
         Ok(rollen)
     }
diff --git a/src/domain/rolle/repository.rs b/src/domain/rolle/repository.rs
index 21b1a11..ee945d3 100644
--- a/src/domain/rolle/repository.rs
+++ b/src/domain/rolle/repository.rs
@@ -1,9 +1,10 @@
 mod find_all_rolle;
 mod find_rolle_by_id;
+mod rolle_alle;
+mod rolle_dataloader;
 mod rolle_erstellen;
 mod rolle_loeschen;
 mod rolle_update;
-mod rollen_dataloader;
 
 #[derive(Debug, Clone)]
 pub struct Repository {}
@@ -13,6 +14,7 @@ impl Repository {
         Repository {}
     }
 }
+
 impl Default for Repository {
     fn default() -> Self {
         Self::new()
diff --git a/src/domain/rolle/repository/rolle_alle.rs b/src/domain/rolle/repository/rolle_alle.rs
new file mode 100644
index 0000000..f71b192
--- /dev/null
+++ b/src/domain/rolle/repository/rolle_alle.rs
@@ -0,0 +1,17 @@
+use anyhow::Error;
+
+use super::Repository;
+use crate::{database::Queryer, domain::rolle::model};
+
+impl Repository {
+    pub async fn rolle_alle<'c, C: Queryer<'c>>(&self, db: C) -> Result<Vec<model::Rolle>, Error> {
+        const QUERY: &str = r#"
+            SELECT id, rollenname, erstellt_am, geaendert_am  FROM rollen
+        "#;
+
+        let rollen = sqlx::query_as::<_, model::Rolle>(QUERY)
+            .fetch_all(db)
+            .await?;
+        Ok(rollen)
+    }
+}
diff --git a/src/domain/rolle/repository/rolle_dataloader.rs b/src/domain/rolle/repository/rolle_dataloader.rs
new file mode 100644
index 0000000..db20d81
--- /dev/null
+++ b/src/domain/rolle/repository/rolle_dataloader.rs
@@ -0,0 +1,55 @@
+use itertools::Itertools;
+use std::collections::HashMap;
+use std::sync::Arc;
+
+use super::Repository;
+
+use crate::database::Queryer;
+use crate::domain::rolle::entity::RolleRow;
+use crate::domain::rolle::model;
+use crate::scalar::Ulid;
+
+impl Repository {
+    pub async fn rolle_dataloader<'c, C: Queryer<'c>>(
+        &self,
+        db: C,
+        keys: &[Ulid],
+    ) -> Result<HashMap<Ulid, Vec<model::Rolle>>, Arc<sqlx::Error>> {
+        const QUERY: &str = r#"
+            SELECT
+                b.id as b_ulid,
+                r.id as r_ulid,
+                r.rollenname,
+                r.erstellt_am,
+                r.geaendert_am
+            FROM rollen AS r
+            LEFT JOIN benutzer_rollen AS br ON r.rolle_id = br.rolle_id
+            LEFT JOIN benutzer AS b ON br.benutzer_id = b.benutzer_id
+            WHERE br.benutzer_id IN (
+                SELECT benutzer_id 
+                FROM benutzer 
+                WHERE id = ANY($1)
+            )
+        "#;
+
+        let rows = sqlx::query_as::<_, RolleRow>(QUERY)
+            .bind(keys)
+            .fetch_all(db)
+            .await?
+            .into_iter()
+            .map(|row| {
+                (
+                    row.b_ulid,
+                    model::Rolle {
+                        id: row.r_ulid,
+                        rollenname: row.rollenname,
+                        erstellt_am: row.erstellt_am,
+                        geaendert_am: row.geaendert_am,
+                    },
+                )
+            })
+            .into_group_map();
+
+        Ok(rows)
+    }
+}
diff --git a/src/domain/rolle/repository/rolle_erstellen.rs b/src/domain/rolle/repository/rolle_erstellen.rs
index da096f5..3471f1d 100644
--- a/src/domain/rolle/repository/rolle_erstellen.rs
+++ b/src/domain/rolle/repository/rolle_erstellen.rs
@@ -8,19 +8,20 @@ impl Repository {
     pub async fn rolle_erstellen<'c, C: Queryer<'c>>(
         &self,
         db: C,
-        rolle: &entity::Rolle,
+        rolle: &entity::RolleErstellen,
     ) -> Result<model::Rolle, Error> {
         const QUERY: &str = r#"
-            INSERT INTO rollen (id, erstellt_am, geaendert_am, rollenname) VALUES (
-                $1, $2, $3, $4
-            ) RETURNING id, erstellt_am, geaendert_am, rollenname
+            INSERT INTO rollen (rolle_id, id, rollenname, erstellt_am, geaendert_am) VALUES (
+                $1, $2, $3, $4, $5
+            ) RETURNING id, rollenname, erstellt_am, geaendert_am
         "#;
 
         let rolle = sqlx::query_as::<_, model::Rolle>(QUERY)
+            .bind(rolle.rolle_id)
             .bind(rolle.id)
+            .bind(&rolle.rollenname)
             .bind(rolle.erstellt_am)
             .bind(rolle.geaendert_am)
-            .bind(&rolle.rollenname)
             .fetch_one(db)
             .await?;
 
diff --git a/src/domain/rolle/repository/rolle_loeschen.rs b/src/domain/rolle/repository/rolle_loeschen.rs
index 2504bd2..1163513 100644
--- a/src/domain/rolle/repository/rolle_loeschen.rs
+++ b/src/domain/rolle/repository/rolle_loeschen.rs
@@ -10,7 +10,7 @@ impl Repository {
     pub async fn rolle_loeschen<'c, C: Queryer<'c>>(
         &self,
         db: C,
-        rolle: &entity::Rolle,
+        rolle: &entity::RolleLoeschen,
     ) -> Result<model::Rolle, Error> {
         const QUERY: &str = r#"
             DELETE FROM rollen WHERE id=$1 RETURNING id, rollenname, erstellt_am, geaendert_am;
diff --git a/src/domain/rolle/repository/rolle_update.rs b/src/domain/rolle/repository/rolle_update.rs
index b4b7124..219b683 100644
--- a/src/domain/rolle/repository/rolle_update.rs
+++ b/src/domain/rolle/repository/rolle_update.rs
@@ -8,7 +8,7 @@ impl Repository {
     pub async fn rolle_update<'c, C: Queryer<'c>>(
         &self,
         db: C,
-        rolle: &entity::Rolle,
+        rolle: &entity::RolleUpdate,
     ) -> Result<model::Rolle, Error> {
         const QUERY: &str = r#"
             UPDATE rollen
diff --git a/src/domain/rolle/repository/rollen_dataloader.rs b/src/domain/rolle/repository/rollen_dataloader.rs
deleted file mode 100644
index a5c7949..0000000
--- a/src/domain/rolle/repository/rollen_dataloader.rs
+++ /dev/null
@@ -1,49 +0,0 @@
-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)
-    }
-}
diff --git a/src/domain/rolle/service.rs b/src/domain/rolle/service.rs
index caea6b6..e51bc71 100644
--- a/src/domain/rolle/service.rs
+++ b/src/domain/rolle/service.rs
@@ -1,3 +1,5 @@
+mod rolle_alle;
+mod rolle_dataloader;
 mod rolle_erstellen;
 mod rolle_loeschen;
 mod rolle_update;
diff --git a/src/domain/rolle/service/rolle_alle.rs b/src/domain/rolle/service/rolle_alle.rs
new file mode 100644
index 0000000..5dafbb3
--- /dev/null
+++ b/src/domain/rolle/service/rolle_alle.rs
@@ -0,0 +1,12 @@
+use anyhow::Error;
+
+use crate::domain::rolle::model;
+
+use super::Service;
+
+impl Service {
+    pub async fn rolle_alle(&self) -> Result<Vec<model::Rolle>, Error> {
+        let typen = self.repo.rolle_alle(&self.db).await?;
+        Ok(typen)
+    }
+}
diff --git a/src/domain/rolle/service/rolle_dataloader.rs b/src/domain/rolle/service/rolle_dataloader.rs
new file mode 100644
index 0000000..2275273
--- /dev/null
+++ b/src/domain/rolle/service/rolle_dataloader.rs
@@ -0,0 +1,15 @@
+use std::{collections::HashMap, sync::Arc};
+
+use crate::{domain::rolle::model, scalar::Ulid};
+
+use super::Service;
+
+impl Service {
+    pub async fn rolle_dataloader(
+        &self,
+        keys: &[Ulid],
+    ) -> Result<HashMap<Ulid, Vec<model::Rolle>>, Arc<sqlx::Error>> {
+        let typen = self.repo.rolle_dataloader(&self.db, keys).await?;
+        Ok(typen)
+    }
+}
diff --git a/src/domain/rolle/service/rolle_erstellen.rs b/src/domain/rolle/service/rolle_erstellen.rs
index 195865b..6adf2cd 100644
--- a/src/domain/rolle/service/rolle_erstellen.rs
+++ b/src/domain/rolle/service/rolle_erstellen.rs
@@ -1,20 +1,23 @@
 use anyhow::Error;
 use chrono::Utc;
-use ulid::Ulid;
 
 use super::Service;
-use crate::domain::rolle::{
-    entity,
-    model::{self, RolleErstelleInput},
+use crate::{
+    domain::rolle::{
+        entity,
+        model::{self, RolleErstelleInput},
+    },
+    scalar::Ulid,
 };
 
 impl Service {
     pub async fn rolle_erstellen(&self, input: RolleErstelleInput) -> Result<model::Rolle, Error> {
-        let rolle_input = entity::Rolle {
-            id: Ulid::new().into(),
+        let rolle_input = entity::RolleErstellen {
+            rolle_id: ulid::Ulid::new().into(),
+            id: Ulid(ulid::Ulid::new()),
             rollenname: input.rollenname,
-            erstellt_am: Some(Utc::now()),
-            geaendert_am: Some(Utc::now()),
+            erstellt_am: Utc::now(),
+            geaendert_am: Utc::now(),
         };
 
         let rolle = self.repo.rolle_erstellen(&self.db, &rolle_input).await?;
diff --git a/src/domain/rolle/service/rolle_loeschen.rs b/src/domain/rolle/service/rolle_loeschen.rs
index e4f3565..aae4551 100644
--- a/src/domain/rolle/service/rolle_loeschen.rs
+++ b/src/domain/rolle/service/rolle_loeschen.rs
@@ -8,12 +8,7 @@ use crate::domain::rolle::{
 
 impl Service {
     pub async fn rolle_loeschen(&self, input: RolleLoeschenInput) -> Result<model::Rolle, Error> {
-        let rolle_input = entity::Rolle {
-            id: input.id,
-            rollenname: String::new(),
-            erstellt_am: None,
-            geaendert_am: None,
-        };
+        let rolle_input = entity::RolleLoeschen { id: input.id };
 
         let deleted = self.repo.rolle_loeschen(&self.db, &rolle_input).await?;
         Ok(deleted)
diff --git a/src/domain/rolle/service/rolle_update.rs b/src/domain/rolle/service/rolle_update.rs
index fb966cb..4e179cc 100644
--- a/src/domain/rolle/service/rolle_update.rs
+++ b/src/domain/rolle/service/rolle_update.rs
@@ -9,11 +9,10 @@ use crate::domain::rolle::{
 
 impl Service {
     pub async fn rolle_update(&self, input: RolleUpdateInput) -> Result<model::Rolle, Error> {
-        let rolle_input = entity::Rolle {
+        let rolle_input = entity::RolleUpdate {
             id: input.id,
             rollenname: input.rollenname,
-            erstellt_am: None,
-            geaendert_am: Some(Utc::now()),
+            geaendert_am: Utc::now(),
         };
 
         let rolle = self.repo.rolle_update(&self.db, &rolle_input).await?;
diff --git a/src/domain/typ/entity.rs b/src/domain/typ/entity.rs
index c0c5e1d..ffbe67f 100644
--- a/src/domain/typ/entity.rs
+++ b/src/domain/typ/entity.rs
@@ -1,6 +1,5 @@
 pub mod typ;
 
-// pub use typ::Typ;
 pub use typ::TypErstellen;
 pub use typ::TypLoeschen;
 pub use typ::TypUpdate;
diff --git a/src/models/hersteller.rs b/src/models/hersteller.rs
index e89323b..a88c849 100644
--- a/src/models/hersteller.rs
+++ b/src/models/hersteller.rs
@@ -4,7 +4,7 @@ use serde::{Deserialize, Serialize};
 use sqlx::{FromRow, PgPool};
 use ulid::Ulid;
 
-use crate::scalar::Id;
+use crate::scalar::{Id, Time};
 
 #[derive(SimpleObject, Debug, FromRow, Deserialize, Serialize, sqlx::Type)]
 pub struct Hersteller {
@@ -12,7 +12,13 @@ pub struct Hersteller {
     pub id: Id,
 
     /// Der Name eines Herstellers
-    herstellername: String,
+    pub herstellername: String,
+
+    /// Wann die Rolle erstellt wurde
+    pub erstellt_am: Time,
+
+    /// Wann die Rolle geaendert wurde
+    pub geaendert_am: Time,
 }
 
 #[derive(InputObject, Debug)]
@@ -40,9 +46,12 @@ impl Hersteller {
     }
 
     pub async fn read_all(pool: &PgPool) -> Result<Vec<Hersteller>> {
-        let rows = sqlx::query_as!(Hersteller, "SELECT id, herstellername FROM hersteller")
-            .fetch_all(pool)
-            .await?;
+        let rows = sqlx::query_as!(
+            Hersteller,
+            "SELECT id, herstellername, erstellt_am, geaendert_am FROM hersteller"
+        )
+        .fetch_all(pool)
+        .await?;
 
         Ok(rows)
     }
diff --git a/src/mutations/mod.rs b/src/mutations/mod.rs
index 4437947..6ec0bce 100644
--- a/src/mutations/mod.rs
+++ b/src/mutations/mod.rs
@@ -1,4 +1,4 @@
-pub mod benutzer;
+// pub mod benutzer;
 pub mod gruppe;
 // pub mod hersteller;
 // pub mod modell;
@@ -14,7 +14,7 @@ pub struct Mutation(
     TypMutation,
     // hersteller::HerstellerMutation,
     // modell::ModellMutation,
-    benutzer::BenutzerMutation,
+    // benutzer::BenutzerMutation,
     gruppe::GruppeMutation,
     rolle::RolleMutation,
     liegenschaft::LiegenschaftMutation,
diff --git a/src/queries/mod.rs b/src/queries/mod.rs
index 9abf127..9342b07 100644
--- a/src/queries/mod.rs
+++ b/src/queries/mod.rs
@@ -1,8 +1,11 @@
 // pub mod hersteller;
 // pub mod modell;
 use crate::domain::{
-    benutzer::queries::benutzer, gruppe::queries::gruppe, liegenschaft::queries::liegenschaft,
-    rolle::queries::rolle, typ::queries::typ::TypQuery,
+    // benutzer::queries::benutzer,
+    gruppe::queries::gruppe,
+    liegenschaft::queries::liegenschaft,
+    rolle::queries::rolle,
+    typ::queries::typ::TypQuery,
 };
 
 use async_graphql::MergedObject;
@@ -10,7 +13,7 @@ use async_graphql::MergedObject;
 #[derive(MergedObject, Default)]
 pub struct Query(
     TypQuery,
-    benutzer::BenutzerQuery,
+    // benutzer::BenutzerQuery,
     rolle::RolleQuery,
     gruppe::GruppeQuery,
     liegenschaft::LiegenschaftQuery, // modell::ModellQuery,
diff --git a/src/scalar.rs b/src/scalar.rs
index 461bb79..0008d12 100644
--- a/src/scalar.rs
+++ b/src/scalar.rs
@@ -1,67 +1,26 @@
 use async_graphql::*;
-/// It is easier to track each type alias if this file is located on the top-level directory (here)
-/// than in each domain. Also, separating them will create a lot of duplicate code.
-use uuid::Uuid;
+use sqlx::{
+    postgres::{PgArgumentBuffer, PgHasArrayType, PgTypeInfo, PgValueRef},
+    Decode, Encode, Postgres, Type,
+};
+use ulid::Ulid as UlidPrimitive;
 
 pub type Time = chrono::DateTime<chrono::Utc>;
 
 /// The ID scalar type represents a unique identifier, often used to refetch an object or as key for a cache.
 /// The ID type appears in a JSON response as a String; however, it is not intended to be human-readable.
 /// When expected as an input type, any string (such as "4") or integer (such as 4) input value will be accepted as an ID.
-pub type Id = Uuid;
+pub type Id = uuid::Uuid;
 
-// pub type Ulid = String;
-
-// pub type Ulid = ulid::Ulid;
-
-// #[derive(Clone, Copy, Eq, PartialEq)]
-// pub struct Ulid(pub ulid::Ulid);
-//
-// /// The ULID scalar type represents a Universally Unique Lexicographically Sortable Identifier as defined by the ULID specification.
-// /// ULIDs are 26-character strings that are URL-safe, case-insensitive, and lexicographically sortable,
-// /// making them ideal for distributed systems requiring time-ordered unique identifiers.
-// #[Scalar]
-// impl ScalarType for Ulid {
-//     fn parse(value: Value) -> InputValueResult<Self> {
-//         match value {
-//             Value::String(s) => {
-//                 let ulid = ulid::Ulid::from_string(&s).map_err(InputValueError::custom)?;
-//                 Ok(Ulid(ulid))
-//             }
-//             _ => Err(InputValueError::expected_type(value)),
-//         }
-//     }
-//
-//     fn to_value(&self) -> Value {
-//         Value::String(self.0.to_string())
-//     }
-// }
-//
-// impl fmt::Display for Ulid {
-//     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-//         write!(f, "{}", self.0) // delegiert an Ulid::to_string()
-//     }
-// }
-//
-//
-//
-use sqlx::{
-    postgres::{PgArgumentBuffer, PgHasArrayType, PgTypeInfo, PgValueRef},
-    Decode, Encode, Postgres, Type,
-};
-
-// #[derive(sqlx::Type)]
-// #[sqlx(type_name = "ULID")]
-// #[sqlx(no_pg_array)]
-#[derive(Clone, Copy, PartialEq, Eq)]
-pub struct Ulid(pub ulid::Ulid);
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash)]
+pub struct Ulid(pub UlidPrimitive);
 
 #[Scalar]
 impl ScalarType for Ulid {
     fn parse(value: Value) -> InputValueResult<Self> {
         match value {
             Value::String(s) => {
-                let ulid = ulid::Ulid::from_string(&s).map_err(InputValueError::custom)?;
+                let ulid = UlidPrimitive::from_string(&s).map_err(InputValueError::custom)?;
                 Ok(Ulid(ulid))
             }
             _ => Err(InputValueError::expected_type(value)),
@@ -75,17 +34,19 @@ impl ScalarType for Ulid {
 
 impl Type<Postgres> for Ulid {
     fn type_info() -> PgTypeInfo {
-        PgTypeInfo::with_name("ULID")
+        <String as Type<Postgres>>::type_info()
     }
+
     fn compatible(ty: &PgTypeInfo) -> bool {
         <String as Type<Postgres>>::compatible(ty)
     }
 }
+
 impl<'r> Decode<'r, Postgres> for Ulid {
     fn decode(value: PgValueRef<'r>) -> Result<Self, Box<dyn std::error::Error + Send + Sync>> {
         let s = <String as Decode<Postgres>>::decode(value)?;
 
-        Ok(Ulid(ulid::Ulid::from_string(s.trim())?))
+        Ok(Ulid(UlidPrimitive::from_string(s.trim())?))
     }
 }
 
@@ -97,8 +58,9 @@ impl<'q> Encode<'q, Postgres> for Ulid {
         <String as Encode<Postgres>>::encode(self.0.to_string(), buf)
     }
 }
+
 impl PgHasArrayType for Ulid {
     fn array_type_info() -> PgTypeInfo {
-        PgTypeInfo::with_name("_ULID")
+        <String as PgHasArrayType>::array_type_info()
     }
 }