@authup/server-core 1.0.0-beta.5 → 1.0.0-beta.51

package/dist/app/modules/http/modules/controller.mjs

@@ -0,0 +1,579 @@
+import "node:path";
+import "node:url";
+import.meta.url;
+import { AuthenticationInjectionKey } from "../../authentication/constants.mjs";
+import { RealmEntity } from "../../../../adapters/database/domains/realm/entity.mjs";
+import { KeyEntity } from "../../../../adapters/database/domains/key/entity.mjs";
+import { ClientEntity } from "../../../../adapters/database/domains/client/entity.mjs";
+import { RoleEntity } from "../../../../adapters/database/domains/role/entity.mjs";
+import { RoleAttributeEntity } from "../../../../adapters/database/domains/role-attribute/entity.mjs";
+import { ClientRoleEntity } from "../../../../adapters/database/domains/client-role/entity.mjs";
+import { PermissionEntity } from "../../../../adapters/database/domains/permission/entity.mjs";
+import { PolicyRepository } from "../../../../adapters/database/domains/policy/repository.mjs";
+import { ClientPermissionEntity } from "../../../../adapters/database/domains/client-permission/entity.mjs";
+import { ScopeEntity } from "../../../../adapters/database/domains/scope/entity.mjs";
+import { ClientScopeEntity } from "../../../../adapters/database/domains/client-scope/entity.mjs";
+import { IdentityProviderRepository } from "../../../../adapters/database/domains/identity-provider/repository.mjs";
+import { UserEntity } from "../../../../adapters/database/domains/user/entity.mjs";
+import { UserAttributeEntity } from "../../../../adapters/database/domains/user-attribute/entity.mjs";
+import { UserRepository } from "../../../../adapters/database/domains/user/repository.mjs";
+import { IdentityProviderRoleMappingEntity } from "../../../../adapters/database/domains/identity-provider-role-mapping/entity.mjs";
+import { RobotEntity } from "../../../../adapters/database/domains/robot/entity.mjs";
+import { PermissionPolicyEntity } from "../../../../adapters/database/domains/permission-policy/entity.mjs";
+import { RobotPermissionEntity } from "../../../../adapters/database/domains/robot-permission/entity.mjs";
+import { RobotRoleEntity } from "../../../../adapters/database/domains/robot-role/entity.mjs";
+import { RolePermissionEntity } from "../../../../adapters/database/domains/role-permission/entity.mjs";
+import { UserPermissionEntity } from "../../../../adapters/database/domains/user-permission/entity.mjs";
+import { UserRoleEntity } from "../../../../adapters/database/domains/user-role/entity.mjs";
+import "../../../../adapters/database/domains/index.mjs";
+import { ClientAuthenticator } from "../../../../core/authentication/entities/client/module.mjs";
+import { RobotAuthenticator } from "../../../../core/authentication/entities/robot/module.mjs";
+import { UserAuthenticator } from "../../../../core/authentication/entities/user/module.mjs";
+import { CredentialsAuthenticator } from "../../../../core/authentication/module.mjs";
+import { ClientService } from "../../../../core/entities/client/service.mjs";
+import { WebClientProvisioner } from "../../../../core/entities/client/web-client.mjs";
+import { ClientPermissionService } from "../../../../core/entities/client-permission/service.mjs";
+import { ClientRoleService } from "../../../../core/entities/client-role/service.mjs";
+import { ClientScopeService } from "../../../../core/entities/client-scope/service.mjs";
+import { PermissionService } from "../../../../core/entities/permission/service.mjs";
+import { PermissionPolicyService } from "../../../../core/entities/permission-policy/service.mjs";
+import { PolicyService } from "../../../../core/entities/policy/service.mjs";
+import { RealmService } from "../../../../core/entities/realm/service.mjs";
+import { RobotService } from "../../../../core/entities/robot/service.mjs";
+import { RobotPermissionService } from "../../../../core/entities/robot-permission/service.mjs";
+import { RobotRoleService } from "../../../../core/entities/robot-role/service.mjs";
+import { RoleService } from "../../../../core/entities/role/service.mjs";
+import { RoleAttributeService } from "../../../../core/entities/role-attribute/service.mjs";
+import { RolePermissionService } from "../../../../core/entities/role-permission/service.mjs";
+import { ScopeService } from "../../../../core/entities/scope/service.mjs";
+import { UserService } from "../../../../core/entities/user/service.mjs";
+import { UserAttributeService } from "../../../../core/entities/user-attribute/service.mjs";
+import { UserPermissionService } from "../../../../core/entities/user-permission/service.mjs";
+import { UserRoleService } from "../../../../core/entities/user-role/service.mjs";
+import { IdentityProviderRoleMappingService } from "../../../../core/entities/identity-provider-role-mapping/service.mjs";
+import { OAuth2ClientAuthenticator } from "../../../../core/oauth2/client/authenticator.mjs";
+import { PasswordRecoveryService } from "../../../../core/identity/password-recovery/service.mjs";
+import { PermissionCheckerService } from "../../../../core/identity/permission/checker/service.mjs";
+import { PolicyCheckerService } from "../../../../core/identity/policy/checker/service.mjs";
+import { RegistrationService } from "../../../../core/identity/registration/service.mjs";
+import "../../../../core/index.mjs";
+import { ConfigInjectionKey } from "../../config/constants.mjs";
+import { getAppOrigins } from "../../config/origins.mjs";
+import "../../config/index.mjs";
+import "../../authentication/index.mjs";
+import { DatabaseInjectionKey } from "../../database/constants.mjs";
+import { LoggerInjectionKey } from "../../logger/constants.mjs";
+import "../../logger/index.mjs";
+import { RealmRepositoryAdapter } from "../../database/repositories/realm/repository.mjs";
+import { ClientRepositoryAdapter } from "../../database/repositories/client/repository.mjs";
+import { ClientPermissionRepositoryAdapter } from "../../database/repositories/client-permission/repository.mjs";
+import { ClientRoleRepositoryAdapter } from "../../database/repositories/client-role/repository.mjs";
+import { ClientScopeRepositoryAdapter } from "../../database/repositories/client-scope/repository.mjs";
+import { IdentityProviderRepositoryAdapter } from "../../database/repositories/identity-provider/repository.mjs";
+import { PermissionRepositoryAdapter } from "../../database/repositories/permission/repository.mjs";
+import { PermissionPolicyRepositoryAdapter } from "../../database/repositories/permission-policy/repository.mjs";
+import { PermissionDatabaseProvider } from "../../database/repositories/permission-provider/module.mjs";
+import { PolicyRepositoryAdapter } from "../../database/repositories/policy/repository.mjs";
+import { RobotRepositoryAdapter } from "../../database/repositories/robot/repository.mjs";
+import { RobotPermissionRepositoryAdapter } from "../../database/repositories/robot-permission/repository.mjs";
+import { RobotRoleRepositoryAdapter } from "../../database/repositories/robot-role/repository.mjs";
+import { RoleRepositoryAdapter } from "../../database/repositories/role/repository.mjs";
+import { RoleAttributeRepositoryAdapter } from "../../database/repositories/role-attribute/repository.mjs";
+import { RolePermissionRepositoryAdapter } from "../../database/repositories/role-permission/repository.mjs";
+import { ScopeRepositoryAdapter } from "../../database/repositories/scope/repository.mjs";
+import { UserRepositoryAdapter } from "../../database/repositories/user/repository.mjs";
+import { UserAttributeRepositoryAdapter } from "../../database/repositories/user-attribute/repository.mjs";
+import { UserPermissionRepositoryAdapter } from "../../database/repositories/user-permission/repository.mjs";
+import { UserRoleRepositoryAdapter } from "../../database/repositories/user-role/repository.mjs";
+import { IdentityProviderRoleMappingRepositoryAdapter } from "../../database/repositories/identity-provider-role-mapping/repository.mjs";
+import "../../database/index.mjs";
+import { ClientController } from "../../../../adapters/http/controllers/entities/client/module.mjs";
+import { ClientPermissionController } from "../../../../adapters/http/controllers/entities/client-permission/module.mjs";
+import { ClientRoleController } from "../../../../adapters/http/controllers/entities/client-role/module.mjs";
+import { ClientScopeController } from "../../../../adapters/http/controllers/entities/client-scope/module.mjs";
+import { IdentityProviderController } from "../../../../adapters/http/controllers/entities/identity-provider/module.mjs";
+import { IdentityProviderRoleMappingController } from "../../../../adapters/http/controllers/entities/identity-provide-role/module.mjs";
+import { PermissionController } from "../../../../adapters/http/controllers/entities/permission/module.mjs";
+import { PermissionPolicyController } from "../../../../adapters/http/controllers/entities/permission-policy/module.mjs";
+import { ActivateController } from "../../../../adapters/http/controllers/workflows/activate/module.mjs";
+import { AuthorizeController } from "../../../../adapters/http/controllers/workflows/authorize/module.mjs";
+import { JwkController } from "../../../../adapters/http/controllers/workflows/jwks/module.mjs";
+import { OpenIDController } from "../../../../adapters/http/controllers/workflows/openid/module.mjs";
+import { PasswordForgotController } from "../../../../adapters/http/controllers/workflows/password-forgot/module.mjs";
+import { PasswordResetController } from "../../../../adapters/http/controllers/workflows/password-reset/module.mjs";
+import { RegisterController } from "../../../../adapters/http/controllers/workflows/register/module.mjs";
+import { StatusController } from "../../../../adapters/http/controllers/workflows/status/module.mjs";
+import { TokenController } from "../../../../adapters/http/controllers/workflows/token/module.mjs";
+import { RealmController } from "../../../../adapters/http/controllers/entities/realm/module.mjs";
+import { RobotController } from "../../../../adapters/http/controllers/entities/robot/module.mjs";
+import { RobotPermissionController } from "../../../../adapters/http/controllers/entities/robot-permission/module.mjs";
+import { RobotRoleController } from "../../../../adapters/http/controllers/entities/robot-role/module.mjs";
+import { RoleController } from "../../../../adapters/http/controllers/entities/role/module.mjs";
+import { RoleAttributeController } from "../../../../adapters/http/controllers/entities/role-attribute/module.mjs";
+import { RolePermissionController } from "../../../../adapters/http/controllers/entities/role-permission/module.mjs";
+import { PolicyController } from "../../../../adapters/http/controllers/entities/policy/module.mjs";
+import { ScopeController } from "../../../../adapters/http/controllers/entities/scope/module.mjs";
+import { UserController } from "../../../../adapters/http/controllers/entities/user/module.mjs";
+import { UserAttributeController } from "../../../../adapters/http/controllers/entities/user-attribute/module.mjs";
+import { UserPermissionController } from "../../../../adapters/http/controllers/entities/user-permission/module.mjs";
+import { UserRoleController } from "../../../../adapters/http/controllers/entities/user-role/module.mjs";
+import "../../../../adapters/http/controllers/index.mjs";
+import "../../../../adapters/http/index.mjs";
+import { OAuth2InjectionToken } from "../../oauth2/constants.mjs";
+import { IdentityInjectionKey } from "../../identity/constants.mjs";
+import "../../identity/index.mjs";
+import "../../oauth2/index.mjs";
+import { MailInjectionKey, MailTemplateRendererInjectionKey } from "../../mail/constants.mjs";
+import "../../mail/index.mjs";
+import { decorators } from "@routup/decorators";
+//#region src/app/modules/http/modules/controller.ts
+var HTTPControllerModule = class {
+	async mount(router, container) {
+		const realmController = this.createRealmController(container);
+		const roleController = this.createRoleController(container);
+		const permissionController = await this.createPermissionController(container);
+		const permissionPolicyController = this.createPermissionPolicyController(container);
+		const clientController = this.createClientController(container);
+		const robotController = this.createRobotController(container);
+		const clientPermissionController = this.createClientPermissionController(container);
+		const clientRoleController = this.createClientRoleController(container);
+		const clientScopeController = this.createClientScopeController(container);
+		const robotPermissionController = this.createRobotPermissionController(container);
+		const robotRoleController = this.createRobotRoleController(container);
+		const roleAttributeController = this.createRoleAttributeController(container);
+		const rolePermissionController = this.createRolePermissionController(container);
+		const scopeController = this.createScopeController(container);
+		const userController = this.createUserController(container);
+		const userAttributeController = this.createUserAttributeController(container);
+		const userPermissionController = this.createUserPermissionController(container);
+		const userRoleController = this.createUserRoleController(container);
+		const policyController = this.createPolicyController(container);
+		const identityProviderRoleController = this.createIdentityProviderRoleController(container);
+		router.use(decorators({ controllers: [
+			this.createAuthorize(container),
+			this.createToken(container),
+			this.createJwkController(container),
+			this.createOpenIDController(container),
+			this.createActivateController(container),
+			this.createPasswordForgotController(container),
+			this.createPasswordResetController(container),
+			this.createRegisterController(container),
+			this.createStatusController(container),
+			clientController,
+			clientPermissionController,
+			clientRoleController,
+			clientScopeController,
+			identityProviderRoleController,
+			this.createIdentityProvider(container),
+			permissionController,
+			permissionPolicyController,
+			policyController,
+			robotController,
+			robotPermissionController,
+			robotRoleController,
+			realmController,
+			roleController,
+			roleAttributeController,
+			rolePermissionController,
+			scopeController,
+			userController,
+			userAttributeController,
+			userPermissionController,
+			userRoleController
+		] }));
+	}
+	createAuthorize(container) {
+		const config = container.resolve(ConfigInjectionKey);
+		const accessTokenIssuer = container.resolve(OAuth2InjectionToken.AccessTokenIssuer);
+		const openIdTokenIssuer = container.resolve(OAuth2InjectionToken.OpenIDTokenIssuer);
+		const codeIssuer = container.resolve(OAuth2InjectionToken.AuthorizationCodeIssuer);
+		const codeRequestVerifier = container.resolve(OAuth2InjectionToken.AuthorizationCodeRequestVerifier);
+		const identityResolver = container.resolve(IdentityInjectionKey.Resolver);
+		return new AuthorizeController({
+			options: {
+				baseURL: config.publicUrl,
+				features: this.buildUIFeatures(config)
+			},
+			accessTokenIssuer,
+			openIdTokenIssuer,
+			codeIssuer,
+			codeRequestVerifier,
+			identityResolver
+		});
+	}
+	createToken(container) {
+		const sessionManager = container.resolve(AuthenticationInjectionKey.SessionManager);
+		const codeVerifier = container.resolve(OAuth2InjectionToken.AuthorizationCodeVerifier);
+		const accessTokenIssuer = container.resolve(OAuth2InjectionToken.AccessTokenIssuer);
+		const refreshTokenIssuer = container.resolve(OAuth2InjectionToken.RefreshTokenIssuer);
+		const tokenRevoker = container.resolve(OAuth2InjectionToken.TokenRevoker);
+		const tokenVerifier = container.resolve(OAuth2InjectionToken.TokenVerifier);
+		const identityResolver = container.resolve(IdentityInjectionKey.Resolver);
+		const identityProviderLdapCollectionAuthenticator = container.resolve(IdentityInjectionKey.ProviderLdapCollectionAuthenticator);
+		return new TokenController({
+			codeVerifier,
+			accessTokenIssuer,
+			refreshTokenIssuer,
+			tokenVerifier,
+			tokenRevoker,
+			identityResolver,
+			identityPermissionProvider: container.resolve(IdentityInjectionKey.PermissionProvider),
+			clientAuthenticator: new ClientAuthenticator(identityResolver),
+			robotAuthenticator: new RobotAuthenticator(identityResolver),
+			userAuthenticator: new CredentialsAuthenticator([identityProviderLdapCollectionAuthenticator, new UserAuthenticator(identityResolver)]),
+			oauth2ClientAuthenticator: new OAuth2ClientAuthenticator(identityResolver),
+			realmRepository: new RealmRepositoryAdapter(container.resolve(RealmEntity)),
+			sessionManager
+		});
+	}
+	createOpenIDController(container) {
+		return new OpenIDController({ baseURL: container.resolve(ConfigInjectionKey).publicUrl });
+	}
+	createActivateController(container) {
+		const config = container.resolve(ConfigInjectionKey);
+		return new ActivateController({
+			options: {
+				baseURL: config.publicUrl,
+				features: this.buildUIFeatures(config)
+			},
+			service: this.createRegistrationService(container)
+		});
+	}
+	createPasswordForgotController(container) {
+		const config = container.resolve(ConfigInjectionKey);
+		return new PasswordForgotController({
+			options: {
+				baseURL: config.publicUrl,
+				features: this.buildUIFeatures(config)
+			},
+			service: this.createPasswordRecoveryService(container)
+		});
+	}
+	createPasswordResetController(container) {
+		const config = container.resolve(ConfigInjectionKey);
+		return new PasswordResetController({
+			options: {
+				baseURL: config.publicUrl,
+				features: this.buildUIFeatures(config)
+			},
+			service: this.createPasswordRecoveryService(container)
+		});
+	}
+	createPasswordRecoveryService(container) {
+		const config = container.resolve(ConfigInjectionKey);
+		const dataSource = container.resolve(DatabaseInjectionKey.DataSource);
+		const realmRepository = container.resolve(RealmEntity);
+		const repository = new UserRepositoryAdapter({
+			repository: new UserRepository(dataSource),
+			realmRepository
+		});
+		return new PasswordRecoveryService({
+			mailClient: container.resolve(MailInjectionKey),
+			mailTemplateRenderer: container.resolve(MailTemplateRendererInjectionKey),
+			repository,
+			realmRepository: new RealmRepositoryAdapter(realmRepository),
+			options: {
+				passwordRecoveryEnabled: config.passwordRecoveryEnabled,
+				emailVerificationEnabled: config.emailVerificationEnabled,
+				publicUrl: config.publicUrl
+			}
+		});
+	}
+	createRegisterController(container) {
+		const config = container.resolve(ConfigInjectionKey);
+		return new RegisterController({
+			options: {
+				baseURL: config.publicUrl,
+				features: this.buildUIFeatures(config)
+			},
+			service: this.createRegistrationService(container)
+		});
+	}
+	createStatusController(container) {
+		const config = container.resolve(ConfigInjectionKey);
+		return new StatusController({ options: { features: this.buildUIFeatures(config) } });
+	}
+	buildUIFeatures(config) {
+		return {
+			registration: config.registrationEnabled,
+			passwordRecovery: config.passwordRecoveryEnabled,
+			emailVerification: config.emailVerificationEnabled
+		};
+	}
+	createRegistrationService(container) {
+		const config = container.resolve(ConfigInjectionKey);
+		const dataSource = container.resolve(DatabaseInjectionKey.DataSource);
+		const realmRepository = container.resolve(RealmEntity);
+		const repository = new UserRepositoryAdapter({
+			repository: new UserRepository(dataSource),
+			realmRepository
+		});
+		return new RegistrationService({
+			mailClient: container.resolve(MailInjectionKey),
+			mailTemplateRenderer: container.resolve(MailTemplateRendererInjectionKey),
+			repository,
+			realmRepository: new RealmRepositoryAdapter(realmRepository),
+			options: {
+				registrationEnabled: config.registrationEnabled,
+				emailVerificationEnabled: config.emailVerificationEnabled,
+				publicUrl: config.publicUrl
+			}
+		});
+	}
+	createIdentityProvider(container) {
+		const config = container.resolve(ConfigInjectionKey);
+		const dataSource = container.resolve(DatabaseInjectionKey.DataSource);
+		const accountManager = container.resolve(IdentityInjectionKey.ProviderAccountManager);
+		const codeIssuer = container.resolve(OAuth2InjectionToken.AuthorizationCodeIssuer);
+		const codeRequestVerifier = container.resolve(OAuth2InjectionToken.AuthorizationCodeRequestVerifier);
+		const stateManager = container.resolve(OAuth2InjectionToken.AuthorizationStateManager);
+		const realmRepository = container.resolve(RealmEntity);
+		const repository = new IdentityProviderRepositoryAdapter({
+			repository: new IdentityProviderRepository(dataSource),
+			realmRepository
+		});
+		return new IdentityProviderController({
+			options: { baseURL: config.publicUrl },
+			repository,
+			realmRepository: new RealmRepositoryAdapter(realmRepository),
+			accountManager,
+			codeIssuer,
+			codeRequestVerifier,
+			stateManager
+		});
+	}
+	createClientController(container) {
+		const realmRepository = container.resolve(RealmEntity);
+		const repository = new ClientRepositoryAdapter({
+			repository: container.resolve(ClientEntity),
+			realmRepository
+		});
+		return new ClientController({
+			service: new ClientService({
+				repository,
+				realmRepository: new RealmRepositoryAdapter(realmRepository)
+			}),
+			repository
+		});
+	}
+	createRobotController(container) {
+		const dataSource = container.resolve(DatabaseInjectionKey.DataSource);
+		const realmRepository = container.resolve(RealmEntity);
+		const repository = new RobotRepositoryAdapter({
+			repository: container.resolve(RobotEntity),
+			realmRepository
+		});
+		const realmRepositoryAdapter = new RealmRepositoryAdapter(realmRepository);
+		return new RobotController({
+			service: new RobotService({
+				repository,
+				realmRepository: realmRepositoryAdapter
+			}),
+			repository,
+			realmRepository: realmRepositoryAdapter,
+			dataSource
+		});
+	}
+	createPermissionRepository(container) {
+		return new PermissionRepositoryAdapter({
+			repository: container.resolve(PermissionEntity),
+			realmRepository: container.resolve(RealmEntity)
+		});
+	}
+	createRoleRepository(container) {
+		return new RoleRepositoryAdapter({
+			repository: container.resolve(RoleEntity),
+			realmRepository: container.resolve(RealmEntity)
+		});
+	}
+	async createPermissionController(container) {
+		const dataSource = container.resolve(DatabaseInjectionKey.DataSource);
+		const realmRepository = container.resolve(RealmEntity);
+		const repository = new PermissionRepositoryAdapter({
+			repository: container.resolve(PermissionEntity),
+			realmRepository
+		});
+		const realmRepositoryAdapter = new RealmRepositoryAdapter(realmRepository);
+		const service = new PermissionService({
+			repository,
+			realmRepository: realmRepositoryAdapter,
+			roleRepository: new RoleRepositoryAdapter({
+				repository: container.resolve(RoleEntity),
+				realmRepository
+			}),
+			rolePermissionRepository: new RolePermissionRepositoryAdapter(container.resolve(RolePermissionEntity)),
+			policyRepository: new PolicyRepositoryAdapter({
+				repository: new PolicyRepository(dataSource),
+				realmRepository
+			}),
+			permissionPolicyRepository: new PermissionPolicyRepositoryAdapter(container.resolve(PermissionPolicyEntity))
+		});
+		const identityPermissionProvider = container.resolve(IdentityInjectionKey.PermissionProvider);
+		return new PermissionController({
+			service,
+			checkerService: new PermissionCheckerService({
+				repository,
+				realmRepository: realmRepositoryAdapter,
+				permissionProvider: new PermissionDatabaseProvider(dataSource),
+				identityPermissionProvider
+			})
+		});
+	}
+	createRoleController(container) {
+		const realmRepository = new RealmRepositoryAdapter(container.resolve(RealmEntity));
+		return new RoleController({ service: new RoleService({
+			repository: new RoleRepositoryAdapter({
+				repository: container.resolve(RoleEntity),
+				realmRepository: container.resolve(RealmEntity)
+			}),
+			realmRepository
+		}) });
+	}
+	createClientPermissionController(container) {
+		return new ClientPermissionController({ service: new ClientPermissionService({
+			repository: new ClientPermissionRepositoryAdapter(container.resolve(ClientPermissionEntity)),
+			permissionRepository: this.createPermissionRepository(container),
+			identityPermissionProvider: container.resolve(IdentityInjectionKey.PermissionProvider)
+		}) });
+	}
+	createClientRoleController(container) {
+		return new ClientRoleController({ service: new ClientRoleService({
+			repository: new ClientRoleRepositoryAdapter(container.resolve(ClientRoleEntity)),
+			identityPermissionProvider: container.resolve(IdentityInjectionKey.PermissionProvider)
+		}) });
+	}
+	createClientScopeController(container) {
+		return new ClientScopeController({ service: new ClientScopeService({ repository: new ClientScopeRepositoryAdapter(container.resolve(ClientScopeEntity)) }) });
+	}
+	createRobotPermissionController(container) {
+		return new RobotPermissionController({ service: new RobotPermissionService({
+			repository: new RobotPermissionRepositoryAdapter(container.resolve(RobotPermissionEntity)),
+			permissionRepository: this.createPermissionRepository(container),
+			identityPermissionProvider: container.resolve(IdentityInjectionKey.PermissionProvider)
+		}) });
+	}
+	createRobotRoleController(container) {
+		return new RobotRoleController({ service: new RobotRoleService({
+			repository: new RobotRoleRepositoryAdapter(container.resolve(RobotRoleEntity)),
+			identityPermissionProvider: container.resolve(IdentityInjectionKey.PermissionProvider)
+		}) });
+	}
+	createRoleAttributeController(container) {
+		const dataSource = container.resolve(DatabaseInjectionKey.DataSource);
+		return new RoleAttributeController({ service: new RoleAttributeService({
+			repository: new RoleAttributeRepositoryAdapter(container.resolve(RoleAttributeEntity)),
+			reservedNames: new Set(dataSource.getMetadata(RoleEntity).columns.map((c) => c.propertyName))
+		}) });
+	}
+	createRolePermissionController(container) {
+		return new RolePermissionController({ service: new RolePermissionService({
+			repository: new RolePermissionRepositoryAdapter(container.resolve(RolePermissionEntity)),
+			permissionRepository: this.createPermissionRepository(container),
+			identityPermissionProvider: container.resolve(IdentityInjectionKey.PermissionProvider)
+		}) });
+	}
+	createPermissionPolicyController(container) {
+		return new PermissionPolicyController({ service: new PermissionPolicyService({ repository: new PermissionPolicyRepositoryAdapter(container.resolve(PermissionPolicyEntity)) }) });
+	}
+	createScopeController(container) {
+		const realmRepository = new RealmRepositoryAdapter(container.resolve(RealmEntity));
+		return new ScopeController({ service: new ScopeService({
+			repository: new ScopeRepositoryAdapter({
+				repository: container.resolve(ScopeEntity),
+				realmRepository: container.resolve(RealmEntity)
+			}),
+			realmRepository
+		}) });
+	}
+	createUserController(container) {
+		const dataSource = container.resolve(DatabaseInjectionKey.DataSource);
+		const realmRepository = container.resolve(RealmEntity);
+		return new UserController({ service: new UserService({
+			repository: new UserRepositoryAdapter({
+				repository: new UserRepository(dataSource),
+				realmRepository
+			}),
+			realmRepository: new RealmRepositoryAdapter(realmRepository)
+		}) });
+	}
+	createUserAttributeController(container) {
+		const dataSource = container.resolve(DatabaseInjectionKey.DataSource);
+		return new UserAttributeController({ service: new UserAttributeService({
+			repository: new UserAttributeRepositoryAdapter(container.resolve(UserAttributeEntity)),
+			reservedNames: new Set(dataSource.getMetadata(UserEntity).columns.map((c) => c.propertyName))
+		}) });
+	}
+	createUserPermissionController(container) {
+		return new UserPermissionController({ service: new UserPermissionService({
+			repository: new UserPermissionRepositoryAdapter(container.resolve(UserPermissionEntity)),
+			permissionRepository: this.createPermissionRepository(container),
+			identityPermissionProvider: container.resolve(IdentityInjectionKey.PermissionProvider)
+		}) });
+	}
+	createUserRoleController(container) {
+		return new UserRoleController({ service: new UserRoleService({
+			repository: new UserRoleRepositoryAdapter(container.resolve(UserRoleEntity)),
+			identityPermissionProvider: container.resolve(IdentityInjectionKey.PermissionProvider)
+		}) });
+	}
+	createPolicyController(container) {
+		const dataSource = container.resolve(DatabaseInjectionKey.DataSource);
+		const realmRepository = container.resolve(RealmEntity);
+		const repository = new PolicyRepositoryAdapter({
+			repository: new PolicyRepository(dataSource),
+			realmRepository
+		});
+		const realmRepositoryAdapter = new RealmRepositoryAdapter(realmRepository);
+		return new PolicyController({
+			service: new PolicyService({
+				repository,
+				realmRepository: realmRepositoryAdapter
+			}),
+			checkerService: new PolicyCheckerService({
+				repository,
+				realmRepository: realmRepositoryAdapter,
+				identityPermissionProvider: container.resolve(IdentityInjectionKey.PermissionProvider)
+			})
+		});
+	}
+	createIdentityProviderRoleController(container) {
+		return new IdentityProviderRoleMappingController({ service: new IdentityProviderRoleMappingService({
+			repository: new IdentityProviderRoleMappingRepositoryAdapter(container.resolve(IdentityProviderRoleMappingEntity)),
+			roleRepository: this.createRoleRepository(container),
+			identityPermissionProvider: container.resolve(IdentityInjectionKey.PermissionProvider)
+		}) });
+	}
+	createJwkController(container) {
+		return new JwkController({ repository: container.resolve(DatabaseInjectionKey.DataSource).getRepository(KeyEntity) });
+	}
+	createRealmController(container) {
+		const config = container.resolve(ConfigInjectionKey);
+		const dataSource = container.resolve(DatabaseInjectionKey.DataSource);
+		const realmRepository = container.resolve(RealmEntity);
+		const repository = new RealmRepositoryAdapter(realmRepository);
+		const clientRepository = new ClientRepositoryAdapter({
+			repository: container.resolve(ClientEntity),
+			realmRepository
+		});
+		const logger = container.resolve(LoggerInjectionKey);
+		const service = new RealmService({
+			repository,
+			webClientProvisioner: new WebClientProvisioner({
+				clientRepository,
+				appOrigins: getAppOrigins(config),
+				logger
+			}),
+			logger
+		});
+		const keyRepository = dataSource.getRepository(KeyEntity);
+		return new RealmController({
+			options: { baseURL: config.publicUrl },
+			service,
+			keyRepository
+		});
+	}
+};
+//#endregion
+export { HTTPControllerModule };
+
+//# sourceMappingURL=controller.mjs.map