domain-model: move domain::model module to separate crate

server/Cargo.toml

@@ -91,6 +91,9 @@ path = "../crates/domain"
 path = "../crates/domain"
 features = ["test"]
 
+[dependencies.lldap_domain_model]
+path = "../crates/domain-model"
+
 [dependencies.lldap_validation]
 path = "../crates/validation"
 

server/src/domain/error.rs

@@ -1,35 +0,0 @@
-use thiserror::Error;
-
-#[allow(clippy::enum_variant_names)]
-#[derive(Error, Debug)]
-pub enum DomainError {
-    #[error("Authentication error {0}")]
-    AuthenticationError(String),
-    #[error("Database error: `{0}`")]
-    DatabaseError(#[from] sea_orm::DbErr),
-    #[error("Database transaction error: `{0}`")]
-    DatabaseTransactionError(#[from] sea_orm::TransactionError<sea_orm::DbErr>),
-    #[error("Authentication protocol error for `{0}`")]
-    AuthenticationProtocolError(#[from] lldap_auth::opaque::AuthenticationError),
-    #[error("Unknown crypto error: `{0}`")]
-    UnknownCryptoError(#[from] orion::errors::UnknownCryptoError),
-    #[error("Binary serialization error: `{0}`")]
-    BinarySerializationError(#[from] bincode::Error),
-    #[error("Invalid base64: `{0}`")]
-    Base64DecodeError(#[from] base64::DecodeError),
-    #[error("Entity not found: `{0}`")]
-    EntityNotFound(String),
-    #[error("Internal error: `{0}`")]
-    InternalError(String),
-}
-
-impl From<sea_orm::TransactionError<DomainError>> for DomainError {
-    fn from(value: sea_orm::TransactionError<DomainError>) -> Self {
-        match value {
-            sea_orm::TransactionError::Connection(e) => e.into(),
-            sea_orm::TransactionError::Transaction(e) => e,
-        }
-    }
-}
-
-pub type Result<T> = std::result::Result<T, DomainError>;

server/src/domain/handler.rs

@@ -1,4 +1,3 @@
-use crate::domain::{error::Result, model::UserColumn};
 use async_trait::async_trait;
 use lldap_domain::{
     requests::{
@@ -11,6 +10,7 @@ use lldap_domain::{
         User, UserAndGroups, UserId, Uuid,
     },
 };
+use lldap_domain_model::{error::Result, model::UserColumn};
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
 

server/src/domain/ldap/user.rs

@@ -16,12 +16,12 @@ use crate::domain::{
             LdapInfo, UserFieldType,
         },
     },
-    model::UserColumn,
     schema::PublicSchema,
 };
 use lldap_domain::types::{
     AttributeName, AttributeType, GroupDetails, LdapObjectClass, User, UserAndGroups, UserId,
 };
+use lldap_domain_model::model::UserColumn;
 
 pub fn get_user_attribute(
     user: &User,

server/src/domain/ldap/utils.rs

@@ -7,7 +7,6 @@ use tracing::{debug, instrument, warn};
 use crate::domain::{
     handler::SubStringFilter,
     ldap::error::{LdapError, LdapResult},
-    model::UserColumn,
     schema::PublicSchema,
 };
 use lldap_domain::types::{
@@ -29,6 +28,7 @@ impl From<LdapSubstringFilter> for SubStringFilter {
         }
     }
 }
+use lldap_domain_model::model::UserColumn;
 
 fn make_dn_pair<I>(mut iter: I) -> LdapResult<(String, String)>
 where

server/src/domain/mod.rs

@@ -1,8 +1,6 @@
 pub mod deserialize;
-pub mod error;
 pub mod handler;
 pub mod ldap;
-pub mod model;
 pub mod opaque_handler;
 pub mod schema;
 pub mod sql_backend_handler;

server/src/domain/model/deserialize.rs

@@ -1,57 +0,0 @@
-use crate::domain::error::DomainError;
-use lldap_domain::{
-    schema::AttributeList,
-    types::{Attribute, AttributeName, AttributeType, AttributeValue, Cardinality, Serialized},
-};
-
-// Value must be a serialized attribute value of the type denoted by typ,
-// and either a singleton or unbounded list, depending on is_list.
-pub(crate) fn deserialize_attribute_value(
-    value: &Serialized,
-    typ: AttributeType,
-    is_list: bool,
-) -> AttributeValue {
-    match (typ, is_list) {
-        (AttributeType::String, false) => {
-            AttributeValue::String(Cardinality::Singleton(value.unwrap()))
-        }
-        (AttributeType::String, true) => {
-            AttributeValue::String(Cardinality::Unbounded(value.unwrap()))
-        }
-        (AttributeType::Integer, false) => {
-            AttributeValue::Integer(Cardinality::Singleton(value.unwrap::<i64>()))
-        }
-        (AttributeType::Integer, true) => {
-            AttributeValue::Integer(Cardinality::Unbounded(value.unwrap()))
-        }
-        (AttributeType::DateTime, false) => {
-            AttributeValue::DateTime(Cardinality::Singleton(value.unwrap()))
-        }
-        (AttributeType::DateTime, true) => {
-            AttributeValue::DateTime(Cardinality::Unbounded(value.unwrap()))
-        }
-        (AttributeType::JpegPhoto, false) => {
-            AttributeValue::JpegPhoto(Cardinality::Singleton(value.unwrap()))
-        }
-        (AttributeType::JpegPhoto, true) => {
-            AttributeValue::JpegPhoto(Cardinality::Unbounded(value.unwrap()))
-        }
-    }
-}
-
-pub(crate) fn deserialize_attribute(
-    name: AttributeName,
-    value: &Serialized,
-    schema: &AttributeList,
-) -> Result<Attribute, DomainError> {
-    match schema.get_attribute_type(&name) {
-        Some((typ, is_list)) => Ok(Attribute {
-            name,
-            value: deserialize_attribute_value(value, typ, is_list),
-        }),
-        None => Err(DomainError::InternalError(format!(
-            "Unable to find schema for attribute named '{}'",
-            name.into_string()
-        ))),
-    }
-}

server/src/domain/model/group_attribute_schema.rs

@@ -1,56 +0,0 @@
-use sea_orm::entity::prelude::*;
-use serde::{Deserialize, Serialize};
-
-use lldap_domain::{
-    schema::AttributeSchema,
-    types::{AttributeName, AttributeType},
-};
-
-#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
-#[sea_orm(table_name = "group_attribute_schema")]
-pub struct Model {
-    #[sea_orm(
-        primary_key,
-        auto_increment = false,
-        column_name = "group_attribute_schema_name"
-    )]
-    pub attribute_name: AttributeName,
-    #[sea_orm(column_name = "group_attribute_schema_type")]
-    pub attribute_type: AttributeType,
-    #[sea_orm(column_name = "group_attribute_schema_is_list")]
-    pub is_list: bool,
-    #[sea_orm(column_name = "group_attribute_schema_is_group_visible")]
-    pub is_group_visible: bool,
-    #[sea_orm(column_name = "group_attribute_schema_is_group_editable")]
-    pub is_group_editable: bool,
-    #[sea_orm(column_name = "group_attribute_schema_is_hardcoded")]
-    pub is_hardcoded: bool,
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {
-    #[sea_orm(has_many = "super::group_attributes::Entity")]
-    GroupAttributes,
-}
-
-impl Related<super::GroupAttributes> for Entity {
-    fn to() -> RelationDef {
-        Relation::GroupAttributes.def()
-    }
-}
-
-impl ActiveModelBehavior for ActiveModel {}
-
-impl From<Model> for AttributeSchema {
-    fn from(value: Model) -> Self {
-        Self {
-            name: value.attribute_name,
-            attribute_type: value.attribute_type,
-            is_list: value.is_list,
-            is_visible: value.is_group_visible,
-            is_editable: value.is_group_editable,
-            is_hardcoded: value.is_hardcoded,
-            is_readonly: false,
-        }
-    }
-}

server/src/domain/model/group_attributes.rs

@@ -1,57 +0,0 @@
-use sea_orm::entity::prelude::*;
-use serde::{Deserialize, Serialize};
-
-use lldap_domain::types::{AttributeName, GroupId, Serialized};
-
-#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
-#[sea_orm(table_name = "group_attributes")]
-pub struct Model {
-    #[sea_orm(
-        primary_key,
-        auto_increment = false,
-        column_name = "group_attribute_group_id"
-    )]
-    pub group_id: GroupId,
-    #[sea_orm(
-        primary_key,
-        auto_increment = false,
-        column_name = "group_attribute_name"
-    )]
-    pub attribute_name: AttributeName,
-    #[sea_orm(column_name = "group_attribute_value")]
-    pub value: Serialized,
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {
-    #[sea_orm(
-        belongs_to = "super::groups::Entity",
-        from = "Column::GroupId",
-        to = "super::groups::Column::GroupId",
-        on_update = "Cascade",
-        on_delete = "Cascade"
-    )]
-    Groups,
-    #[sea_orm(
-        belongs_to = "super::group_attribute_schema::Entity",
-        from = "Column::AttributeName",
-        to = "super::group_attribute_schema::Column::AttributeName",
-        on_update = "Cascade",
-        on_delete = "Cascade"
-    )]
-    GroupAttributeSchema,
-}
-
-impl Related<super::Group> for Entity {
-    fn to() -> RelationDef {
-        Relation::Groups.def()
-    }
-}
-
-impl Related<super::GroupAttributeSchema> for Entity {
-    fn to() -> RelationDef {
-        Relation::GroupAttributeSchema.def()
-    }
-}
-
-impl ActiveModelBehavior for ActiveModel {}

server/src/domain/model/group_object_classes.rs

@@ -1,23 +0,0 @@
-use sea_orm::entity::prelude::*;
-use serde::{Deserialize, Serialize};
-
-use lldap_domain::types::LdapObjectClass;
-
-#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
-#[sea_orm(table_name = "group_object_classes")]
-pub struct Model {
-    #[sea_orm(primary_key, auto_increment = false)]
-    pub lower_object_class: String,
-    pub object_class: LdapObjectClass,
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {}
-
-impl ActiveModelBehavior for ActiveModel {}
-
-impl From<Model> for LdapObjectClass {
-    fn from(value: Model) -> Self {
-        value.object_class
-    }
-}

server/src/domain/model/groups.rs

@@ -1,56 +0,0 @@
-//! `SeaORM` Entity. Generated by sea-orm-codegen 0.10.3
-
-use sea_orm::entity::prelude::*;
-use serde::{Deserialize, Serialize};
-
-use lldap_domain::types::{GroupId, GroupName, Uuid};
-
-#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
-#[sea_orm(table_name = "groups")]
-pub struct Model {
-    #[sea_orm(primary_key, auto_increment = false)]
-    pub group_id: GroupId,
-    pub display_name: GroupName,
-    pub lowercase_display_name: String,
-    pub creation_date: chrono::NaiveDateTime,
-    pub uuid: Uuid,
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {
-    #[sea_orm(has_many = "super::memberships::Entity")]
-    Memberships,
-}
-
-impl Related<super::memberships::Entity> for Entity {
-    fn to() -> RelationDef {
-        Relation::Memberships.def()
-    }
-}
-
-impl ActiveModelBehavior for ActiveModel {}
-
-impl From<Model> for lldap_domain::types::Group {
-    fn from(group: Model) -> Self {
-        Self {
-            id: group.group_id,
-            display_name: group.display_name,
-            creation_date: group.creation_date,
-            uuid: group.uuid,
-            users: vec![],
-            attributes: Vec::new(),
-        }
-    }
-}
-
-impl From<Model> for lldap_domain::types::GroupDetails {
-    fn from(group: Model) -> Self {
-        Self {
-            group_id: group.group_id,
-            display_name: group.display_name,
-            creation_date: group.creation_date,
-            uuid: group.uuid,
-            attributes: Vec::new(),
-        }
-    }
-}

server/src/domain/model/jwt_refresh_storage.rs

@@ -1,35 +0,0 @@
-//! `SeaORM` Entity. Generated by sea-orm-codegen 0.10.3
-
-use sea_orm::entity::prelude::*;
-use serde::{Deserialize, Serialize};
-
-use lldap_domain::types::UserId;
-
-#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
-#[sea_orm(table_name = "jwt_refresh_storage")]
-pub struct Model {
-    #[sea_orm(primary_key, auto_increment = false)]
-    pub refresh_token_hash: i64,
-    pub user_id: UserId,
-    pub expiry_date: chrono::NaiveDateTime,
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {
-    #[sea_orm(
-        belongs_to = "super::users::Entity",
-        from = "Column::UserId",
-        to = "super::users::Column::UserId",
-        on_update = "Cascade",
-        on_delete = "Cascade"
-    )]
-    Users,
-}
-
-impl Related<super::users::Entity> for Entity {
-    fn to() -> RelationDef {
-        Relation::Users.def()
-    }
-}
-
-impl ActiveModelBehavior for ActiveModel {}

server/src/domain/model/jwt_storage.rs

@@ -1,36 +0,0 @@
-//! `SeaORM` Entity. Generated by sea-orm-codegen 0.10.3
-
-use sea_orm::entity::prelude::*;
-use serde::{Deserialize, Serialize};
-
-use lldap_domain::types::UserId;
-
-#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
-#[sea_orm(table_name = "jwt_storage")]
-pub struct Model {
-    #[sea_orm(primary_key, auto_increment = false)]
-    pub jwt_hash: i64,
-    pub user_id: UserId,
-    pub expiry_date: chrono::NaiveDateTime,
-    pub blacklisted: bool,
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {
-    #[sea_orm(
-        belongs_to = "super::users::Entity",
-        from = "Column::UserId",
-        to = "super::users::Column::UserId",
-        on_update = "Cascade",
-        on_delete = "Cascade"
-    )]
-    Users,
-}
-
-impl Related<super::users::Entity> for Entity {
-    fn to() -> RelationDef {
-        Relation::Users.def()
-    }
-}
-
-impl ActiveModelBehavior for ActiveModel {}

server/src/domain/model/memberships.rs

@@ -1,73 +0,0 @@
-//! `SeaORM` Entity. Generated by sea-orm-codegen 0.10.3
-
-use sea_orm::entity::prelude::*;
-use serde::{Deserialize, Serialize};
-
-use lldap_domain::types::{GroupId, UserId};
-
-#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
-#[sea_orm(table_name = "memberships")]
-pub struct Model {
-    #[sea_orm(primary_key)]
-    pub user_id: UserId,
-    #[sea_orm(primary_key)]
-    pub group_id: GroupId,
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {
-    #[sea_orm(
-        belongs_to = "super::groups::Entity",
-        from = "Column::GroupId",
-        to = "super::groups::Column::GroupId",
-        on_update = "Cascade",
-        on_delete = "Cascade"
-    )]
-    Groups,
-    #[sea_orm(
-        belongs_to = "super::users::Entity",
-        from = "Column::UserId",
-        to = "super::users::Column::UserId",
-        on_update = "Cascade",
-        on_delete = "Cascade"
-    )]
-    Users,
-}
-
-impl Related<super::groups::Entity> for Entity {
-    fn to() -> RelationDef {
-        Relation::Groups.def()
-    }
-}
-
-impl Related<super::users::Entity> for Entity {
-    fn to() -> RelationDef {
-        Relation::Users.def()
-    }
-}
-
-#[derive(Debug)]
-pub struct UserToGroup;
-impl Linked for UserToGroup {
-    type FromEntity = super::User;
-
-    type ToEntity = super::Group;
-
-    fn link(&self) -> Vec<RelationDef> {
-        vec![Relation::Users.def().rev(), Relation::Groups.def()]
-    }
-}
-
-#[derive(Debug)]
-pub struct GroupToUser;
-impl Linked for GroupToUser {
-    type FromEntity = super::Group;
-
-    type ToEntity = super::User;
-
-    fn link(&self) -> Vec<RelationDef> {
-        vec![Relation::Groups.def().rev(), Relation::Users.def()]
-    }
-}
-
-impl ActiveModelBehavior for ActiveModel {}

server/src/domain/model/mod.rs

@@ -1,19 +0,0 @@
-pub mod prelude;
-
-pub(crate) mod deserialize;
-pub mod groups;
-pub mod jwt_refresh_storage;
-pub mod jwt_storage;
-pub mod memberships;
-pub mod password_reset_tokens;
-pub mod users;
-
-pub mod user_attribute_schema;
-pub mod user_attributes;
-pub mod user_object_classes;
-
-pub mod group_attribute_schema;
-pub mod group_attributes;
-pub mod group_object_classes;
-
-pub use prelude::*;

server/src/domain/model/password_reset_tokens.rs

@@ -1,35 +0,0 @@
-//! `SeaORM` Entity. Generated by sea-orm-codegen 0.10.3
-
-use sea_orm::entity::prelude::*;
-use serde::{Deserialize, Serialize};
-
-use lldap_domain::types::UserId;
-
-#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
-#[sea_orm(table_name = "password_reset_tokens")]
-pub struct Model {
-    #[sea_orm(primary_key, auto_increment = false)]
-    pub token: String,
-    pub user_id: UserId,
-    pub expiry_date: chrono::NaiveDateTime,
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {
-    #[sea_orm(
-        belongs_to = "super::users::Entity",
-        from = "Column::UserId",
-        to = "super::users::Column::UserId",
-        on_update = "Cascade",
-        on_delete = "Cascade"
-    )]
-    Users,
-}
-
-impl Related<super::users::Entity> for Entity {
-    fn to() -> RelationDef {
-        Relation::Users.def()
-    }
-}
-
-impl ActiveModelBehavior for ActiveModel {}

server/src/domain/model/prelude.rs

@@ -1,26 +0,0 @@
-//! `SeaORM` Entity. Generated by sea-orm-codegen 0.10.3
-
-pub use super::group_attribute_schema::Column as GroupAttributeSchemaColumn;
-pub use super::group_attribute_schema::Entity as GroupAttributeSchema;
-pub use super::group_attributes::Column as GroupAttributesColumn;
-pub use super::group_attributes::Entity as GroupAttributes;
-pub use super::group_object_classes::Column as GroupObjectClassesColumn;
-pub use super::group_object_classes::Entity as GroupObjectClasses;
-pub use super::groups::Column as GroupColumn;
-pub use super::groups::Entity as Group;
-pub use super::jwt_refresh_storage::Column as JwtRefreshStorageColumn;
-pub use super::jwt_refresh_storage::Entity as JwtRefreshStorage;
-pub use super::jwt_storage::Column as JwtStorageColumn;
-pub use super::jwt_storage::Entity as JwtStorage;
-pub use super::memberships::Column as MembershipColumn;
-pub use super::memberships::Entity as Membership;
-pub use super::password_reset_tokens::Column as PasswordResetTokensColumn;
-pub use super::password_reset_tokens::Entity as PasswordResetTokens;
-pub use super::user_attribute_schema::Column as UserAttributeSchemaColumn;
-pub use super::user_attribute_schema::Entity as UserAttributeSchema;
-pub use super::user_attributes::Column as UserAttributesColumn;
-pub use super::user_attributes::Entity as UserAttributes;
-pub use super::user_object_classes::Column as UserObjectClassesColumn;
-pub use super::user_object_classes::Entity as UserObjectClasses;
-pub use super::users::Column as UserColumn;
-pub use super::users::Entity as User;

server/src/domain/model/user_attribute_schema.rs

@@ -1,56 +0,0 @@
-use sea_orm::entity::prelude::*;
-use serde::{Deserialize, Serialize};
-
-use lldap_domain::{
-    schema::AttributeSchema,
-    types::{AttributeName, AttributeType},
-};
-
-#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
-#[sea_orm(table_name = "user_attribute_schema")]
-pub struct Model {
-    #[sea_orm(
-        primary_key,
-        auto_increment = false,
-        column_name = "user_attribute_schema_name"
-    )]
-    pub attribute_name: AttributeName,
-    #[sea_orm(column_name = "user_attribute_schema_type")]
-    pub attribute_type: AttributeType,
-    #[sea_orm(column_name = "user_attribute_schema_is_list")]
-    pub is_list: bool,
-    #[sea_orm(column_name = "user_attribute_schema_is_user_visible")]
-    pub is_user_visible: bool,
-    #[sea_orm(column_name = "user_attribute_schema_is_user_editable")]
-    pub is_user_editable: bool,
-    #[sea_orm(column_name = "user_attribute_schema_is_hardcoded")]
-    pub is_hardcoded: bool,
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {
-    #[sea_orm(has_many = "super::user_attributes::Entity")]
-    UserAttributes,
-}
-
-impl Related<super::UserAttributes> for Entity {
-    fn to() -> RelationDef {
-        Relation::UserAttributes.def()
-    }
-}
-
-impl ActiveModelBehavior for ActiveModel {}
-
-impl From<Model> for AttributeSchema {
-    fn from(value: Model) -> Self {
-        Self {
-            name: value.attribute_name,
-            attribute_type: value.attribute_type,
-            is_list: value.is_list,
-            is_visible: value.is_user_visible,
-            is_editable: value.is_user_editable,
-            is_hardcoded: value.is_hardcoded,
-            is_readonly: false,
-        }
-    }
-}

server/src/domain/model/user_attributes.rs

@@ -1,57 +0,0 @@
-use sea_orm::entity::prelude::*;
-use serde::{Deserialize, Serialize};
-
-use lldap_domain::types::{AttributeName, Serialized, UserId};
-
-#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
-#[sea_orm(table_name = "user_attributes")]
-pub struct Model {
-    #[sea_orm(
-        primary_key,
-        auto_increment = false,
-        column_name = "user_attribute_user_id"
-    )]
-    pub user_id: UserId,
-    #[sea_orm(
-        primary_key,
-        auto_increment = false,
-        column_name = "user_attribute_name"
-    )]
-    pub attribute_name: AttributeName,
-    #[sea_orm(column_name = "user_attribute_value")]
-    pub value: Serialized,
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {
-    #[sea_orm(
-        belongs_to = "super::users::Entity",
-        from = "Column::UserId",
-        to = "super::users::Column::UserId",
-        on_update = "Cascade",
-        on_delete = "Cascade"
-    )]
-    Users,
-    #[sea_orm(
-        belongs_to = "super::user_attribute_schema::Entity",
-        from = "Column::AttributeName",
-        to = "super::user_attribute_schema::Column::AttributeName",
-        on_update = "Cascade",
-        on_delete = "Cascade"
-    )]
-    UserAttributeSchema,
-}
-
-impl Related<super::User> for Entity {
-    fn to() -> RelationDef {
-        Relation::Users.def()
-    }
-}
-
-impl Related<super::UserAttributeSchema> for Entity {
-    fn to() -> RelationDef {
-        Relation::UserAttributeSchema.def()
-    }
-}
-
-impl ActiveModelBehavior for ActiveModel {}

server/src/domain/model/user_object_classes.rs

@@ -1,23 +0,0 @@
-use sea_orm::entity::prelude::*;
-use serde::{Deserialize, Serialize};
-
-use lldap_domain::types::LdapObjectClass;
-
-#[derive(Clone, Debug, PartialEq, DeriveEntityModel, Eq, Serialize, Deserialize)]
-#[sea_orm(table_name = "user_object_classes")]
-pub struct Model {
-    #[sea_orm(primary_key, auto_increment = false)]
-    pub lower_object_class: String,
-    pub object_class: LdapObjectClass,
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {}
-
-impl ActiveModelBehavior for ActiveModel {}
-
-impl From<Model> for LdapObjectClass {
-    fn from(value: Model) -> Self {
-        value.object_class
-    }
-}

server/src/domain/model/users.rs

@@ -1,126 +0,0 @@
-//! `SeaORM` Entity. Generated by sea-orm-codegen 0.10.3
-
-use sea_orm::{entity::prelude::*, sea_query::BlobSize};
-use serde::{Deserialize, Serialize};
-
-use lldap_domain::types::{Email, UserId, Uuid};
-
-#[derive(Copy, Clone, Default, Debug, DeriveEntity)]
-pub struct Entity;
-
-#[derive(Clone, Debug, PartialEq, DeriveModel, Eq, Serialize, Deserialize, DeriveActiveModel)]
-#[sea_orm(table_name = "users")]
-pub struct Model {
-    #[sea_orm(primary_key, auto_increment = false)]
-    pub user_id: UserId,
-    pub email: Email,
-    pub lowercase_email: String,
-    pub display_name: Option<String>,
-    pub creation_date: chrono::NaiveDateTime,
-    pub password_hash: Option<Vec<u8>>,
-    pub totp_secret: Option<String>,
-    pub mfa_type: Option<String>,
-    pub uuid: Uuid,
-}
-
-impl EntityName for Entity {
-    fn table_name(&self) -> &str {
-        "users"
-    }
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DeriveColumn, PartialEq, Eq, Serialize, Deserialize)]
-pub enum Column {
-    UserId,
-    Email,
-    LowercaseEmail,
-    DisplayName,
-    CreationDate,
-    PasswordHash,
-    TotpSecret,
-    MfaType,
-    Uuid,
-}
-
-impl ColumnTrait for Column {
-    type EntityName = Entity;
-
-    fn def(&self) -> ColumnDef {
-        match self {
-            Column::UserId => ColumnType::String(Some(255)),
-            Column::Email => ColumnType::String(Some(255)),
-            Column::LowercaseEmail => ColumnType::String(Some(255)),
-            Column::DisplayName => ColumnType::String(Some(255)),
-            Column::CreationDate => ColumnType::DateTime,
-            Column::PasswordHash => ColumnType::Binary(BlobSize::Medium),
-            Column::TotpSecret => ColumnType::String(Some(64)),
-            Column::MfaType => ColumnType::String(Some(64)),
-            Column::Uuid => ColumnType::String(Some(36)),
-        }
-        .def()
-    }
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]
-pub enum Relation {
-    #[sea_orm(has_many = "super::memberships::Entity")]
-    Memberships,
-    #[sea_orm(has_many = "super::jwt_refresh_storage::Entity")]
-    JwtRefreshStorage,
-    #[sea_orm(has_many = "super::jwt_storage::Entity")]
-    JwtStorage,
-    #[sea_orm(has_many = "super::password_reset_tokens::Entity")]
-    PasswordResetTokens,
-}
-
-#[derive(Copy, Clone, Debug, EnumIter, DerivePrimaryKey)]
-pub enum PrimaryKey {
-    UserId,
-}
-
-impl PrimaryKeyTrait for PrimaryKey {
-    type ValueType = UserId;
-
-    fn auto_increment() -> bool {
-        false
-    }
-}
-
-impl Related<super::memberships::Entity> for Entity {
-    fn to() -> RelationDef {
-        Relation::Memberships.def()
-    }
-}
-
-impl Related<super::jwt_refresh_storage::Entity> for Entity {
-    fn to() -> RelationDef {
-        Relation::JwtRefreshStorage.def()
-    }
-}
-
-impl Related<super::jwt_storage::Entity> for Entity {
-    fn to() -> RelationDef {
-        Relation::JwtStorage.def()
-    }
-}
-
-impl Related<super::password_reset_tokens::Entity> for Entity {
-    fn to() -> RelationDef {
-        Relation::PasswordResetTokens.def()
-    }
-}
-
-impl ActiveModelBehavior for ActiveModel {}
-
-impl From<Model> for lldap_domain::types::User {
-    fn from(user: Model) -> Self {
-        Self {
-            user_id: user.user_id,
-            email: user.email,
-            display_name: user.display_name,
-            creation_date: user.creation_date,
-            uuid: user.uuid,
-            attributes: Vec::new(),
-        }
-    }
-}

server/src/domain/opaque_handler.rs

@@ -1,6 +1,6 @@
-use crate::domain::error::Result;
 use async_trait::async_trait;
 use lldap_domain::types::UserId;
+use lldap_domain_model::error::Result;
 
 pub use lldap_auth::{login, registration};
 

server/src/domain/sql_group_backend_handler.rs

@@ -1,8 +1,6 @@
 use crate::{
     domain::{
-        error::{DomainError, Result},
         handler::{GroupBackendHandler, GroupListerBackendHandler, GroupRequestFilter},
-        model::{self, deserialize, GroupColumn, MembershipColumn},
         sql_backend_handler::SqlBackendHandler,
     },
     infra::access_control::UserReadableBackendHandler,
@@ -12,6 +10,10 @@ use lldap_domain::{
     requests::{CreateGroupRequest, UpdateGroupRequest},
     types::{AttributeName, Group, GroupDetails, GroupId, Serialized, Uuid},
 };
+use lldap_domain_model::{
+    error::{DomainError, Result},
+    model::{self, deserialize, GroupColumn, MembershipColumn},
+};
 use sea_orm::{
     sea_query::{Alias, Cond, Expr, Func, IntoCondition, OnConflict, SimpleExpr},
     ActiveModelTrait, ColumnTrait, DatabaseTransaction, EntityTrait, QueryFilter, QueryOrder,

server/src/domain/sql_opaque_handler.rs

@@ -1,7 +1,5 @@
 use super::{
-    error::{DomainError, Result},
     handler::{BindRequest, LoginHandler},
-    model::{self, UserColumn},
     opaque_handler::{login, registration, OpaqueHandler},
     sql_backend_handler::SqlBackendHandler,
 };
@@ -9,6 +7,10 @@ use async_trait::async_trait;
 use base64::Engine;
 use lldap_auth::opaque;
 use lldap_domain::types::UserId;
+use lldap_domain_model::{
+    error::{DomainError, Result},
+    model::{self, UserColumn},
+};
 use sea_orm::{ActiveModelTrait, ActiveValue, EntityTrait, QuerySelect};
 use secstr::SecUtf8;
 use tracing::{debug, info, instrument, warn};

server/src/domain/sql_schema_backend_handler.rs

@@ -1,7 +1,5 @@
 use crate::domain::{
-    error::{DomainError, Result},
     handler::{ReadSchemaBackendHandler, SchemaBackendHandler},
-    model,
     sql_backend_handler::SqlBackendHandler,
 };
 use async_trait::async_trait;
@@ -10,6 +8,10 @@ use lldap_domain::{
     schema::{AttributeList, AttributeSchema, Schema},
     types::{AttributeName, LdapObjectClass},
 };
+use lldap_domain_model::{
+    error::{DomainError, Result},
+    model,
+};
 use sea_orm::{
     ActiveModelTrait, DatabaseTransaction, EntityTrait, QueryOrder, Set, TransactionTrait,
 };

server/src/domain/sql_user_backend_handler.rs

@@ -1,9 +1,7 @@
 use crate::domain::{
-    error::{DomainError, Result},
     handler::{
         ReadSchemaBackendHandler, UserBackendHandler, UserListerBackendHandler, UserRequestFilter,
     },
-    model::{self, deserialize, GroupColumn, UserColumn},
     sql_backend_handler::SqlBackendHandler,
 };
 use async_trait::async_trait;
@@ -11,6 +9,10 @@ use lldap_domain::{
     requests::{CreateUserRequest, UpdateUserRequest},
     types::{AttributeName, GroupDetails, GroupId, Serialized, User, UserAndGroups, UserId, Uuid},
 };
+use lldap_domain_model::{
+    error::{DomainError, Result},
+    model::{self, deserialize, GroupColumn, UserColumn},
+};
 use sea_orm::{
     sea_query::{
         query::OnConflict, Alias, Cond, Expr, Func, IntoColumnRef, IntoCondition, SimpleExpr,
@@ -414,10 +416,9 @@ impl UserBackendHandler for SqlBackendHandler {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::domain::{
-        handler::SubStringFilter, model::UserColumn, sql_backend_handler::tests::*,
-    };
+    use crate::domain::{handler::SubStringFilter, sql_backend_handler::tests::*};
     use lldap_domain::types::{Attribute, JpegPhoto};
+    use lldap_domain_model::model::UserColumn;
     use pretty_assertions::{assert_eq, assert_ne};
 
     #[tokio::test]

server/src/infra/access_control.rs

@@ -4,7 +4,6 @@ use async_trait::async_trait;
 use tracing::info;
 
 use crate::domain::{
-    error::Result,
     handler::{
         BackendHandler, GroupBackendHandler, GroupListerBackendHandler, GroupRequestFilter,
         ReadSchemaBackendHandler, SchemaBackendHandler, UserBackendHandler,
@@ -23,6 +22,7 @@ use lldap_domain::{
         UserAndGroups, UserId,
     },
 };
+use lldap_domain_model::error::Result;
 
 #[derive(Clone, Copy, PartialEq, Eq, Debug)]
 pub enum Permission {

server/src/infra/auth_service.rs

@@ -23,12 +23,11 @@ use tracing::{debug, info, instrument, warn};
 
 use lldap_auth::{login, password_reset, registration, JWTClaims};
 use lldap_domain::types::{GroupDetails, GroupName, UserId};
+use lldap_domain_model::{error::DomainError, model::UserColumn};
 
 use crate::{
     domain::{
-        error::DomainError,
         handler::{BackendHandler, BindRequest, LoginHandler, UserRequestFilter},
-        model::UserColumn,
         opaque_handler::OpaqueHandler,
     },
     infra::{

server/src/infra/db_cleaner.rs

@@ -1,9 +1,9 @@
-use crate::domain::{
-    model::{self, JwtRefreshStorageColumn, JwtStorageColumn, PasswordResetTokensColumn},
-    sql_tables::DbConnection,
-};
+use crate::domain::sql_tables::DbConnection;
 use actix::prelude::{Actor, AsyncContext, Context};
 use cron::Schedule;
+use lldap_domain_model::model::{
+    self, JwtRefreshStorageColumn, JwtStorageColumn, PasswordResetTokensColumn,
+};
 use sea_orm::{ColumnTrait, EntityTrait, QueryFilter};
 use std::{str::FromStr, time::Duration};
 use tracing::{error, info, instrument};

server/src/infra/graphql/query.rs

@@ -5,7 +5,6 @@ use crate::{
         deserialize::deserialize_attribute_value,
         handler::{BackendHandler, ReadSchemaBackendHandler},
         ldap::utils::{map_user_field, UserFieldType},
-        model::UserColumn,
         schema::PublicSchema,
     },
     infra::{
@@ -19,6 +18,7 @@ use juniper::{graphql_object, FieldResult, GraphQLInputObject};
 use lldap_domain::types::{
     AttributeType, Cardinality, GroupDetails, GroupId, LdapObjectClass, UserId,
 };
+use lldap_domain_model::model::UserColumn;
 use serde::{Deserialize, Serialize};
 use tracing::{debug, debug_span, Instrument, Span};
 

server/src/infra/ldap_handler.rs

@@ -926,16 +926,18 @@ mod tests {
     use super::*;
     use crate::{
         domain::handler::*,
-        domain::model::UserColumn,
         infra::test_utils::{setup_default_schema, MockTestBackendHandler},
     };
     use chrono::TimeZone;
     use ldap3_proto::proto::{
         LdapDerefAliases, LdapSearchScope, LdapSubstringFilter, LdapWhoamiRequest,
     };
-    use lldap_domain::schema::{AttributeList, AttributeSchema, Schema};
-    use lldap_domain::types::*;
-    use lldap_domain::uuid;
+    use lldap_domain::{
+        schema::{AttributeList, AttributeSchema, Schema},
+        types::*,
+        uuid,
+    };
+    use lldap_domain_model::model::UserColumn;
     use mockall::predicate::eq;
     use pretty_assertions::assert_eq;
     use std::collections::HashSet;
@@ -1854,7 +1856,7 @@ mod tests {
             ]))))
             .times(1)
             .return_once(|_| {
-                Err(crate::domain::error::DomainError::InternalError(
+                Err(lldap_domain_model::error::DomainError::InternalError(
                     "Error getting groups".to_string(),
                 ))
             });

server/src/infra/sql_backend_handler.rs

@@ -1,12 +1,12 @@
 use super::tcp_backend_handler::TcpBackendHandler;
-use crate::domain::{
-    error::*,
-    model::{self, JwtRefreshStorageColumn, JwtStorageColumn, PasswordResetTokensColumn},
-    sql_backend_handler::SqlBackendHandler,
-};
+use crate::domain::sql_backend_handler::SqlBackendHandler;
 use async_trait::async_trait;
 use chrono::NaiveDateTime;
 use lldap_domain::types::UserId;
+use lldap_domain_model::{
+    error::*,
+    model::{self, JwtRefreshStorageColumn, JwtStorageColumn, PasswordResetTokensColumn},
+};
 use sea_orm::{
     sea_query::{Cond, Expr},
     ActiveModelTrait, ColumnTrait, EntityTrait, IntoActiveModel, QueryFilter, QuerySelect,

server/src/infra/tcp_backend_handler.rs

@@ -2,8 +2,8 @@ use async_trait::async_trait;
 use chrono::NaiveDateTime;
 use std::collections::HashSet;
 
-use crate::domain::error::Result;
 use lldap_domain::types::UserId;
+use lldap_domain_model::error::Result;
 
 #[async_trait]
 pub trait TcpBackendHandler: Sync {

server/src/infra/tcp_server.rs

@@ -1,6 +1,5 @@
 use crate::{
     domain::{
-        error::DomainError,
         handler::{BackendHandler, LoginHandler},
         opaque_handler::OpaqueHandler,
     },
@@ -19,6 +18,7 @@ use actix_service::map_config;
 use actix_web::{dev::AppConfig, guard, web, App, HttpResponse, Responder};
 use anyhow::{Context, Result};
 use hmac::Hmac;
+use lldap_domain_model::error::DomainError;
 use sha2::Sha512;
 use std::collections::HashSet;
 use std::path::PathBuf;

server/src/infra/test_utils.rs

@@ -1,4 +1,4 @@
-use crate::domain::{error::Result, handler::*, opaque_handler::*};
+use crate::domain::{handler::*, opaque_handler::*};
 use lldap_domain::{
     requests::{
         CreateAttributeRequest, CreateGroupRequest, CreateUserRequest, UpdateGroupRequest,
@@ -7,6 +7,7 @@ use lldap_domain::{
     schema::{AttributeList, AttributeSchema, Schema},
     types::*,
 };
+use lldap_domain_model::error::Result;
 
 use async_trait::async_trait;
 use std::collections::HashSet;