domain-handlers: move backend handler traits to separate crate

server/src/domain/handler.rs

@@ -1,209 +0,0 @@
-use async_trait::async_trait;
-use lldap_domain::{
-    requests::{
-        CreateAttributeRequest, CreateGroupRequest, CreateUserRequest, UpdateGroupRequest,
-        UpdateUserRequest,
-    },
-    schema::Schema,
-    types::{
-        AttributeName, AttributeValue, Group, GroupDetails, GroupId, GroupName, LdapObjectClass,
-        User, UserAndGroups, UserId, Uuid,
-    },
-};
-use lldap_domain_model::{error::Result, model::UserColumn};
-use serde::{Deserialize, Serialize};
-use std::collections::HashSet;
-
-#[derive(PartialEq, Eq, Debug, Serialize, Deserialize, Clone)]
-pub struct BindRequest {
-    pub name: UserId,
-    pub password: String,
-}
-
-#[derive(PartialEq, Eq, Debug, Serialize, Deserialize, Clone)]
-pub struct SubStringFilter {
-    pub initial: Option<String>,
-    pub any: Vec<String>,
-    pub final_: Option<String>,
-}
-
-impl SubStringFilter {
-    pub fn to_sql_filter(&self) -> String {
-        let mut filter = String::with_capacity(
-            self.initial.as_ref().map(String::len).unwrap_or_default()
-                + 1
-                + self.any.iter().map(String::len).sum::<usize>()
-                + self.any.len()
-                + self.final_.as_ref().map(String::len).unwrap_or_default(),
-        );
-        if let Some(f) = &self.initial {
-            filter.push_str(&f.to_ascii_lowercase());
-        }
-        filter.push('%');
-        for part in self.any.iter() {
-            filter.push_str(&part.to_ascii_lowercase());
-            filter.push('%');
-        }
-        if let Some(f) = &self.final_ {
-            filter.push_str(&f.to_ascii_lowercase());
-        }
-        filter
-    }
-}
-
-#[derive(PartialEq, Eq, Debug, Serialize, Deserialize, Clone)]
-pub enum UserRequestFilter {
-    And(Vec<UserRequestFilter>),
-    Or(Vec<UserRequestFilter>),
-    Not(Box<UserRequestFilter>),
-    UserId(UserId),
-    UserIdSubString(SubStringFilter),
-    Equality(UserColumn, String),
-    AttributeEquality(AttributeName, AttributeValue),
-    SubString(UserColumn, SubStringFilter),
-    // Check if a user belongs to a group identified by name.
-    MemberOf(GroupName),
-    // Same, by id.
-    MemberOfId(GroupId),
-    CustomAttributePresent(AttributeName),
-}
-
-impl From<bool> for UserRequestFilter {
-    fn from(val: bool) -> Self {
-        if val {
-            Self::And(vec![])
-        } else {
-            Self::Not(Box::new(Self::And(vec![])))
-        }
-    }
-}
-
-#[derive(PartialEq, Eq, Debug, Serialize, Deserialize, Clone)]
-pub enum GroupRequestFilter {
-    And(Vec<GroupRequestFilter>),
-    Or(Vec<GroupRequestFilter>),
-    Not(Box<GroupRequestFilter>),
-    DisplayName(GroupName),
-    DisplayNameSubString(SubStringFilter),
-    Uuid(Uuid),
-    GroupId(GroupId),
-    // Check if the group contains a user identified by uid.
-    Member(UserId),
-    AttributeEquality(AttributeName, AttributeValue),
-    CustomAttributePresent(AttributeName),
-}
-
-impl From<bool> for GroupRequestFilter {
-    fn from(val: bool) -> Self {
-        if val {
-            Self::And(vec![])
-        } else {
-            Self::Not(Box::new(Self::And(vec![])))
-        }
-    }
-}
-
-#[async_trait]
-pub trait LoginHandler: Send + Sync {
-    async fn bind(&self, request: BindRequest) -> Result<()>;
-}
-
-#[async_trait]
-pub trait GroupListerBackendHandler: ReadSchemaBackendHandler {
-    async fn list_groups(&self, filters: Option<GroupRequestFilter>) -> Result<Vec<Group>>;
-}
-
-#[async_trait]
-pub trait GroupBackendHandler: ReadSchemaBackendHandler {
-    async fn get_group_details(&self, group_id: GroupId) -> Result<GroupDetails>;
-    async fn update_group(&self, request: UpdateGroupRequest) -> Result<()>;
-    async fn create_group(&self, request: CreateGroupRequest) -> Result<GroupId>;
-    async fn delete_group(&self, group_id: GroupId) -> Result<()>;
-}
-
-#[async_trait]
-pub trait UserListerBackendHandler: ReadSchemaBackendHandler {
-    async fn list_users(
-        &self,
-        filters: Option<UserRequestFilter>,
-        get_groups: bool,
-    ) -> Result<Vec<UserAndGroups>>;
-}
-
-#[async_trait]
-pub trait UserBackendHandler: ReadSchemaBackendHandler {
-    async fn get_user_details(&self, user_id: &UserId) -> Result<User>;
-    async fn create_user(&self, request: CreateUserRequest) -> Result<()>;
-    async fn update_user(&self, request: UpdateUserRequest) -> Result<()>;
-    async fn delete_user(&self, user_id: &UserId) -> Result<()>;
-    async fn add_user_to_group(&self, user_id: &UserId, group_id: GroupId) -> Result<()>;
-    async fn remove_user_from_group(&self, user_id: &UserId, group_id: GroupId) -> Result<()>;
-    async fn get_user_groups(&self, user_id: &UserId) -> Result<HashSet<GroupDetails>>;
-}
-
-#[async_trait]
-pub trait ReadSchemaBackendHandler {
-    async fn get_schema(&self) -> Result<Schema>;
-}
-
-#[async_trait]
-pub trait SchemaBackendHandler: ReadSchemaBackendHandler {
-    async fn add_user_attribute(&self, request: CreateAttributeRequest) -> Result<()>;
-    async fn add_group_attribute(&self, request: CreateAttributeRequest) -> Result<()>;
-    // Note: It's up to the caller to make sure that the attribute is not hardcoded.
-    async fn delete_user_attribute(&self, name: &AttributeName) -> Result<()>;
-    async fn delete_group_attribute(&self, name: &AttributeName) -> Result<()>;
-
-    async fn add_user_object_class(&self, name: &LdapObjectClass) -> Result<()>;
-    async fn add_group_object_class(&self, name: &LdapObjectClass) -> Result<()>;
-    async fn delete_user_object_class(&self, name: &LdapObjectClass) -> Result<()>;
-    async fn delete_group_object_class(&self, name: &LdapObjectClass) -> Result<()>;
-}
-
-#[async_trait]
-pub trait BackendHandler:
-    Send
-    + Sync
-    + GroupBackendHandler
-    + UserBackendHandler
-    + UserListerBackendHandler
-    + GroupListerBackendHandler
-    + ReadSchemaBackendHandler
-    + SchemaBackendHandler
-{
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-    use base64::Engine;
-    use lldap_domain::types::JpegPhoto;
-    use pretty_assertions::assert_ne;
-
-    #[test]
-    fn test_uuid_time() {
-        use chrono::prelude::*;
-        let user_id = "bob";
-        let date1 = Utc
-            .with_ymd_and_hms(2014, 7, 8, 9, 10, 11)
-            .unwrap()
-            .naive_utc();
-        let date2 = Utc
-            .with_ymd_and_hms(2014, 7, 8, 9, 10, 12)
-            .unwrap()
-            .naive_utc();
-        assert_ne!(
-            Uuid::from_name_and_date(user_id, &date1),
-            Uuid::from_name_and_date(user_id, &date2)
-        );
-    }
-
-    #[test]
-    fn test_jpeg_try_from_bytes() {
-        let base64_raw = "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";
-        let base64_jpeg = base64::engine::general_purpose::STANDARD
-            .decode(base64_raw)
-            .unwrap();
-        JpegPhoto::try_from(base64_jpeg).unwrap();
-    }
-}

server/src/domain/ldap/group.rs

@@ -6,7 +6,6 @@ use tracing::{debug, instrument, warn};
 
 use crate::domain::{
     deserialize::deserialize_attribute_value,
-    handler::{GroupListerBackendHandler, GroupRequestFilter},
     ldap::{
         error::{LdapError, LdapResult},
         utils::{
@@ -21,6 +20,7 @@ use crate::domain::{
 use lldap_domain::types::{
     AttributeName, AttributeType, Group, GroupId, LdapObjectClass, UserId, Uuid,
 };
+use lldap_domain_handlers::handler::{GroupListerBackendHandler, GroupRequestFilter};
 
 pub fn get_group_attribute(
     group: &Group,

server/src/domain/ldap/user.rs

@@ -6,7 +6,6 @@ use tracing::{debug, instrument, warn};
 
 use crate::domain::{
     deserialize::deserialize_attribute_value,
-    handler::{UserListerBackendHandler, UserRequestFilter},
     ldap::{
         error::{LdapError, LdapResult},
         utils::{
@@ -21,6 +20,7 @@ use crate::domain::{
 use lldap_domain::types::{
     AttributeName, AttributeType, GroupDetails, LdapObjectClass, User, UserAndGroups, UserId,
 };
+use lldap_domain_handlers::handler::{UserListerBackendHandler, UserRequestFilter};
 use lldap_domain_model::model::UserColumn;
 
 pub fn get_user_attribute(

server/src/domain/ldap/utils.rs

@@ -1,33 +1,16 @@
 use std::collections::BTreeMap;
 
 use chrono::TimeZone;
-use ldap3_proto::{proto::LdapSubstringFilter, LdapResultCode};
+use ldap3_proto::LdapResultCode;
 use tracing::{debug, instrument, warn};
 
 use crate::domain::{
-    handler::SubStringFilter,
     ldap::error::{LdapError, LdapResult},
     schema::PublicSchema,
 };
 use lldap_domain::types::{
     Attribute, AttributeName, AttributeType, AttributeValue, Cardinality, GroupName, UserId,
 };
-
-impl From<LdapSubstringFilter> for SubStringFilter {
-    fn from(
-        LdapSubstringFilter {
-            initial,
-            any,
-            final_,
-        }: LdapSubstringFilter,
-    ) -> Self {
-        Self {
-            initial,
-            any,
-            final_,
-        }
-    }
-}
 use lldap_domain_model::model::UserColumn;
 
 fn make_dn_pair<I>(mut iter: I) -> LdapResult<(String, String)>

server/src/domain/mod.rs

@@ -1,5 +1,4 @@
 pub mod deserialize;
-pub mod handler;
 pub mod ldap;
 pub mod opaque_handler;
 pub mod schema;

server/src/domain/sql_backend_handler.rs

@@ -1,7 +1,8 @@
-use crate::domain::{handler::BackendHandler, sql_tables::DbConnection};
-use crate::infra::configuration::Configuration;
+use crate::{domain::sql_tables::DbConnection, infra::configuration::Configuration};
 use async_trait::async_trait;
 
+use lldap_domain_handlers::handler::BackendHandler;
+
 #[derive(Clone)]
 pub struct SqlBackendHandler {
     pub(crate) config: Configuration,
@@ -20,21 +21,15 @@ impl BackendHandler for SqlBackendHandler {}
 #[cfg(test)]
 pub mod tests {
     use super::*;
-    use crate::{
-        domain::{
-            handler::{
-                GroupBackendHandler, UserBackendHandler, UserListerBackendHandler,
-                UserRequestFilter,
-            },
-            sql_tables::init_table,
-        },
-        infra::configuration::ConfigurationBuilder,
-    };
+    use crate::{domain::sql_tables::init_table, infra::configuration::ConfigurationBuilder};
     use lldap_auth::{opaque, registration};
     use lldap_domain::{
         requests::{CreateGroupRequest, CreateUserRequest},
         types::{Attribute as DomainAttribute, GroupId, UserId},
     };
+    use lldap_domain_handlers::handler::{
+        GroupBackendHandler, UserBackendHandler, UserListerBackendHandler, UserRequestFilter,
+    };
     use pretty_assertions::assert_eq;
     use sea_orm::Database;
 

server/src/domain/sql_group_backend_handler.rs

@@ -1,8 +1,5 @@
 use crate::{
-    domain::{
-        handler::{GroupBackendHandler, GroupListerBackendHandler, GroupRequestFilter},
-        sql_backend_handler::SqlBackendHandler,
-    },
+    domain::sql_backend_handler::SqlBackendHandler,
     infra::access_control::UserReadableBackendHandler,
 };
 use async_trait::async_trait;
@@ -10,6 +7,9 @@ use lldap_domain::{
     requests::{CreateGroupRequest, UpdateGroupRequest},
     types::{AttributeName, Group, GroupDetails, GroupId, Serialized, Uuid},
 };
+use lldap_domain_handlers::handler::{
+    GroupBackendHandler, GroupListerBackendHandler, GroupRequestFilter,
+};
 use lldap_domain_model::{
     error::{DomainError, Result},
     model::{self, deserialize, GroupColumn, MembershipColumn},
@@ -336,14 +336,12 @@ impl SqlBackendHandler {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::domain::{
-        handler::{SchemaBackendHandler, SubStringFilter},
-        sql_backend_handler::tests::*,
-    };
+    use crate::domain::sql_backend_handler::tests::*;
     use lldap_domain::{
         requests::CreateAttributeRequest,
         types::{Attribute, AttributeType, GroupName, UserId},
     };
+    use lldap_domain_handlers::handler::{SchemaBackendHandler, SubStringFilter};
     use pretty_assertions::assert_eq;
 
     async fn get_group_ids(

server/src/domain/sql_opaque_handler.rs

@@ -1,5 +1,4 @@
 use super::{
-    handler::{BindRequest, LoginHandler},
     opaque_handler::{login, registration, OpaqueHandler},
     sql_backend_handler::SqlBackendHandler,
 };
@@ -7,6 +6,7 @@ use async_trait::async_trait;
 use base64::Engine;
 use lldap_auth::opaque;
 use lldap_domain::types::UserId;
+use lldap_domain_handlers::handler::{BindRequest, LoginHandler};
 use lldap_domain_model::{
     error::{DomainError, Result},
     model::{self, UserColumn},

server/src/domain/sql_schema_backend_handler.rs

@@ -1,13 +1,11 @@
-use crate::domain::{
-    handler::{ReadSchemaBackendHandler, SchemaBackendHandler},
-    sql_backend_handler::SqlBackendHandler,
-};
+use crate::domain::sql_backend_handler::SqlBackendHandler;
 use async_trait::async_trait;
 use lldap_domain::{
     requests::CreateAttributeRequest,
     schema::{AttributeList, AttributeSchema, Schema},
     types::{AttributeName, LdapObjectClass},
 };
+use lldap_domain_handlers::handler::{ReadSchemaBackendHandler, SchemaBackendHandler};
 use lldap_domain_model::{
     error::{DomainError, Result},
     model,
@@ -177,13 +175,11 @@ impl SqlBackendHandler {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::domain::{
-        handler::{UserBackendHandler, UserRequestFilter},
-        sql_backend_handler::tests::*,
-    };
+    use crate::domain::sql_backend_handler::tests::*;
     use lldap_domain::requests::UpdateUserRequest;
     use lldap_domain::schema::AttributeList;
     use lldap_domain::types::{Attribute, AttributeType};
+    use lldap_domain_handlers::handler::{UserBackendHandler, UserRequestFilter};
     use pretty_assertions::assert_eq;
 
     #[tokio::test]

server/src/domain/sql_user_backend_handler.rs

@@ -1,14 +1,12 @@
-use crate::domain::{
-    handler::{
-        ReadSchemaBackendHandler, UserBackendHandler, UserListerBackendHandler, UserRequestFilter,
-    },
-    sql_backend_handler::SqlBackendHandler,
-};
+use crate::domain::sql_backend_handler::SqlBackendHandler;
 use async_trait::async_trait;
 use lldap_domain::{
     requests::{CreateUserRequest, UpdateUserRequest},
     types::{AttributeName, GroupDetails, GroupId, Serialized, User, UserAndGroups, UserId, Uuid},
 };
+use lldap_domain_handlers::handler::{
+    ReadSchemaBackendHandler, UserBackendHandler, UserListerBackendHandler, UserRequestFilter,
+};
 use lldap_domain_model::{
     error::{DomainError, Result},
     model::{self, deserialize, GroupColumn, UserColumn},
@@ -416,8 +414,9 @@ impl UserBackendHandler for SqlBackendHandler {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::domain::{handler::SubStringFilter, sql_backend_handler::tests::*};
+    use crate::domain::sql_backend_handler::tests::*;
     use lldap_domain::types::{Attribute, JpegPhoto};
+    use lldap_domain_handlers::handler::SubStringFilter;
     use lldap_domain_model::model::UserColumn;
     use pretty_assertions::{assert_eq, assert_ne};
 

server/src/infra/access_control.rs

@@ -3,14 +3,13 @@ use std::collections::HashSet;
 use async_trait::async_trait;
 use tracing::info;
 
-use crate::domain::{
-    handler::{
-        BackendHandler, GroupBackendHandler, GroupListerBackendHandler, GroupRequestFilter,
-        ReadSchemaBackendHandler, SchemaBackendHandler, UserBackendHandler,
-        UserListerBackendHandler, UserRequestFilter,
-    },
-    schema::PublicSchema,
+use lldap_domain_handlers::handler::{
+    BackendHandler, GroupBackendHandler, GroupListerBackendHandler, GroupRequestFilter,
+    ReadSchemaBackendHandler, SchemaBackendHandler, UserBackendHandler, UserListerBackendHandler,
+    UserRequestFilter,
 };
+
+use crate::domain::schema::PublicSchema;
 use lldap_domain::{
     requests::{
         CreateAttributeRequest, CreateGroupRequest, CreateUserRequest, UpdateGroupRequest,

server/src/infra/auth_service.rs

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

server/src/infra/graphql/api.rs

@@ -1,15 +1,12 @@
-use crate::{
-    domain::handler::BackendHandler,
-    infra::{
-        access_control::{
-            AccessControlledBackendHandler, AdminBackendHandler, ReadonlyBackendHandler,
-            UserReadableBackendHandler, UserWriteableBackendHandler, ValidationResults,
-        },
-        auth_service::check_if_token_is_valid,
-        cli::ExportGraphQLSchemaOpts,
-        graphql::{mutation::Mutation, query::Query},
-        tcp_server::AppState,
+use crate::infra::{
+    access_control::{
+        AccessControlledBackendHandler, AdminBackendHandler, ReadonlyBackendHandler,
+        UserReadableBackendHandler, UserWriteableBackendHandler, ValidationResults,
     },
+    auth_service::check_if_token_is_valid,
+    cli::ExportGraphQLSchemaOpts,
+    graphql::{mutation::Mutation, query::Query},
+    tcp_server::AppState,
 };
 
 use actix_web::FromRequest;
@@ -24,6 +21,7 @@ use juniper::{
     EmptySubscription, FieldError, RootNode, ScalarValue,
 };
 use lldap_domain::types::UserId;
+use lldap_domain_handlers::handler::BackendHandler;
 use tracing::debug;
 
 pub struct Context<Handler: BackendHandler> {

server/src/infra/graphql/mutation.rs

@@ -1,9 +1,7 @@
 use std::{collections::BTreeMap, sync::Arc};
 
 use crate::{
-    domain::{
-        deserialize::deserialize_attribute_value, handler::BackendHandler, schema::PublicSchema,
-    },
+    domain::{deserialize::deserialize_attribute_value, schema::PublicSchema},
     infra::{
         access_control::{
             AdminBackendHandler, ReadonlyBackendHandler, UserReadableBackendHandler,
@@ -25,6 +23,7 @@ use lldap_domain::{
         LdapObjectClass, UserId,
     },
 };
+use lldap_domain_handlers::handler::BackendHandler;
 use lldap_validation::attributes::{validate_attribute_name, ALLOWED_CHARACTERS_DESCRIPTION};
 use tracing::{debug, debug_span, Instrument, Span};
 

server/src/infra/graphql/query.rs

@@ -3,7 +3,6 @@ use std::sync::Arc;
 use crate::{
     domain::{
         deserialize::deserialize_attribute_value,
-        handler::{BackendHandler, ReadSchemaBackendHandler},
         ldap::utils::{map_user_field, UserFieldType},
         schema::PublicSchema,
     },
@@ -18,11 +17,12 @@ use juniper::{graphql_object, FieldResult, GraphQLInputObject};
 use lldap_domain::types::{
     AttributeType, Cardinality, GroupDetails, GroupId, LdapObjectClass, UserId,
 };
+use lldap_domain_handlers::handler::{BackendHandler, ReadSchemaBackendHandler};
 use lldap_domain_model::model::UserColumn;
 use serde::{Deserialize, Serialize};
 use tracing::{debug, debug_span, Instrument, Span};
 
-type DomainRequestFilter = crate::domain::handler::UserRequestFilter;
+type DomainRequestFilter = lldap_domain_handlers::handler::UserRequestFilter;
 type DomainUser = lldap_domain::types::User;
 type DomainGroup = lldap_domain::types::Group;
 type DomainUserAndGroups = lldap_domain::types::UserAndGroups;

server/src/infra/ldap_handler.rs

@@ -1,7 +1,6 @@
 use crate::{
     domain::{
         deserialize,
-        handler::{BackendHandler, BindRequest, LoginHandler, ReadSchemaBackendHandler},
         ldap::{
             error::{LdapError, LdapResult},
             group::{convert_groups_to_ldap_op, get_groups_list},
@@ -30,6 +29,9 @@ use lldap_domain::{
     requests::CreateUserRequest,
     types::{Attribute, AttributeName, AttributeType, Email, Group, UserAndGroups, UserId},
 };
+use lldap_domain_handlers::handler::{
+    BackendHandler, BindRequest, LoginHandler, ReadSchemaBackendHandler,
+};
 use std::collections::HashMap;
 use tracing::{debug, instrument, warn};
 
@@ -924,10 +926,7 @@ impl<Backend: BackendHandler + LoginHandler + OpaqueHandler> LdapHandler<Backend
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{
-        domain::handler::*,
-        infra::test_utils::{setup_default_schema, MockTestBackendHandler},
-    };
+    use crate::infra::test_utils::{setup_default_schema, MockTestBackendHandler};
     use chrono::TimeZone;
     use ldap3_proto::proto::{
         LdapDerefAliases, LdapSearchScope, LdapSubstringFilter, LdapWhoamiRequest,
@@ -937,6 +936,7 @@ mod tests {
         types::*,
         uuid,
     };
+    use lldap_domain_handlers::handler::*;
     use lldap_domain_model::model::UserColumn;
     use mockall::predicate::eq;
     use pretty_assertions::assert_eq;
@@ -1016,7 +1016,7 @@ mod tests {
     async fn test_bind() {
         let mut mock = MockTestBackendHandler::new();
         mock.expect_bind()
-            .with(eq(crate::domain::handler::BindRequest {
+            .with(eq(lldap_domain_handlers::handler::BindRequest {
                 name: UserId::new("bob"),
                 password: "pass".to_string(),
             }))
@@ -1049,7 +1049,7 @@ mod tests {
     async fn test_admin_bind() {
         let mut mock = MockTestBackendHandler::new();
         mock.expect_bind()
-            .with(eq(crate::domain::handler::BindRequest {
+            .with(eq(lldap_domain_handlers::handler::BindRequest {
                 name: UserId::new("test"),
                 password: "pass".to_string(),
             }))

server/src/infra/ldap_server.rs

@@ -1,8 +1,5 @@
 use crate::{
-    domain::{
-        handler::{BackendHandler, LoginHandler},
-        opaque_handler::OpaqueHandler,
-    },
+    domain::opaque_handler::OpaqueHandler,
     infra::{
         access_control::AccessControlledBackendHandler,
         configuration::{Configuration, LdapsOptions},
@@ -15,6 +12,7 @@ use actix_service::{fn_service, ServiceFactoryExt};
 use anyhow::{anyhow, Context, Result};
 use ldap3_proto::{control::LdapControl, proto::LdapMsg, proto::LdapOp, LdapCodec};
 use lldap_domain::types::AttributeName;
+use lldap_domain_handlers::handler::{BackendHandler, LoginHandler};
 use rustls::PrivateKey;
 use tokio_rustls::TlsAcceptor as RustlsTlsAcceptor;
 use tokio_util::codec::{FramedRead, FramedWrite};

server/src/infra/tcp_server.rs

@@ -1,8 +1,5 @@
 use crate::{
-    domain::{
-        handler::{BackendHandler, LoginHandler},
-        opaque_handler::OpaqueHandler,
-    },
+    domain::opaque_handler::OpaqueHandler,
     infra::{
         access_control::{AccessControlledBackendHandler, ReadonlyBackendHandler},
         auth_service,
@@ -18,6 +15,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_handlers::handler::{BackendHandler, LoginHandler};
 use lldap_domain_model::error::DomainError;
 use sha2::Sha512;
 use std::collections::HashSet;

server/src/infra/test_utils.rs

@@ -1,4 +1,4 @@
-use crate::domain::{handler::*, opaque_handler::*};
+use crate::domain::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_handlers::handler::*;
 use lldap_domain_model::error::Result;
 
 use async_trait::async_trait;

server/src/main.rs

@@ -7,10 +7,6 @@ use std::time::Duration;
 
 use crate::{
     domain::{
-        handler::{
-            GroupBackendHandler, GroupListerBackendHandler, GroupRequestFilter, UserBackendHandler,
-            UserListerBackendHandler, UserRequestFilter,
-        },
         sql_backend_handler::SqlBackendHandler,
         sql_opaque_handler::register_password,
         sql_tables::{get_private_key_info, set_private_key_info},
@@ -31,6 +27,10 @@ use sea_orm::{Database, DatabaseConnection};
 use tracing::{debug, error, info, instrument, span, warn, Instrument, Level};
 
 use lldap_domain::requests::{CreateGroupRequest, CreateUserRequest};
+use lldap_domain_handlers::handler::{
+    GroupBackendHandler, GroupListerBackendHandler, GroupRequestFilter, UserBackendHandler,
+    UserListerBackendHandler, UserRequestFilter,
+};
 
 mod domain;
 mod infra;