major update

lib/App/Container/ContainerRegistrar.php

@@ -0,0 +1,10 @@
+<?php
+
+namespace MintyPHP\App\Container;
+
+use MintyPHP\App\AppContainer;
+
+interface ContainerRegistrar
+{
+    public function register(AppContainer $container): void;
+}

lib/App/Container/Registrars/AccessRegistrar.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace MintyPHP\App\Container\Registrars;
+
+use MintyPHP\App\AppContainer;
+use MintyPHP\App\Container\ContainerRegistrar;
+use MintyPHP\Repository\Access\PermissionRepository;
+use MintyPHP\Repository\Access\RolePermissionRepository;
+use MintyPHP\Repository\Access\RoleRepository;
+use MintyPHP\Service\Access\AccessServicesFactory;
+use MintyPHP\Service\Access\AuthorizationService;
+use MintyPHP\Service\Access\PermissionGateway;
+use MintyPHP\Service\Access\PermissionService;
+use MintyPHP\Service\Access\RoleService;
+use MintyPHP\Service\Access\UiAccessService;
+use MintyPHP\Service\Directory\DirectoryServicesFactory;
+
+final class AccessRegistrar implements ContainerRegistrar
+{
+    public function register(AppContainer $container): void
+    {
+        $container->set(PermissionGateway::class, static fn (AppContainer $c): PermissionGateway => $c->get(AccessServicesFactory::class)->createPermissionGateway());
+        $container->set(AuthorizationService::class, static fn (AppContainer $c): AuthorizationService => $c->get(AccessServicesFactory::class)->createAuthorizationService());
+        $container->set(UiAccessService::class, static fn (AppContainer $c): UiAccessService => new UiAccessService(
+            $c->get(AuthorizationService::class)
+        ));
+        $container->set(PermissionService::class, static fn (AppContainer $c): PermissionService => $c->get(AccessServicesFactory::class)->createPermissionService());
+        $container->set(RoleService::class, static fn (AppContainer $c): RoleService => $c->get(DirectoryServicesFactory::class)->createRoleService());
+        $container->set(PermissionRepository::class, static fn (AppContainer $c): PermissionRepository => $c->get(AccessServicesFactory::class)->createPermissionRepository());
+        $container->set(RolePermissionRepository::class, static fn (AppContainer $c): RolePermissionRepository => $c->get(AccessServicesFactory::class)->createRolePermissionRepository());
+        $container->set(RoleRepository::class, static fn (AppContainer $c): RoleRepository => $c->get(DirectoryServicesFactory::class)->createRoleRepository());
+    }
+}

lib/App/Container/Registrars/AppServicesRegistrar.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace MintyPHP\App\Container\Registrars;
+
+use MintyPHP\App\AppContainer;
+use MintyPHP\App\Container\ContainerRegistrar;
+use MintyPHP\Http\ApiSystemAuditReporter;
+use MintyPHP\Http\Input\RequestInputFactory;
+use MintyPHP\Repository\Search\SearchQueryRepository;
+use MintyPHP\Repository\Stats\AdminStatsRepository;
+use MintyPHP\Repository\Tenant\UserTenantRepository;
+use MintyPHP\Service\Access\PermissionGateway;
+use MintyPHP\Service\AddressBook\AddressBookService;
+use MintyPHP\Service\AddressBook\AddressBookServicesFactory;
+use MintyPHP\Service\Audit\ApiAuditService;
+use MintyPHP\Service\Audit\AuditServicesFactory;
+use MintyPHP\Service\Audit\ImportAuditService;
+use MintyPHP\Service\Audit\SystemAuditService;
+use MintyPHP\Service\Audit\UserLifecycleAuditService;
+use MintyPHP\Service\CustomField\CustomFieldServicesFactory;
+use MintyPHP\Service\CustomField\TenantCustomFieldService;
+use MintyPHP\Service\CustomField\UserCustomFieldValueService;
+use MintyPHP\Service\Import\ImportService;
+use MintyPHP\Service\Import\ImportServicesFactory;
+use MintyPHP\Service\Mail\MailLogService;
+use MintyPHP\Service\Mail\MailService;
+use MintyPHP\Service\Mail\MailServicesFactory;
+use MintyPHP\Service\Scheduler\ScheduledJobService;
+use MintyPHP\Service\Scheduler\SchedulerRunService;
+use MintyPHP\Service\Scheduler\SchedulerServicesFactory;
+use MintyPHP\Service\Search\SearchDataService;
+use MintyPHP\Service\Security\RateLimiterService;
+use MintyPHP\Service\Security\SecurityServicesFactory;
+use MintyPHP\Service\Stats\AdminStatsViewDataService;
+
+final class AppServicesRegistrar implements ContainerRegistrar
+{
+    public function register(AppContainer $container): void
+    {
+        $container->set(AdminStatsViewDataService::class, static fn (AppContainer $c): AdminStatsViewDataService => new AdminStatsViewDataService(
+            $c->get(AdminStatsRepository::class)
+        ));
+        $container->set(SearchDataService::class, static fn (AppContainer $c): SearchDataService => new SearchDataService(
+            $c->get(PermissionGateway::class),
+            $c->get(UserTenantRepository::class),
+            $c->get(SearchQueryRepository::class)
+        ));
+        $container->set(RateLimiterService::class, static fn (AppContainer $c): RateLimiterService => $c->get(SecurityServicesFactory::class)->createRateLimiterService());
+        $container->set(MailService::class, static fn (AppContainer $c): MailService => $c->get(MailServicesFactory::class)->createMailService());
+        $container->set(MailLogService::class, static fn (AppContainer $c): MailLogService => $c->get(MailServicesFactory::class)->createMailLogService());
+        $container->set(ApiAuditService::class, static fn (AppContainer $c): ApiAuditService => $c->get(AuditServicesFactory::class)->createApiAuditService());
+        $container->set(UserLifecycleAuditService::class, static fn (AppContainer $c): UserLifecycleAuditService => $c->get(AuditServicesFactory::class)->createUserLifecycleAuditService());
+        $container->set(SystemAuditService::class, static fn (AppContainer $c): SystemAuditService => $c->get(AuditServicesFactory::class)->createSystemAuditService());
+        $container->set(ApiSystemAuditReporter::class, static fn (AppContainer $c): ApiSystemAuditReporter => new ApiSystemAuditReporter(
+            $c->get(SystemAuditService::class)
+        ));
+        $container->set(ImportService::class, static fn (AppContainer $c): ImportService => $c->get(ImportServicesFactory::class)->createImportService());
+        $container->set(ImportAuditService::class, static fn (AppContainer $c): ImportAuditService => $c->get(ImportServicesFactory::class)->createImportAuditService());
+        $container->set(ScheduledJobService::class, static fn (AppContainer $c): ScheduledJobService => $c->get(SchedulerServicesFactory::class)->createScheduledJobService());
+        $container->set(SchedulerRunService::class, static fn (AppContainer $c): SchedulerRunService => $c->get(SchedulerServicesFactory::class)->createSchedulerRunService());
+        $container->set(AddressBookService::class, static fn (AppContainer $c): AddressBookService => $c->get(AddressBookServicesFactory::class)->createAddressBookService());
+        $container->set(TenantCustomFieldService::class, static fn (AppContainer $c): TenantCustomFieldService => $c->get(CustomFieldServicesFactory::class)->createTenantCustomFieldService());
+        $container->set(UserCustomFieldValueService::class, static fn (AppContainer $c): UserCustomFieldValueService => $c->get(CustomFieldServicesFactory::class)->createUserCustomFieldValueService());
+        $container->set(RequestInputFactory::class, static fn (): RequestInputFactory => new RequestInputFactory());
+    }
+}

lib/App/Container/Registrars/AuthRegistrar.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace MintyPHP\App\Container\Registrars;
+
+use MintyPHP\App\AppContainer;
+use MintyPHP\App\Container\ContainerRegistrar;
+use MintyPHP\Repository\Auth\ApiTokenRepository;
+use MintyPHP\Repository\Auth\PasswordResetRepository;
+use MintyPHP\Repository\Auth\RememberTokenRepository;
+use MintyPHP\Repository\Tenant\TenantMicrosoftAuthRepository;
+use MintyPHP\Repository\Tenant\TenantRepository;
+use MintyPHP\Service\Auth\ApiTokenEndpointService;
+use MintyPHP\Service\Auth\ApiTokenService;
+use MintyPHP\Service\Auth\AuthRepositoryFactory;
+use MintyPHP\Service\Auth\AuthScopeGateway;
+use MintyPHP\Service\Auth\AuthService;
+use MintyPHP\Service\Auth\AuthServicesFactory;
+use MintyPHP\Service\Auth\EmailVerificationService;
+use MintyPHP\Service\Auth\MicrosoftOidcService;
+use MintyPHP\Service\Auth\PasswordResetService;
+use MintyPHP\Service\Auth\RememberMeService;
+use MintyPHP\Service\Auth\SsoUserLinkService;
+use MintyPHP\Service\Auth\TenantSsoService;
+
+final class AuthRegistrar implements ContainerRegistrar
+{
+    public function register(AppContainer $container): void
+    {
+        $container->set(AuthService::class, static fn (AppContainer $c): AuthService => $c->get(AuthServicesFactory::class)->createAuthService());
+        $container->set(RememberMeService::class, static fn (AppContainer $c): RememberMeService => $c->get(AuthServicesFactory::class)->createRememberMeService());
+        $container->set(ApiTokenService::class, static fn (AppContainer $c): ApiTokenService => $c->get(AuthServicesFactory::class)->createApiTokenService());
+        $container->set(ApiTokenEndpointService::class, static fn (AppContainer $c): ApiTokenEndpointService => new ApiTokenEndpointService(
+            $c->get(AuthRepositoryFactory::class)->createApiTokenRepository(),
+            $c->get(TenantRepository::class),
+            $c->get(AuthScopeGateway::class)
+        ));
+        $container->set(PasswordResetService::class, static fn (AppContainer $c): PasswordResetService => $c->get(AuthServicesFactory::class)->createPasswordResetService());
+        $container->set(EmailVerificationService::class, static fn (AppContainer $c): EmailVerificationService => $c->get(AuthServicesFactory::class)->createEmailVerificationService());
+        $container->set(TenantSsoService::class, static fn (AppContainer $c): TenantSsoService => $c->get(AuthServicesFactory::class)->createTenantSsoService());
+        $container->set(MicrosoftOidcService::class, static fn (AppContainer $c): MicrosoftOidcService => $c->get(AuthServicesFactory::class)->createMicrosoftOidcService());
+        $container->set(SsoUserLinkService::class, static fn (AppContainer $c): SsoUserLinkService => $c->get(AuthServicesFactory::class)->createSsoUserLinkService());
+        $container->set(AuthScopeGateway::class, static fn (AppContainer $c): AuthScopeGateway => $c->get(AuthServicesFactory::class)->createAuthScopeGateway());
+        $container->set(TenantMicrosoftAuthRepository::class, static fn (AppContainer $c): TenantMicrosoftAuthRepository => $c->get(AuthRepositoryFactory::class)->createTenantMicrosoftAuthRepository());
+        $container->set(ApiTokenRepository::class, static fn (AppContainer $c): ApiTokenRepository => $c->get(AuthRepositoryFactory::class)->createApiTokenRepository());
+        $container->set(RememberTokenRepository::class, static fn (AppContainer $c): RememberTokenRepository => $c->get(AuthRepositoryFactory::class)->createRememberTokenRepository());
+        $container->set(PasswordResetRepository::class, static fn (AppContainer $c): PasswordResetRepository => $c->get(AuthRepositoryFactory::class)->createPasswordResetRepository());
+    }
+}

lib/App/Container/Registrars/DirectoryRegistrar.php

@@ -0,0 +1,33 @@
+<?php
+
+namespace MintyPHP\App\Container\Registrars;
+
+use MintyPHP\App\AppContainer;
+use MintyPHP\App\Container\ContainerRegistrar;
+use MintyPHP\Repository\Org\DepartmentRepository;
+use MintyPHP\Repository\Tenant\TenantRepository;
+use MintyPHP\Service\Directory\DirectoryScopeGateway;
+use MintyPHP\Service\Directory\DirectoryServicesFactory;
+use MintyPHP\Service\Directory\DirectorySettingsGateway;
+use MintyPHP\Service\Org\DepartmentService;
+use MintyPHP\Service\Tenant\TenantAvatarService;
+use MintyPHP\Service\Tenant\TenantFaviconService;
+use MintyPHP\Service\Tenant\TenantScopeService;
+use MintyPHP\Service\Tenant\TenantService;
+use MintyPHP\Service\Tenant\TenantServicesFactory;
+
+final class DirectoryRegistrar implements ContainerRegistrar
+{
+    public function register(AppContainer $container): void
+    {
+        $container->set(TenantService::class, static fn (AppContainer $c): TenantService => $c->get(DirectoryServicesFactory::class)->createTenantService());
+        $container->set(TenantScopeService::class, static fn (AppContainer $c): TenantScopeService => $c->get(TenantServicesFactory::class)->createTenantScopeService());
+        $container->set(DepartmentService::class, static fn (AppContainer $c): DepartmentService => $c->get(DirectoryServicesFactory::class)->createDepartmentService());
+        $container->set(DirectoryScopeGateway::class, static fn (AppContainer $c): DirectoryScopeGateway => $c->get(DirectoryServicesFactory::class)->createDirectoryScopeGateway());
+        $container->set(DirectorySettingsGateway::class, static fn (AppContainer $c): DirectorySettingsGateway => $c->get(DirectoryServicesFactory::class)->createDirectorySettingsGateway());
+        $container->set(TenantAvatarService::class, static fn (AppContainer $c): TenantAvatarService => $c->get(TenantServicesFactory::class)->createTenantAvatarService());
+        $container->set(TenantFaviconService::class, static fn (AppContainer $c): TenantFaviconService => $c->get(TenantServicesFactory::class)->createTenantFaviconService());
+        $container->set(TenantRepository::class, static fn (AppContainer $c): TenantRepository => $c->get(TenantServicesFactory::class)->createTenantRepository());
+        $container->set(DepartmentRepository::class, static fn (AppContainer $c): DepartmentRepository => $c->get(DirectoryServicesFactory::class)->createDepartmentRepository());
+    }
+}

lib/App/Container/Registrars/RepositoryFactoryRegistrar.php

@@ -0,0 +1,41 @@
+<?php
+
+namespace MintyPHP\App\Container\Registrars;
+
+use MintyPHP\App\AppContainer;
+use MintyPHP\App\Container\ContainerRegistrar;
+use MintyPHP\Repository\Search\SearchQueryRepository;
+use MintyPHP\Repository\Stats\AdminStatsRepository;
+use MintyPHP\Repository\Support\DatabaseSessionRepository;
+use MintyPHP\Service\Access\AccessRepositoryFactory;
+use MintyPHP\Service\Audit\AuditRepositoryFactory;
+use MintyPHP\Service\Auth\AuthRepositoryFactory;
+use MintyPHP\Service\Directory\DirectoryRepositoryFactory;
+use MintyPHP\Service\Import\ImportRepositoryFactory;
+use MintyPHP\Service\Mail\MailRepositoryFactory;
+use MintyPHP\Service\Scheduler\SchedulerRepositoryFactory;
+use MintyPHP\Service\Security\SecurityRepositoryFactory;
+use MintyPHP\Service\Settings\SettingRepositoryFactory;
+use MintyPHP\Service\Tenant\TenantRepositoryFactory;
+use MintyPHP\Service\User\UserRepositoryFactory;
+
+final class RepositoryFactoryRegistrar implements ContainerRegistrar
+{
+    public function register(AppContainer $container): void
+    {
+        $container->set(SettingRepositoryFactory::class, static fn (): SettingRepositoryFactory => new SettingRepositoryFactory());
+        $container->set(AuditRepositoryFactory::class, static fn (): AuditRepositoryFactory => new AuditRepositoryFactory());
+        $container->set(SecurityRepositoryFactory::class, static fn (): SecurityRepositoryFactory => new SecurityRepositoryFactory());
+        $container->set(MailRepositoryFactory::class, static fn (): MailRepositoryFactory => new MailRepositoryFactory());
+        $container->set(ImportRepositoryFactory::class, static fn (): ImportRepositoryFactory => new ImportRepositoryFactory());
+        $container->set(SchedulerRepositoryFactory::class, static fn (): SchedulerRepositoryFactory => new SchedulerRepositoryFactory());
+        $container->set(TenantRepositoryFactory::class, static fn (): TenantRepositoryFactory => new TenantRepositoryFactory());
+        $container->set(DirectoryRepositoryFactory::class, static fn (): DirectoryRepositoryFactory => new DirectoryRepositoryFactory());
+        $container->set(AccessRepositoryFactory::class, static fn (): AccessRepositoryFactory => new AccessRepositoryFactory());
+        $container->set(UserRepositoryFactory::class, static fn (): UserRepositoryFactory => new UserRepositoryFactory());
+        $container->set(AuthRepositoryFactory::class, static fn (): AuthRepositoryFactory => new AuthRepositoryFactory());
+        $container->set(AdminStatsRepository::class, static fn (): AdminStatsRepository => new AdminStatsRepository());
+        $container->set(SearchQueryRepository::class, static fn (): SearchQueryRepository => new SearchQueryRepository());
+        $container->set(DatabaseSessionRepository::class, static fn (): DatabaseSessionRepository => new DatabaseSessionRepository());
+    }
+}

lib/App/Container/Registrars/ServiceFactoryRegistrar.php

@@ -0,0 +1,144 @@
+<?php
+
+namespace MintyPHP\App\Container\Registrars;
+
+use MintyPHP\App\AppContainer;
+use MintyPHP\App\Container\ContainerRegistrar;
+use MintyPHP\Repository\Support\DatabaseSessionRepository;
+use MintyPHP\Repository\Tenant\TenantRepository;
+use MintyPHP\Service\Access\AccessGatewayFactory;
+use MintyPHP\Service\Access\AccessPolicyFactory;
+use MintyPHP\Service\Access\AccessRepositoryFactory;
+use MintyPHP\Service\Access\AccessServicesFactory;
+use MintyPHP\Service\Access\PermissionGateway;
+use MintyPHP\Service\Directory\DirectoryScopeGateway;
+use MintyPHP\Service\AddressBook\AddressBookServicesFactory;
+use MintyPHP\Service\Audit\AuditRepositoryFactory;
+use MintyPHP\Service\Audit\AuditServicesFactory;
+use MintyPHP\Service\Auth\AuthGatewayFactory;
+use MintyPHP\Service\Auth\AuthRepositoryFactory;
+use MintyPHP\Service\Auth\AuthServicesFactory;
+use MintyPHP\Service\Branding\BrandingServicesFactory;
+use MintyPHP\Service\CustomField\CustomFieldServicesFactory;
+use MintyPHP\Service\Directory\DirectoryGatewayFactory;
+use MintyPHP\Service\Directory\DirectoryRepositoryFactory;
+use MintyPHP\Service\Directory\DirectoryServicesFactory;
+use MintyPHP\Service\Import\ImportRepositoryFactory;
+use MintyPHP\Service\Import\ImportServicesFactory;
+use MintyPHP\Service\Mail\MailRepositoryFactory;
+use MintyPHP\Service\Mail\MailServicesFactory;
+use MintyPHP\Service\Scheduler\SchedulerRepositoryFactory;
+use MintyPHP\Service\Scheduler\SchedulerServicesFactory;
+use MintyPHP\Service\Security\SecurityRepositoryFactory;
+use MintyPHP\Service\Security\SecurityServicesFactory;
+use MintyPHP\Service\Settings\SettingGateway;
+use MintyPHP\Service\Settings\SettingRepositoryFactory;
+use MintyPHP\Service\Settings\SettingServicesFactory;
+use MintyPHP\Service\Tenant\TenantRepositoryFactory;
+use MintyPHP\Service\Tenant\TenantScopeService;
+use MintyPHP\Service\Tenant\TenantServicesFactory;
+use MintyPHP\Service\User\UserGatewayFactory;
+use MintyPHP\Service\User\UserRepositoryFactory;
+use MintyPHP\Service\User\UserScopeGateway;
+use MintyPHP\Service\User\UserServicesFactory;
+
+final class ServiceFactoryRegistrar implements ContainerRegistrar
+{
+    public function register(AppContainer $container): void
+    {
+        $container->set(SettingServicesFactory::class, static fn (AppContainer $c): SettingServicesFactory => new SettingServicesFactory(
+            $c->get(SettingRepositoryFactory::class)
+        ));
+        $container->set(AuditServicesFactory::class, static fn (AppContainer $c): AuditServicesFactory => new AuditServicesFactory(
+            $c->get(AuditRepositoryFactory::class),
+            $c->get(SettingGateway::class)
+        ));
+        $container->set(SecurityServicesFactory::class, static fn (AppContainer $c): SecurityServicesFactory => new SecurityServicesFactory(
+            $c->get(SecurityRepositoryFactory::class)
+        ));
+        $container->set(MailServicesFactory::class, static fn (AppContainer $c): MailServicesFactory => new MailServicesFactory(
+            $c->get(MailRepositoryFactory::class),
+            $c->get(SettingGateway::class)
+        ));
+        $container->set(BrandingServicesFactory::class, static fn (AppContainer $c): BrandingServicesFactory => new BrandingServicesFactory(
+            $c->get(SettingGateway::class)
+        ));
+        $container->set(CustomFieldServicesFactory::class, static fn (AppContainer $c): CustomFieldServicesFactory => new CustomFieldServicesFactory(
+            $c->get(TenantRepository::class),
+            $c->get(UserScopeGateway::class)
+        ));
+        $container->set(TenantServicesFactory::class, static fn (AppContainer $c): TenantServicesFactory => new TenantServicesFactory(
+            $c->get(PermissionGateway::class),
+            $c->get(TenantRepositoryFactory::class)
+        ));
+        $container->set(ImportServicesFactory::class, static fn (AppContainer $c): ImportServicesFactory => new ImportServicesFactory(
+            $c->get(UserServicesFactory::class),
+            $c->get(AccessServicesFactory::class),
+            $c->get(SettingServicesFactory::class),
+            $c->get(UserRepositoryFactory::class),
+            $c->get(DirectoryServicesFactory::class),
+            $c->get(ImportRepositoryFactory::class)
+        ));
+        $container->set(SchedulerServicesFactory::class, static fn (AppContainer $c): SchedulerServicesFactory => new SchedulerServicesFactory(
+            $c->get(UserServicesFactory::class),
+            $c->get(AuditServicesFactory::class),
+            $c->get(DatabaseSessionRepository::class),
+            $c->get(SchedulerRepositoryFactory::class)
+        ));
+        $container->set(AddressBookServicesFactory::class, static fn (AppContainer $c): AddressBookServicesFactory => new AddressBookServicesFactory(
+            $c->get(UserServicesFactory::class),
+            $c->get(DirectoryServicesFactory::class),
+            $c->get(CustomFieldServicesFactory::class)
+        ));
+        $container->set(DirectoryServicesFactory::class, static fn (AppContainer $c): DirectoryServicesFactory => new DirectoryServicesFactory(
+            $c->get(UserServicesFactory::class),
+            $c->get(AuditServicesFactory::class),
+            $c->get(DirectoryRepositoryFactory::class),
+            $c->get(DirectoryGatewayFactory::class)
+        ));
+        $container->set(DirectoryGatewayFactory::class, static fn (AppContainer $c): DirectoryGatewayFactory => new DirectoryGatewayFactory(
+            $c->get(SettingServicesFactory::class),
+            $c->get(TenantScopeService::class)
+        ));
+        $container->set(AccessServicesFactory::class, static fn (AppContainer $c): AccessServicesFactory => new AccessServicesFactory(
+            $c->get(AccessRepositoryFactory::class),
+            $c->get(AccessGatewayFactory::class),
+            static fn (): AccessPolicyFactory => $c->get(AccessPolicyFactory::class)
+        ));
+        $container->set(AccessGatewayFactory::class, static fn (AppContainer $c): AccessGatewayFactory => new AccessGatewayFactory(
+            $c->get(AccessRepositoryFactory::class),
+            $c->get(AuditServicesFactory::class)
+        ));
+        $container->set(AccessPolicyFactory::class, static fn (AppContainer $c): AccessPolicyFactory => new AccessPolicyFactory(
+            $c->get(PermissionGateway::class),
+            $c->get(DirectoryScopeGateway::class)
+        ));
+        $container->set(UserGatewayFactory::class, static fn (AppContainer $c): UserGatewayFactory => new UserGatewayFactory(
+            $c->get(UserRepositoryFactory::class),
+            $c->get(AccessServicesFactory::class),
+            $c->get(SettingServicesFactory::class),
+            $c->get(TenantScopeService::class)
+        ));
+        $container->set(UserServicesFactory::class, static fn (AppContainer $c): UserServicesFactory => new UserServicesFactory(
+            $c->get(AuditServicesFactory::class),
+            $c->get(UserRepositoryFactory::class),
+            $c->get(UserGatewayFactory::class),
+            $c->get(DatabaseSessionRepository::class)
+        ));
+        $container->set(AuthGatewayFactory::class, static fn (AppContainer $c): AuthGatewayFactory => new AuthGatewayFactory(
+            $c->get(AuthRepositoryFactory::class),
+            $c->get(AccessServicesFactory::class),
+            $c->get(UserServicesFactory::class),
+            $c->get(SettingServicesFactory::class),
+            $c->get(TenantScopeService::class)
+        ));
+        $container->set(AuthServicesFactory::class, static fn (AppContainer $c): AuthServicesFactory => new AuthServicesFactory(
+            $c->get(UserServicesFactory::class),
+            $c->get(AuditServicesFactory::class),
+            $c->get(MailServicesFactory::class),
+            $c->get(AuthRepositoryFactory::class),
+            $c->get(AuthGatewayFactory::class),
+            $c->get(DatabaseSessionRepository::class)
+        ));
+    }
+}

lib/App/Container/Registrars/SettingsRegistrar.php

@@ -0,0 +1,44 @@
+<?php
+
+namespace MintyPHP\App\Container\Registrars;
+
+use MintyPHP\App\AppContainer;
+use MintyPHP\App\Container\ContainerRegistrar;
+use MintyPHP\Repository\Auth\ApiTokenRepository;
+use MintyPHP\Repository\Auth\RememberTokenRepository;
+use MintyPHP\Service\Access\RoleService;
+use MintyPHP\Service\Branding\BrandingFaviconService;
+use MintyPHP\Service\Branding\BrandingLogoService;
+use MintyPHP\Service\Branding\BrandingServicesFactory;
+use MintyPHP\Service\Org\DepartmentService;
+use MintyPHP\Service\Settings\AdminSettingsService;
+use MintyPHP\Service\Settings\SettingCacheService;
+use MintyPHP\Service\Settings\SettingGateway;
+use MintyPHP\Service\Settings\SettingService;
+use MintyPHP\Service\Settings\SettingServicesFactory;
+use MintyPHP\Service\Settings\ThemeConfigService;
+use MintyPHP\Service\Tenant\TenantService;
+use MintyPHP\Service\Audit\SystemAuditService;
+
+final class SettingsRegistrar implements ContainerRegistrar
+{
+    public function register(AppContainer $container): void
+    {
+        $container->set(SettingService::class, static fn (AppContainer $c): SettingService => $c->get(SettingServicesFactory::class)->createSettingService());
+        $container->set(SettingGateway::class, static fn (AppContainer $c): SettingGateway => $c->get(SettingServicesFactory::class)->createSettingGateway());
+        $container->set(SettingCacheService::class, static fn (AppContainer $c): SettingCacheService => $c->get(SettingServicesFactory::class)->createSettingCacheService());
+        $container->set(AdminSettingsService::class, static fn (AppContainer $c): AdminSettingsService => new AdminSettingsService(
+            $c->get(SettingGateway::class),
+            $c->get(SettingCacheService::class),
+            $c->get(TenantService::class),
+            $c->get(RoleService::class),
+            $c->get(DepartmentService::class),
+            $c->get(RememberTokenRepository::class),
+            $c->get(ApiTokenRepository::class),
+            $c->get(SystemAuditService::class)
+        ));
+        $container->set(ThemeConfigService::class, static fn (AppContainer $c): ThemeConfigService => $c->get(SettingServicesFactory::class)->createThemeConfigService());
+        $container->set(BrandingLogoService::class, static fn (AppContainer $c): BrandingLogoService => $c->get(BrandingServicesFactory::class)->createBrandingLogoService());
+        $container->set(BrandingFaviconService::class, static fn (AppContainer $c): BrandingFaviconService => $c->get(BrandingServicesFactory::class)->createBrandingFaviconService());
+    }
+}

lib/App/Container/Registrars/UserRegistrar.php

@@ -0,0 +1,66 @@
+<?php
+
+namespace MintyPHP\App\Container\Registrars;
+
+use MintyPHP\App\AppContainer;
+use MintyPHP\App\Container\ContainerRegistrar;
+use MintyPHP\Repository\Access\UserRoleRepository;
+use MintyPHP\Repository\Org\UserDepartmentRepository;
+use MintyPHP\Repository\User\UserReadRepository;
+use MintyPHP\Repository\User\UserWriteRepository;
+use MintyPHP\Repository\Tenant\UserTenantRepository;
+use MintyPHP\Service\Auth\TenantSsoService;
+use MintyPHP\Service\Branding\BrandingLogoService;
+use MintyPHP\Service\User\UserAccessPdfService;
+use MintyPHP\Service\User\UserAccessTemplateService;
+use MintyPHP\Service\User\UserAccountService;
+use MintyPHP\Service\User\UserAssignmentService;
+use MintyPHP\Service\User\UserAvatarService;
+use MintyPHP\Service\User\UserDirectoryGateway;
+use MintyPHP\Service\User\UserLifecycleRestoreService;
+use MintyPHP\Service\User\UserLifecycleService;
+use MintyPHP\Service\User\UserPasswordPolicyService;
+use MintyPHP\Service\User\UserPasswordService;
+use MintyPHP\Service\User\UserApiWriteInputMapper;
+use MintyPHP\Service\User\UserRepositoryFactory;
+use MintyPHP\Service\User\UserSavedFilterService;
+use MintyPHP\Service\User\UserScopeGateway;
+use MintyPHP\Service\User\UserServicesFactory;
+use MintyPHP\Service\User\UserTenantContextService;
+
+final class UserRegistrar implements ContainerRegistrar
+{
+    public function register(AppContainer $container): void
+    {
+        $container->set(UserAccountService::class, static fn (AppContainer $c): UserAccountService => $c->get(UserServicesFactory::class)->createUserAccountService());
+        $container->set(UserAssignmentService::class, static fn (AppContainer $c): UserAssignmentService => $c->get(UserServicesFactory::class)->createUserAssignmentService());
+        $container->set(UserPasswordService::class, static fn (AppContainer $c): UserPasswordService => $c->get(UserServicesFactory::class)->createUserPasswordService());
+        $container->set(UserAvatarService::class, static fn (AppContainer $c): UserAvatarService => $c->get(UserServicesFactory::class)->createUserAvatarService());
+        $container->set(UserDirectoryGateway::class, static fn (AppContainer $c): UserDirectoryGateway => $c->get(UserServicesFactory::class)->createUserDirectoryGateway());
+        $container->set(UserScopeGateway::class, static fn (AppContainer $c): UserScopeGateway => $c->get(UserServicesFactory::class)->createUserScopeGateway());
+        $container->set(UserAccessTemplateService::class, static fn (AppContainer $c): UserAccessTemplateService => new UserAccessTemplateService(
+            $c->get(TenantSsoService::class),
+            $c->get(UserDirectoryGateway::class),
+            $c->get(UserTenantRepository::class)
+        ));
+        $container->set(UserAccessPdfService::class, static fn (AppContainer $c): UserAccessPdfService => new UserAccessPdfService(
+            $c->get(UserAccessTemplateService::class),
+            $c->get(BrandingLogoService::class)
+        ));
+        $container->set(UserSavedFilterService::class, static fn (AppContainer $c): UserSavedFilterService => $c->get(UserServicesFactory::class)->createUserSavedFilterService());
+        $container->set(UserTenantContextService::class, static fn (AppContainer $c): UserTenantContextService => $c->get(UserServicesFactory::class)->createUserTenantContextService());
+        $container->set(UserLifecycleService::class, static fn (AppContainer $c): UserLifecycleService => $c->get(UserServicesFactory::class)->createUserLifecycleService());
+        $container->set(UserPasswordPolicyService::class, static fn (AppContainer $c): UserPasswordPolicyService => $c->get(UserServicesFactory::class)->createUserPasswordPolicyService());
+        $container->set(UserLifecycleRestoreService::class, static fn (AppContainer $c): UserLifecycleRestoreService => $c->get(UserServicesFactory::class)->createUserLifecycleRestoreService());
+        $container->set(UserApiWriteInputMapper::class, static fn (AppContainer $c): UserApiWriteInputMapper => new UserApiWriteInputMapper(
+            $c->get(\MintyPHP\Service\Tenant\TenantService::class),
+            $c->get(\MintyPHP\Service\Access\RoleService::class),
+            $c->get(\MintyPHP\Service\Org\DepartmentService::class)
+        ));
+        $container->set(UserReadRepository::class, static fn (AppContainer $c): UserReadRepository => $c->get(UserRepositoryFactory::class)->createUserReadRepository());
+        $container->set(UserWriteRepository::class, static fn (AppContainer $c): UserWriteRepository => $c->get(UserRepositoryFactory::class)->createUserWriteRepository());
+        $container->set(UserTenantRepository::class, static fn (AppContainer $c): UserTenantRepository => $c->get(UserRepositoryFactory::class)->createUserTenantRepository());
+        $container->set(UserRoleRepository::class, static fn (AppContainer $c): UserRoleRepository => $c->get(UserRepositoryFactory::class)->createUserRoleRepository());
+        $container->set(UserDepartmentRepository::class, static fn (AppContainer $c): UserDepartmentRepository => $c->get(UserRepositoryFactory::class)->createUserDepartmentRepository());
+    }
+}