@authup/server-core 1.0.0-beta.4 → 1.0.0-beta.41

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

@@ -0,0 +1,104 @@
+import { AuthenticationInjectionKey } from "../../authentication/constants.mjs";
+import { ConfigInjectionKey } from "../../config/constants.mjs";
+import "../../config/index.mjs";
+import "../../authentication/index.mjs";
+import { DatabaseInjectionKey } from "../../database/constants.mjs";
+import { PermissionDatabaseProvider } from "../../database/repositories/permission-provider/module.mjs";
+import "../../database/index.mjs";
+import { createAuthorizationMiddleware } from "../../../../adapters/http/middleware/built-in/authorization/factory.mjs";
+import { DIST_PATH } from "../../../../path.mjs";
+import { registerAssetsMiddleware } from "../../../../adapters/http/middleware/built-in/assets.mjs";
+import { registerBasicMiddleware } from "../../../../adapters/http/middleware/built-in/basic.mjs";
+import { registerCorsMiddleware } from "../../../../adapters/http/middleware/built-in/cors.mjs";
+import { registerErrorMiddleware } from "../../../../adapters/http/middleware/built-in/error.mjs";
+import { createLoggerMiddleware } from "../../../../adapters/http/middleware/built-in/logger.mjs";
+import { registerPrometheusMiddleware } from "../../../../adapters/http/middleware/built-in/prometheus.mjs";
+import { registerRateLimitMiddleware } from "../../../../adapters/http/middleware/built-in/rate-limit.mjs";
+import { createSwaggerMiddleware } from "../../../../adapters/http/middleware/built-in/swagger.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 path from "node:path";
+//#region src/app/modules/http/modules/middleware.ts
+var HTTPMiddlewareModule = class {
+	async mountBefore(router, container) {
+		await this.mountPrometheus(router, container);
+		await this.mountLogger(router, container);
+		await this.mountCors(router, container);
+		await this.mountAssets(router);
+		await this.mountBasic(router);
+		await this.mountRateLimit(router, container);
+		await this.mountSwagger(router, container);
+		await this.mountAuthorization(router, container);
+	}
+	async mountAfter(router, _container) {
+		registerErrorMiddleware(router);
+	}
+	async mountCors(router, container) {
+		const config = container.resolve(ConfigInjectionKey);
+		if (!this.isEnabled(config.middlewareCors)) return;
+		registerCorsMiddleware(router, this.transformBoolToEmptyObject(config.middlewareCors));
+	}
+	async mountLogger(router, container) {
+		const middleware = createLoggerMiddleware({ env: container.resolve(ConfigInjectionKey).env });
+		router.use(middleware);
+	}
+	async mountAssets(router) {
+		await registerAssetsMiddleware(router);
+	}
+	async mountBasic(router) {
+		registerBasicMiddleware(router);
+	}
+	async mountPrometheus(router, container) {
+		const config = container.resolve(ConfigInjectionKey);
+		if (!this.isEnabled(config.middlewarePrometheus)) return;
+		registerPrometheusMiddleware(router, this.transformBoolToEmptyObject(config.middlewarePrometheus));
+	}
+	async mountRateLimit(router, container) {
+		const config = container.resolve(ConfigInjectionKey);
+		if (!this.isEnabled(config.middlewareRateLimit)) return;
+		registerRateLimitMiddleware(router, this.transformBoolToEmptyObject(config.middlewareRateLimit));
+	}
+	async mountSwagger(router, container) {
+		const config = container.resolve(ConfigInjectionKey);
+		if (!this.isEnabled(config.middlewareSwagger)) return;
+		const middleware = createSwaggerMiddleware({
+			documentPath: path.join(DIST_PATH, "swagger.json"),
+			baseURL: config.publicUrl
+		});
+		router.use("/docs", middleware);
+	}
+	async mountAuthorization(router, container) {
+		const config = container.resolve(ConfigInjectionKey);
+		const dataSource = container.resolve(DatabaseInjectionKey.DataSource);
+		const identityResolver = container.resolve(IdentityInjectionKey.Resolver);
+		const sessionManager = container.resolve(AuthenticationInjectionKey.SessionManager);
+		const oauth2TokenVerifier = container.resolve(OAuth2InjectionToken.TokenVerifier);
+		const middleware = createAuthorizationMiddleware({
+			identityResolver,
+			identityPermissionProvider: container.resolve(IdentityInjectionKey.PermissionProvider),
+			permissionProvider: new PermissionDatabaseProvider(dataSource),
+			oauth2TokenVerifier,
+			sessionManager,
+			options: {
+				clientAuthBasic: config.clientAuthBasic,
+				robotAuthBasic: config.robotAuthBasic,
+				userAuthBasic: config.userAuthBasic
+			}
+		});
+		router.use(middleware);
+	}
+	transformBoolToEmptyObject(input) {
+		if (typeof input === "boolean") return {};
+		return input || {};
+	}
+	isEnabled(input) {
+		return typeof input !== "boolean" || input === true;
+	}
+};
+//#endregion
+export { HTTPMiddlewareModule };
+
+//# sourceMappingURL=middleware.mjs.map

package/dist/app/modules/http/modules/middleware.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware.mjs","names":["path","createAuthorizationMiddleware","createLoggerMiddleware","createSwaggerMiddleware","registerAssetsMiddleware","registerBasicMiddleware","registerCorsMiddleware","registerErrorMiddleware","registerPrometheusMiddleware","registerRateLimitMiddleware","DIST_PATH","AuthenticationInjectionKey","ConfigInjectionKey","IdentityInjectionKey","OAuth2InjectionToken","DatabaseInjectionKey","PermissionDatabaseProvider","HTTPMiddlewareModule","mountBefore","router","container","mountPrometheus","mountLogger","mountCors","mountAssets","mountBasic","mountRateLimit","mountSwagger","mountAuthorization","mountAfter","_container","config","resolve","isEnabled","middlewareCors","transformBoolToEmptyObject","middleware","env","use","middlewarePrometheus","middlewareRateLimit","middlewareSwagger","documentPath","join","baseURL","publicUrl","dataSource","DataSource","identityResolver","Resolver","sessionManager","SessionManager","oauth2TokenVerifier","TokenVerifier","identityPermissionProvider","PermissionProvider","permissionProvider","options","clientAuthBasic","robotAuthBasic","userAuthBasic","input"],"sources":["../../../../../src/app/modules/http/modules/middleware.ts"],"sourcesContent":["/*\n * Copyright (c) 2025.\n *  Author Peter Placzek (tada5hi)\n *  For the full copyright and license information,\n *  view the LICENSE file that was distributed with this source code.\n */\n\nimport type { Router } from 'routup';\nimport path from 'node:path';\nimport type { IContainer } from 'eldin';\nimport {\n    createAuthorizationMiddleware,\n    createLoggerMiddleware,\n    createSwaggerMiddleware,\n    registerAssetsMiddleware,\n    registerBasicMiddleware,\n    registerCorsMiddleware,\n    registerErrorMiddleware,\n    registerPrometheusMiddleware,\n    registerRateLimitMiddleware,\n} from '../../../../adapters/http/index.ts';\nimport { DIST_PATH } from '../../../../path.ts';\nimport { AuthenticationInjectionKey } from '../../authentication/index.ts';\nimport { ConfigInjectionKey } from '../../config/index.ts';\nimport { IdentityInjectionKey } from '../../identity/index.ts';\nimport { OAuth2InjectionToken } from '../../oauth2/index.ts';\nimport {\n    DatabaseInjectionKey,\n    PermissionDatabaseProvider,\n} from '../../database/index.ts';\n\nexport class HTTPMiddlewareModule {\n    async mountBefore(router: Router, container: IContainer): Promise<void> {\n        // @routup/prometheus must be installed before any other plugin or\n        // route so that its onion middleware can observe the full request\n        // lifecycle (the v3 README is explicit on this).\n        await this.mountPrometheus(router, container);\n        await this.mountLogger(router, container);\n        await this.mountCors(router, container);\n        await this.mountAssets(router);\n        await this.mountBasic(router);\n        await this.mountRateLimit(router, container);\n\n        await this.mountSwagger(router, container);\n        await this.mountAuthorization(router, container);\n    }\n\n     \n    async mountAfter(router: Router, _container: IContainer): Promise<void> {\n        registerErrorMiddleware(router);\n    }\n\n    // ----------------------------------------------------\n    async mountCors(router: Router, container: IContainer): Promise<void> {\n        const config = container.resolve(ConfigInjectionKey);\n\n        if (!this.isEnabled(config.middlewareCors)) {\n            return;\n        }\n\n        registerCorsMiddleware(router, this.transformBoolToEmptyObject(config.middlewareCors));\n    }\n\n    async mountLogger(router: Router, container: IContainer): Promise<void> {\n        const config = container.resolve(ConfigInjectionKey);\n        const middleware = createLoggerMiddleware({ env: config.env });\n\n        router.use(middleware);\n    }\n\n    async mountAssets(router: Router): Promise<void> {\n        await registerAssetsMiddleware(router);\n    }\n\n    async mountBasic(router: Router): Promise<void> {\n        registerBasicMiddleware(router);\n    }\n\n    async mountPrometheus(router: Router, container: IContainer): Promise<void> {\n        const config = container.resolve(ConfigInjectionKey);\n\n        if (!this.isEnabled(config.middlewarePrometheus)) {\n            return;\n        }\n\n        registerPrometheusMiddleware(router, this.transformBoolToEmptyObject(config.middlewarePrometheus));\n    }\n\n    async mountRateLimit(router: Router, container: IContainer): Promise<void> {\n        const config = container.resolve(ConfigInjectionKey);\n\n        if (!this.isEnabled(config.middlewareRateLimit)) {\n            return;\n        }\n\n        registerRateLimitMiddleware(router, this.transformBoolToEmptyObject(config.middlewareRateLimit));\n    }\n\n    async mountSwagger(router: Router, container: IContainer): Promise<void> {\n        const config = container.resolve(ConfigInjectionKey);\n        if (!this.isEnabled(config.middlewareSwagger)) {\n            return;\n        }\n\n        const middleware = createSwaggerMiddleware({\n            documentPath: path.join(DIST_PATH, 'swagger.json'),\n            baseURL: config.publicUrl,\n        });\n\n        router.use('/docs', middleware);\n    }\n\n    async mountAuthorization(router: Router, container: IContainer): Promise<void> {\n        const config = container.resolve(ConfigInjectionKey);\n        const dataSource = container.resolve(DatabaseInjectionKey.DataSource);\n\n        const identityResolver = container.resolve(IdentityInjectionKey.Resolver);\n        const sessionManager = container.resolve(AuthenticationInjectionKey.SessionManager);\n        const oauth2TokenVerifier = container.resolve(OAuth2InjectionToken.TokenVerifier);\n        const identityPermissionProvider = container.resolve(IdentityInjectionKey.PermissionProvider);\n\n        const permissionProvider = new PermissionDatabaseProvider(dataSource);\n\n        const middleware = createAuthorizationMiddleware({\n            identityResolver,\n            identityPermissionProvider,\n            permissionProvider,\n            oauth2TokenVerifier,\n            sessionManager,\n            options: {\n                clientAuthBasic: config.clientAuthBasic,\n                robotAuthBasic: config.robotAuthBasic,\n                userAuthBasic: config.userAuthBasic,\n            },\n        });\n\n        router.use(middleware);\n    }\n\n    // ----------------------------------------------------\n\n    private transformBoolToEmptyObject<T extends Record<string, any>>(\n        input?: T | boolean,\n    ) : T | undefined {\n        if (typeof input === 'boolean') {\n            return {} as T;\n        }\n\n        return input || {} as T;\n    }\n\n    private isEnabled<T>(input: T | boolean) {\n        return typeof input !== 'boolean' || input === true;\n    }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AA+BA,IAAaiB,uBAAb,MAAaA;CACT,MAAMC,YAAYC,QAAgBC,WAAsC;AAIpE,QAAM,KAAKC,gBAAgBF,QAAQC,UAAAA;AACnC,QAAM,KAAKE,YAAYH,QAAQC,UAAAA;AAC/B,QAAM,KAAKG,UAAUJ,QAAQC,UAAAA;AAC7B,QAAM,KAAKI,YAAYL,OAAAA;AACvB,QAAM,KAAKM,WAAWN,OAAAA;AACtB,QAAM,KAAKO,eAAeP,QAAQC,UAAAA;AAElC,QAAM,KAAKO,aAAaR,QAAQC,UAAAA;AAChC,QAAM,KAAKQ,mBAAmBT,QAAQC,UAAAA;;CAI1C,MAAMS,WAAWV,QAAgBW,YAAuC;AACpEvB,0BAAwBY,OAAAA;;CAI5B,MAAMI,UAAUJ,QAAgBC,WAAsC;EAClE,MAAMW,SAASX,UAAUY,QAAQpB,mBAAAA;AAEjC,MAAI,CAAC,KAAKqB,UAAUF,OAAOG,eAAc,CACrC;AAGJ5B,yBAAuBa,QAAQ,KAAKgB,2BAA2BJ,OAAOG,eAAc,CAAA;;CAGxF,MAAMZ,YAAYH,QAAgBC,WAAsC;EAEpE,MAAMgB,aAAalC,uBAAuB,EAAEmC,KAD7BjB,UAAUY,QAAQpB,mBACgBmB,CAAOM,KAAI,CAAA;AAE5DlB,SAAOmB,IAAIF,WAAAA;;CAGf,MAAMZ,YAAYL,QAA+B;AAC7C,QAAMf,yBAAyBe,OAAAA;;CAGnC,MAAMM,WAAWN,QAA+B;AAC5Cd,0BAAwBc,OAAAA;;CAG5B,MAAME,gBAAgBF,QAAgBC,WAAsC;EACxE,MAAMW,SAASX,UAAUY,QAAQpB,mBAAAA;AAEjC,MAAI,CAAC,KAAKqB,UAAUF,OAAOQ,qBAAoB,CAC3C;AAGJ/B,+BAA6BW,QAAQ,KAAKgB,2BAA2BJ,OAAOQ,qBAAoB,CAAA;;CAGpG,MAAMb,eAAeP,QAAgBC,WAAsC;EACvE,MAAMW,SAASX,UAAUY,QAAQpB,mBAAAA;AAEjC,MAAI,CAAC,KAAKqB,UAAUF,OAAOS,oBAAmB,CAC1C;AAGJ/B,8BAA4BU,QAAQ,KAAKgB,2BAA2BJ,OAAOS,oBAAmB,CAAA;;CAGlG,MAAMb,aAAaR,QAAgBC,WAAsC;EACrE,MAAMW,SAASX,UAAUY,QAAQpB,mBAAAA;AACjC,MAAI,CAAC,KAAKqB,UAAUF,OAAOU,kBAAiB,CACxC;EAGJ,MAAML,aAAajC,wBAAwB;GACvCuC,cAAc1C,KAAK2C,KAAKjC,WAAW,eAAA;GACnCkC,SAASb,OAAOc;GACpB,CAAA;AAEA1B,SAAOmB,IAAI,SAASF,WAAAA;;CAGxB,MAAMR,mBAAmBT,QAAgBC,WAAsC;EAC3E,MAAMW,SAASX,UAAUY,QAAQpB,mBAAAA;EACjC,MAAMkC,aAAa1B,UAAUY,QAAQjB,qBAAqBgC,WAAU;EAEpE,MAAMC,mBAAmB5B,UAAUY,QAAQnB,qBAAqBoC,SAAQ;EACxE,MAAMC,iBAAiB9B,UAAUY,QAAQrB,2BAA2BwC,eAAc;EAClF,MAAMC,sBAAsBhC,UAAUY,QAAQlB,qBAAqBuC,cAAa;EAKhF,MAAMjB,aAAanC,8BAA8B;GAC7C+C;GACAM,4BAN+BlC,UAAUY,QAAQnB,qBAAqB0C,mBAMtED;GACAE,oBAAAA,IAL2BxC,2BAA2B8B,WAKtDU;GACAJ;GACAF;GACAO,SAAS;IACLC,iBAAiB3B,OAAO2B;IACxBC,gBAAgB5B,OAAO4B;IACvBC,eAAe7B,OAAO6B;IAC1B;GACJ,CAAA;AAEAzC,SAAOmB,IAAIF,WAAAA;;CAKPD,2BACJ0B,OACc;AACd,MAAI,OAAOA,UAAU,UACjB,QAAO,EAAC;AAGZ,SAAOA,SAAS,EAAC;;CAGb5B,UAAa4B,OAAoB;AACrC,SAAO,OAAOA,UAAU,aAAaA,UAAU"}

package/dist/app/modules/identity/constants.d.ts

@@ -0,0 +1,10 @@
+import { TypedToken } from 'eldin';
+import type { IIdentityPermissionProvider, IIdentityProviderAccountManager, IIdentityResolver, IIdentityRoleProvider, IdentityProviderLdapCollectionAuthenticator } from '../../../core/index.ts';
+export declare const IdentityInjectionKey: {
+    readonly Resolver: TypedToken<IIdentityResolver>;
+    readonly PermissionProvider: TypedToken<IIdentityPermissionProvider>;
+    readonly RoleProvider: TypedToken<IIdentityRoleProvider>;
+    readonly ProviderAccountManager: TypedToken<IIdentityProviderAccountManager>;
+    readonly ProviderLdapCollectionAuthenticator: TypedToken<IdentityProviderLdapCollectionAuthenticator>;
+};
+//# sourceMappingURL=constants.d.ts.map

package/dist/app/modules/identity/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../../src/app/modules/identity/constants.ts"],"names":[],"mappings":"AAOA,OAAO,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AACnC,OAAO,KAAK,EACR,2BAA2B,EAC3B,+BAA+B,EAC/B,iBAAiB,EACjB,qBAAqB,EACrB,2CAA2C,EAC9C,MAAM,wBAAwB,CAAC;AAEhC,eAAO,MAAM,oBAAoB;;;;;;CAMvB,CAAC"}

package/dist/app/modules/identity/constants.mjs

@@ -0,0 +1,13 @@
+import { TypedToken } from "eldin";
+//#region src/app/modules/identity/constants.ts
+const IdentityInjectionKey = {
+	Resolver: new TypedToken("Resolver"),
+	PermissionProvider: new TypedToken("IdentityPermissionProvider"),
+	RoleProvider: new TypedToken("IdentityRoleProvider"),
+	ProviderAccountManager: new TypedToken("AccountManager"),
+	ProviderLdapCollectionAuthenticator: new TypedToken("ProviderLdapCollectionAuthenticator")
+};
+//#endregion
+export { IdentityInjectionKey };
+
+//# sourceMappingURL=constants.mjs.map

package/dist/app/modules/identity/constants.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","names":["TypedToken","IdentityInjectionKey","Resolver","PermissionProvider","RoleProvider","ProviderAccountManager","ProviderLdapCollectionAuthenticator"],"sources":["../../../../src/app/modules/identity/constants.ts"],"sourcesContent":["/*\n * Copyright (c) 2025.\n * Author Peter Placzek (tada5hi)\n * For the full copyright and license information,\n * view the LICENSE file that was distributed with this source code.\n */\n\nimport { TypedToken } from 'eldin';\nimport type {\n    IIdentityPermissionProvider,\n    IIdentityProviderAccountManager,\n    IIdentityResolver,\n    IIdentityRoleProvider,\n    IdentityProviderLdapCollectionAuthenticator,\n} from '../../../core/index.ts';\n\nexport const IdentityInjectionKey = {\n    Resolver: new TypedToken<IIdentityResolver>('Resolver'),\n    PermissionProvider: new TypedToken<IIdentityPermissionProvider>('IdentityPermissionProvider'),\n    RoleProvider: new TypedToken<IIdentityRoleProvider>('IdentityRoleProvider'),\n    ProviderAccountManager: new TypedToken<IIdentityProviderAccountManager>('AccountManager'),\n    ProviderLdapCollectionAuthenticator: new TypedToken<IdentityProviderLdapCollectionAuthenticator>('ProviderLdapCollectionAuthenticator'),\n} as const;\n"],"mappings":";;AAgBA,MAAaC,uBAAuB;CAChCC,UAAU,IAAIF,WAA8B,WAAA;CAC5CG,oBAAoB,IAAIH,WAAwC,6BAAA;CAChEI,cAAc,IAAIJ,WAAkC,uBAAA;CACpDK,wBAAwB,IAAIL,WAA4C,iBAAA;CACxEM,qCAAqC,IAAIN,WAAwD,sCAAA;CACrG"}

package/dist/app/modules/identity/index.d.ts

@@ -0,0 +1,4 @@
+export * from './constants.ts';
+export * from './module.ts';
+export * from './repositories/index.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/app/modules/identity/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/app/modules/identity/index.ts"],"names":[],"mappings":"AAOA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,aAAa,CAAC;AAC5B,cAAc,yBAAyB,CAAC"}

package/dist/app/modules/identity/index.mjs

@@ -0,0 +1,11 @@
+import { IdentityInjectionKey } from "./constants.mjs";
+import { IdentityProviderAccountRepository } from "./repositories/provider/account/module.mjs";
+import { IdentityProviderAttributeMappingRepository } from "./repositories/provider/mapper/attribute.mjs";
+import { IdentityProviderPermissionMappingRepository } from "./repositories/provider/mapper/permission.mjs";
+import { IdentityProviderRoleMappingRepository } from "./repositories/provider/mapper/role.mjs";
+import { ClientIdentityRepository } from "./repositories/client.mjs";
+import { RobotIdentityRepository } from "./repositories/robot.mjs";
+import { UserIdentityRepository } from "./repositories/user.mjs";
+import "./repositories/index.mjs";
+import { IdentityModule } from "./module.mjs";
+export { ClientIdentityRepository, IdentityInjectionKey, IdentityModule, IdentityProviderAccountRepository, IdentityProviderAttributeMappingRepository, IdentityProviderPermissionMappingRepository, IdentityProviderRoleMappingRepository, RobotIdentityRepository, UserIdentityRepository };

package/dist/app/modules/identity/module.d.ts

@@ -0,0 +1,9 @@
+import type { IContainer } from 'eldin';
+import type { IModule } from 'orkos';
+export declare class IdentityModule implements IModule {
+    readonly name: string;
+    readonly dependencies: string[];
+    constructor();
+    setup(container: IContainer): Promise<void>;
+}
+//# sourceMappingURL=module.d.ts.map

package/dist/app/modules/identity/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../src/app/modules/identity/module.ts"],"names":[],"mappings":"AA0CA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,OAAO,CAAC;AAaxC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAIrC,qBAAa,cAAe,YAAW,OAAO;IAC1C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,QAAQ,CAAC,YAAY,EAAE,MAAM,EAAE,CAAC;;IAO1B,KAAK,CAAC,SAAS,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC;CAkGpD"}

package/dist/app/modules/identity/module.mjs

@@ -0,0 +1,115 @@
+import { RealmEntity } from "../../../adapters/database/domains/realm/entity.mjs";
+import { ClientEntity } from "../../../adapters/database/domains/client/entity.mjs";
+import { RoleEntity } from "../../../adapters/database/domains/role/entity.mjs";
+import { IdentityProviderRepository } from "../../../adapters/database/domains/identity-provider/repository.mjs";
+import { UserRepository } from "../../../adapters/database/domains/user/repository.mjs";
+import { RobotEntity } from "../../../adapters/database/domains/robot/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 { IdentityPermissionProvider } from "../../../core/identity/permission/module.mjs";
+import { IdentityProviderAttributeMapper } from "../../../core/identity/provider/mapper/attributes/module.mjs";
+import { IdentityProviderRoleMapper } from "../../../core/identity/provider/mapper/role/module.mjs";
+import { IdentityProviderPermissionMapper } from "../../../core/identity/provider/mapper/permission/module.mjs";
+import { IdentityProviderAccountManager } from "../../../core/identity/provider/account/module.mjs";
+import { IdentityProviderLdapCollectionAuthenticator } from "../../../core/identity/provider/authentication/protocols/ldap/collection.mjs";
+import { IdentityResolver } from "../../../core/identity/resolver/module.mjs";
+import { IdentityRoleProvider } from "../../../core/identity/role/module.mjs";
+import "../../../core/index.mjs";
+import { ModuleName } from "../constants.mjs";
+import { DatabaseInjectionKey } from "../database/constants.mjs";
+import { ClientRepositoryAdapter } from "../database/repositories/client/repository.mjs";
+import { IdentityProviderRepositoryAdapter } from "../database/repositories/identity-provider/repository.mjs";
+import { RobotRepositoryAdapter } from "../database/repositories/robot/repository.mjs";
+import { RoleRepositoryAdapter } from "../database/repositories/role/repository.mjs";
+import { UserRepositoryAdapter } from "../database/repositories/user/repository.mjs";
+import "../database/repositories/index.mjs";
+import "../database/index.mjs";
+import { IdentityInjectionKey } from "./constants.mjs";
+import { IdentityProviderAccountRepository } from "./repositories/provider/account/module.mjs";
+import { IdentityProviderAttributeMappingRepository } from "./repositories/provider/mapper/attribute.mjs";
+import { IdentityProviderPermissionMappingRepository } from "./repositories/provider/mapper/permission.mjs";
+import { IdentityProviderRoleMappingRepository } from "./repositories/provider/mapper/role.mjs";
+import { ClientIdentityRepository } from "./repositories/client.mjs";
+import { RobotIdentityRepository } from "./repositories/robot.mjs";
+import { UserIdentityRepository } from "./repositories/user.mjs";
+import "./repositories/index.mjs";
+import { LDAPInjectionKey } from "../ldap/constants.mjs";
+import "../ldap/index.mjs";
+//#region src/app/modules/identity/module.ts
+var IdentityModule = class {
+	name;
+	dependencies;
+	constructor() {
+		this.name = ModuleName.IDENTITY;
+		this.dependencies = [ModuleName.DATABASE];
+	}
+	async setup(container) {
+		const dataSource = container.resolve(DatabaseInjectionKey.DataSource);
+		const realmRepository = container.resolve(RealmEntity);
+		const clientRepository = new ClientIdentityRepository(container.resolve(ClientEntity));
+		const robotRepository = new RobotIdentityRepository(container.resolve(RobotEntity));
+		const userRepository = new UserIdentityRepository({
+			repository: new UserRepository(dataSource),
+			userPermissionRepository: container.resolve(UserPermissionEntity),
+			userRoleRepository: container.resolve(UserRoleEntity)
+		});
+		container.register(IdentityInjectionKey.Resolver, { useFactory: () => new IdentityResolver({
+			clientRepository,
+			robotRepository,
+			userRepository
+		}) });
+		const clientRepositoryAdapter = new ClientRepositoryAdapter({
+			repository: container.resolve(ClientEntity),
+			realmRepository
+		});
+		const userRepositoryAdapter = new UserRepositoryAdapter({
+			repository: new UserRepository(dataSource),
+			realmRepository
+		});
+		const robotRepositoryAdapter = new RobotRepositoryAdapter({
+			repository: container.resolve(RobotEntity),
+			realmRepository
+		});
+		const roleRepositoryAdapter = new RoleRepositoryAdapter({
+			repository: container.resolve(RoleEntity),
+			realmRepository
+		});
+		container.register(IdentityInjectionKey.RoleProvider, { useFactory: () => new IdentityRoleProvider({
+			clientRepository: clientRepositoryAdapter,
+			userRepository: userRepositoryAdapter,
+			robotRepository: robotRepositoryAdapter
+		}) });
+		container.register(IdentityInjectionKey.PermissionProvider, { useFactory: (c) => new IdentityPermissionProvider({
+			clientRepository: clientRepositoryAdapter,
+			userRepository: userRepositoryAdapter,
+			robotRepository: robotRepositoryAdapter,
+			roleRepository: roleRepositoryAdapter,
+			roleProvider: c.resolve(IdentityInjectionKey.RoleProvider)
+		}) });
+		const attributeMapper = new IdentityProviderAttributeMapper(new IdentityProviderAttributeMappingRepository());
+		const roleMapper = new IdentityProviderRoleMapper(new IdentityProviderRoleMappingRepository());
+		const permissionMapper = new IdentityProviderPermissionMapper(new IdentityProviderPermissionMappingRepository());
+		const providerAccountRepository = new IdentityProviderAccountRepository();
+		container.register(IdentityInjectionKey.ProviderAccountManager, { useFactory: () => new IdentityProviderAccountManager({
+			repository: providerAccountRepository,
+			userRepository,
+			attributeMapper,
+			roleMapper,
+			permissionMapper
+		}) });
+		const identityProviderRepository = new IdentityProviderRepositoryAdapter({
+			repository: new IdentityProviderRepository(dataSource),
+			realmRepository: container.resolve(RealmEntity)
+		});
+		container.register(IdentityInjectionKey.ProviderLdapCollectionAuthenticator, { useFactory: (c) => new IdentityProviderLdapCollectionAuthenticator({
+			repository: identityProviderRepository,
+			accountManager: c.resolve(IdentityInjectionKey.ProviderAccountManager),
+			clientFactory: c.resolve(LDAPInjectionKey.ClientFactory)
+		}) });
+	}
+};
+//#endregion
+export { IdentityModule };
+
+//# sourceMappingURL=module.mjs.map

package/dist/app/modules/identity/module.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.mjs","names":["ClientIdentityRepository","IdentityProviderAccountRepository","IdentityProviderAttributeMappingRepository","IdentityProviderPermissionMappingRepository","IdentityProviderRoleMappingRepository","RobotIdentityRepository","UserIdentityRepository","DatabaseInjectionKey","IdentityProviderRepositoryAdapter","ClientEntity","IdentityProviderRepository","RealmEntity","RobotEntity","RoleEntity","UserPermissionEntity","UserRepository","UserRoleEntity","ClientRepositoryAdapter","RobotRepositoryAdapter","RoleRepositoryAdapter","UserRepositoryAdapter","IdentityPermissionProvider","IdentityProviderAccountManager","IdentityProviderAttributeMapper","IdentityProviderLdapCollectionAuthenticator","IdentityProviderPermissionMapper","IdentityProviderRoleMapper","IdentityResolver","IdentityRoleProvider","LDAPInjectionKey","ModuleName","IdentityInjectionKey","IdentityModule","name","dependencies","IDENTITY","DATABASE","setup","container","dataSource","resolve","DataSource","realmRepository","clientRepository","robotRepository","userRepository","repository","userPermissionRepository","userRoleRepository","register","Resolver","useFactory","clientRepositoryAdapter","userRepositoryAdapter","robotRepositoryAdapter","roleRepositoryAdapter","RoleProvider","PermissionProvider","c","roleRepository","roleProvider","attributeMapperRepository","attributeMapper","roleMapperFinder","roleMapper","permissionMapperRepository","permissionMapper","providerAccountRepository","ProviderAccountManager","identityProviderRepository","ProviderLdapCollectionAuthenticator","accountManager","clientFactory","ClientFactory"],"sources":["../../../../src/app/modules/identity/module.ts"],"sourcesContent":["/*\n * Copyright (c) 2025.\n * Author Peter Placzek (tada5hi)\n * For the full copyright and license information,\n * view the LICENSE file that was distributed with this source code.\n */\n\nimport type {\n    Client,\n    Realm,\n    Robot,\n    Role,\n    UserPermission,\n    UserRole,\n} from '@authup/core-kit';\nimport type { Repository } from 'typeorm';\nimport {\n    ClientIdentityRepository,\n    IdentityProviderAccountRepository,\n    IdentityProviderAttributeMappingRepository,\n    IdentityProviderPermissionMappingRepository,\n    IdentityProviderRoleMappingRepository,\n    RobotIdentityRepository,\n    UserIdentityRepository,\n} from './repositories/index.ts';\nimport { DatabaseInjectionKey, IdentityProviderRepositoryAdapter } from '../database/index.ts';\nimport {\n    ClientEntity,\n    IdentityProviderRepository,\n    RealmEntity,\n    RobotEntity,\n    RoleEntity,\n    UserPermissionEntity,\n    UserRepository,\n    UserRoleEntity,\n} from '../../../adapters/database/domains/index.ts';\nimport {\n    ClientRepositoryAdapter,\n    RobotRepositoryAdapter,\n    RoleRepositoryAdapter,\n    UserRepositoryAdapter,\n} from '../database/repositories/index.ts';\nimport type { IContainer } from 'eldin';\nimport {\n    IdentityPermissionProvider,\n    IdentityProviderAccountManager,\n    IdentityProviderAttributeMapper,\n    IdentityProviderLdapCollectionAuthenticator,\n    IdentityProviderPermissionMapper,\n    IdentityProviderRoleMapper,\n    IdentityResolver,\n    IdentityRoleProvider,\n} from '../../../core/index.ts';\nimport { LDAPInjectionKey } from '../ldap/index.ts';\n\nimport type { IModule } from 'orkos';\nimport { ModuleName } from '../constants.ts';\nimport { IdentityInjectionKey } from './constants.ts';\n\nexport class IdentityModule implements IModule {\n    readonly name: string;\n\n    readonly dependencies: string[];\n\n    constructor() {\n        this.name = ModuleName.IDENTITY;\n        this.dependencies = [ModuleName.DATABASE];\n    }\n\n    async setup(container: IContainer): Promise<void> {\n        const dataSource = container.resolve(DatabaseInjectionKey.DataSource);\n        const realmRepository = container.resolve<Repository<Realm>>(RealmEntity);\n\n        const clientRepository = new ClientIdentityRepository(\n            container.resolve<Repository<Client>>(ClientEntity),\n        );\n        const robotRepository = new RobotIdentityRepository(\n            container.resolve<Repository<Robot>>(RobotEntity),\n        );\n        const userRepository = new UserIdentityRepository({\n            repository: new UserRepository(dataSource),\n            userPermissionRepository: container.resolve<Repository<UserPermission>>(UserPermissionEntity),\n            userRoleRepository: container.resolve<Repository<UserRole>>(UserRoleEntity),\n        });\n\n        container.register(IdentityInjectionKey.Resolver, {\n            useFactory: () => new IdentityResolver({\n                clientRepository,\n                robotRepository,\n                userRepository,\n            }),\n        });\n\n        // ---------------------------------------------\n\n        const clientRepositoryAdapter = new ClientRepositoryAdapter({\n            repository: container.resolve<Repository<Client>>(ClientEntity),\n            realmRepository,\n        });\n        const userRepositoryAdapter = new UserRepositoryAdapter({\n            repository: new UserRepository(dataSource),\n            realmRepository,\n        });\n        const robotRepositoryAdapter = new RobotRepositoryAdapter({\n            repository: container.resolve<Repository<Robot>>(RobotEntity),\n            realmRepository,\n        });\n        const roleRepositoryAdapter = new RoleRepositoryAdapter({\n            repository: container.resolve<Repository<Role>>(RoleEntity),\n            realmRepository,\n        });\n\n        container.register(IdentityInjectionKey.RoleProvider, {\n            useFactory: () => new IdentityRoleProvider({\n                clientRepository: clientRepositoryAdapter,\n                userRepository: userRepositoryAdapter,\n                robotRepository: robotRepositoryAdapter,\n            }),\n        });\n\n        container.register(IdentityInjectionKey.PermissionProvider, {\n            useFactory: (c) => new IdentityPermissionProvider({\n                clientRepository: clientRepositoryAdapter,\n                userRepository: userRepositoryAdapter,\n                robotRepository: robotRepositoryAdapter,\n                roleRepository: roleRepositoryAdapter,\n                roleProvider: c.resolve(IdentityInjectionKey.RoleProvider),\n            }),\n        });\n\n        // ---------------------------------------------\n\n        const attributeMapperRepository = new IdentityProviderAttributeMappingRepository();\n        const attributeMapper = new IdentityProviderAttributeMapper(attributeMapperRepository);\n\n        const roleMapperFinder = new IdentityProviderRoleMappingRepository();\n        const roleMapper = new IdentityProviderRoleMapper(roleMapperFinder);\n\n        const permissionMapperRepository = new IdentityProviderPermissionMappingRepository();\n        const permissionMapper = new IdentityProviderPermissionMapper(permissionMapperRepository);\n\n        const providerAccountRepository = new IdentityProviderAccountRepository();\n\n        container.register(IdentityInjectionKey.ProviderAccountManager, {\n            useFactory: () => new IdentityProviderAccountManager({\n                repository: providerAccountRepository,\n                userRepository,\n                attributeMapper,\n                roleMapper,\n                permissionMapper,\n            }),\n        });\n\n        // ---------------------------------------------\n\n        const identityProviderRepository = new IdentityProviderRepositoryAdapter({\n            repository: new IdentityProviderRepository(dataSource),\n            realmRepository: container.resolve<Repository<Realm>>(RealmEntity),\n        });\n        container.register(IdentityInjectionKey.ProviderLdapCollectionAuthenticator, {\n            useFactory: (c) => new IdentityProviderLdapCollectionAuthenticator({\n                repository: identityProviderRepository,\n                accountManager: c.resolve(IdentityInjectionKey.ProviderAccountManager),\n                clientFactory: c.resolve(LDAPInjectionKey.ClientFactory),\n            }),\n        });\n    }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA2DA,IAAagC,iBAAb,MAAaA;CACAC;CAEAC;CAET,cAAc;AACV,OAAKD,OAAOH,WAAWK;AACvB,OAAKD,eAAe,CAACJ,WAAWM,SAAS;;CAG7C,MAAMC,MAAMC,WAAsC;EAC9C,MAAMC,aAAaD,UAAUE,QAAQjC,qBAAqBkC,WAAU;EACpE,MAAMC,kBAAkBJ,UAAUE,QAA2B7B,YAAAA;EAE7D,MAAMgC,mBAAmB,IAAI3C,yBACzBsC,UAAUE,QAA4B/B,aAAAA,CAAAA;EAE1C,MAAMmC,kBAAkB,IAAIvC,wBACxBiC,UAAUE,QAA2B5B,YAAAA,CAAAA;EAEzC,MAAMiC,iBAAiB,IAAIvC,uBAAuB;GAC9CwC,YAAY,IAAI/B,eAAewB,WAAAA;GAC/BQ,0BAA0BT,UAAUE,QAAoC1B,qBAAAA;GACxEkC,oBAAoBV,UAAUE,QAA8BxB,eAAAA;GAChE,CAAA;AAEAsB,YAAUW,SAASlB,qBAAqBmB,UAAU,EAC9CC,kBAAkB,IAAIxB,iBAAiB;GACnCgB;GACAC;GACAC;GACJ,CAAA,EACJ,CAAA;EAIA,MAAMO,0BAA0B,IAAInC,wBAAwB;GACxD6B,YAAYR,UAAUE,QAA4B/B,aAAAA;GAClDiC;GACJ,CAAA;EACA,MAAMW,wBAAwB,IAAIjC,sBAAsB;GACpD0B,YAAY,IAAI/B,eAAewB,WAAAA;GAC/BG;GACJ,CAAA;EACA,MAAMY,yBAAyB,IAAIpC,uBAAuB;GACtD4B,YAAYR,UAAUE,QAA2B5B,YAAAA;GACjD8B;GACJ,CAAA;EACA,MAAMa,wBAAwB,IAAIpC,sBAAsB;GACpD2B,YAAYR,UAAUE,QAA0B3B,WAAAA;GAChD6B;GACJ,CAAA;AAEAJ,YAAUW,SAASlB,qBAAqByB,cAAc,EAClDL,kBAAkB,IAAIvB,qBAAqB;GACvCe,kBAAkBS;GAClBP,gBAAgBQ;GAChBT,iBAAiBU;GACrB,CAAA,EACJ,CAAA;AAEAhB,YAAUW,SAASlB,qBAAqB0B,oBAAoB,EACxDN,aAAaO,MAAM,IAAIrC,2BAA2B;GAC9CsB,kBAAkBS;GAClBP,gBAAgBQ;GAChBT,iBAAiBU;GACjBK,gBAAgBJ;GAChBK,cAAcF,EAAElB,QAAQT,qBAAqByB,aAAY;GAC7D,CAAA,EACJ,CAAA;EAKA,MAAMM,kBAAkB,IAAIvC,gCAAgCsC,IADtB3D,4CACsB2D,CAAAA;EAG5D,MAAMG,aAAa,IAAItC,2BAA2BqC,IADrB3D,uCACqB2D,CAAAA;EAGlD,MAAMG,mBAAmB,IAAIzC,iCAAiCwC,IADvB9D,6CACuB8D,CAAAA;EAE9D,MAAME,4BAA4B,IAAIlE,mCAAAA;AAEtCqC,YAAUW,SAASlB,qBAAqBqC,wBAAwB,EAC5DjB,kBAAkB,IAAI7B,+BAA+B;GACjDwB,YAAYqB;GACZtB;GACAiB;GACAE;GACAE;GACJ,CAAA,EACJ,CAAA;EAIA,MAAMG,6BAA6B,IAAI7D,kCAAkC;GACrEsC,YAAY,IAAIpC,2BAA2B6B,WAAAA;GAC3CG,iBAAiBJ,UAAUE,QAA2B7B,YAAAA;GAC1D,CAAA;AACA2B,YAAUW,SAASlB,qBAAqBuC,qCAAqC,EACzEnB,aAAaO,MAAM,IAAIlC,4CAA4C;GAC/DsB,YAAYuB;GACZE,gBAAgBb,EAAElB,QAAQT,qBAAqBqC,uBAAsB;GACrEI,eAAed,EAAElB,QAAQX,iBAAiB4C,cAAa;GAC3D,CAAA,EACJ,CAAA"}

package/dist/app/modules/identity/repositories/client.d.ts

@@ -0,0 +1,13 @@
+import type { Client } from '@authup/core-kit';
+import type { Repository } from 'typeorm';
+import type { IClientIdentityRepository } from '../../../../core/index.ts';
+export declare class ClientIdentityRepository implements IClientIdentityRepository {
+    private readonly repository;
+    constructor(repository: Repository<Client>);
+    findOneById(id: string): Promise<Client | null>;
+    findOneByName(id: string, realm?: string): Promise<Client | null>;
+    findOneByIdOrName(idOrName: string, realm?: string): Promise<Client | null>;
+    findOneBy(where: Record<string, any>): Promise<Client | null>;
+    private find;
+}
+//# sourceMappingURL=client.d.ts.map

package/dist/app/modules/identity/repositories/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../../src/app/modules/identity/repositories/client.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,kBAAkB,CAAC;AAC/C,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAC1C,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAC;AAG3E,qBAAa,wBAAyB,YAAW,yBAAyB;IACtE,OAAO,CAAC,QAAQ,CAAC,UAAU,CAAqB;gBAEpC,UAAU,EAAE,UAAU,CAAC,MAAM,CAAC;IAIpC,WAAW,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAI/C,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAIjE,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;IAI3E,SAAS,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC;YAIrD,IAAI;CAqCrB"}

package/dist/app/modules/identity/repositories/client.mjs

@@ -0,0 +1,44 @@
+import { CachePrefix } from "../../../../adapters/database/domains/constants.mjs";
+import "../../../../adapters/database/domains/index.mjs";
+import { buildRedisKeyPath } from "@authup/server-kit";
+import { isUUID } from "@authup/kit";
+//#region src/app/modules/identity/repositories/client.ts
+var ClientIdentityRepository = class {
+	repository;
+	constructor(repository) {
+		this.repository = repository;
+	}
+	async findOneById(id) {
+		return this.find(id);
+	}
+	async findOneByName(id, realm) {
+		return this.find(id, realm);
+	}
+	async findOneByIdOrName(idOrName, realm) {
+		return this.find(idOrName, realm);
+	}
+	async findOneBy(where) {
+		return this.repository.findOneBy(where);
+	}
+	async find(key, realmKey) {
+		const query = this.repository.createQueryBuilder("client").leftJoinAndSelect("client.realm", "realm");
+		const isId = isUUID(key);
+		if (isId) query.where("client.id = :id", { id: key });
+		else {
+			query.where("client.name = :name", { name: key });
+			if (realmKey) if (isUUID(realmKey)) query.andWhere("client.realm_id = :realmId", { realmId: realmKey });
+			else query.andWhere("realm.name = :realmName", { realmName: realmKey });
+		}
+		const { columns } = this.repository.metadata;
+		for (const column of columns) if (!column.isSelect) query.addSelect(`client.${column.databaseName}`);
+		if (isId) query.cache(buildRedisKeyPath({
+			prefix: CachePrefix.CLIENT,
+			key
+		}), 6e4);
+		return query.getOne();
+	}
+};
+//#endregion
+export { ClientIdentityRepository };
+
+//# sourceMappingURL=client.mjs.map

package/dist/app/modules/identity/repositories/client.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.mjs","names":["buildRedisKeyPath","isUUID","CachePrefix","ClientIdentityRepository","repository","findOneById","id","find","findOneByName","realm","findOneByIdOrName","idOrName","findOneBy","where","key","realmKey","query","createQueryBuilder","leftJoinAndSelect","isId","name","andWhere","realmId","realmName","columns","metadata","column","isSelect","addSelect","databaseName","cache","prefix","CLIENT","getOne"],"sources":["../../../../../src/app/modules/identity/repositories/client.ts"],"sourcesContent":["/*\n * Copyright (c) 2025.\n *  Author Peter Placzek (tada5hi)\n *  For the full copyright and license information,\n *  view the LICENSE file that was distributed with this source code.\n */\n\nimport { buildRedisKeyPath } from '@authup/server-kit';\nimport { isUUID } from '@authup/kit';\nimport type { Client } from '@authup/core-kit';\nimport type { Repository } from 'typeorm';\nimport type { IClientIdentityRepository } from '../../../../core/index.ts';\nimport { CachePrefix } from '../../../../adapters/database/domains/index.ts';\n\nexport class ClientIdentityRepository implements IClientIdentityRepository {\n    private readonly repository: Repository<Client>;\n\n    constructor(repository: Repository<Client>) {\n        this.repository = repository;\n    }\n\n    async findOneById(id: string): Promise<Client | null> {\n        return this.find(id);\n    }\n\n    async findOneByName(id: string, realm?: string): Promise<Client | null> {\n        return this.find(id, realm);\n    }\n\n    async findOneByIdOrName(idOrName: string, realm?: string): Promise<Client | null> {\n        return this.find(idOrName, realm);\n    }\n\n    async findOneBy(where: Record<string, any>): Promise<Client | null> {\n        return this.repository.findOneBy(where);\n    }\n\n    private async find(key: string, realmKey?: string) : Promise<Client | null> {\n        const query = this.repository.createQueryBuilder('client')\n            .leftJoinAndSelect('client.realm', 'realm');\n\n        const isId = isUUID(key);\n        if (isId) {\n            query.where('client.id = :id', { id: key });\n        } else {\n            query.where('client.name = :name', { name: key });\n\n            if (realmKey) {\n                if (isUUID(realmKey)) {\n                    query.andWhere('client.realm_id = :realmId', { realmId: realmKey });\n                } else {\n                    query.andWhere('realm.name = :realmName', { realmName: realmKey });\n                }\n            }\n        }\n        const { columns } = this.repository.metadata;\n        for (const column of columns) {\n            if (!column.isSelect) {\n                query.addSelect(`client.${column.databaseName}`);\n            }\n        }\n\n        if (isId) {\n            query.cache(\n                buildRedisKeyPath({\n                    prefix: CachePrefix.CLIENT,\n                    key,\n                }),\n                60_000,\n            );\n        }\n\n        return query.getOne();\n    }\n}\n"],"mappings":";;;;;AAcA,IAAaG,2BAAb,MAAaA;CACQC;CAEjB,YAAYA,YAAgC;AACxC,OAAKA,aAAaA;;CAGtB,MAAMC,YAAYC,IAAoC;AAClD,SAAO,KAAKC,KAAKD,GAAAA;;CAGrB,MAAME,cAAcF,IAAYG,OAAwC;AACpE,SAAO,KAAKF,KAAKD,IAAIG,MAAAA;;CAGzB,MAAMC,kBAAkBC,UAAkBF,OAAwC;AAC9E,SAAO,KAAKF,KAAKI,UAAUF,MAAAA;;CAG/B,MAAMG,UAAUC,OAAoD;AAChE,SAAO,KAAKT,WAAWQ,UAAUC,MAAAA;;CAGrC,MAAcN,KAAKO,KAAaC,UAA4C;EACxE,MAAMC,QAAQ,KAAKZ,WAAWa,mBAAmB,SAAA,CAC5CC,kBAAkB,gBAAgB,QAAA;EAEvC,MAAMC,OAAOlB,OAAOa,IAAAA;AACpB,MAAIK,KACAH,OAAMH,MAAM,mBAAmB,EAAEP,IAAIQ,KAAI,CAAA;OACtC;AACHE,SAAMH,MAAM,uBAAuB,EAAEO,MAAMN,KAAI,CAAA;AAE/C,OAAIC,SACA,KAAId,OAAOc,SAAAA,CACPC,OAAMK,SAAS,8BAA8B,EAAEC,SAASP,UAAS,CAAA;OAEjEC,OAAMK,SAAS,2BAA2B,EAAEE,WAAWR,UAAS,CAAA;;EAI5E,MAAM,EAAES,YAAY,KAAKpB,WAAWqB;AACpC,OAAK,MAAMC,UAAUF,QACjB,KAAI,CAACE,OAAOC,SACRX,OAAMY,UAAU,UAAUF,OAAOG,eAAc;AAIvD,MAAIV,KACAH,OAAMc,MACF9B,kBAAkB;GACd+B,QAAQ7B,YAAY8B;GACpBlB;GACJ,CAAA,EACA,IAAA;AAIR,SAAOE,MAAMiB,QAAM"}

package/dist/app/modules/identity/repositories/index.d.ts

@@ -0,0 +1,5 @@
+export * from './provider/index.ts';
+export * from './client.ts';
+export * from './robot.ts';
+export * from './user.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/app/modules/identity/repositories/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../src/app/modules/identity/repositories/index.ts"],"names":[],"mappings":"AAOA,cAAc,qBAAqB,CAAC;AAEpC,cAAc,aAAa,CAAC;AAC5B,cAAc,YAAY,CAAC;AAC3B,cAAc,WAAW,CAAC"}

package/dist/app/modules/identity/repositories/index.mjs

@@ -0,0 +1,9 @@
+import { IdentityProviderAccountRepository } from "./provider/account/module.mjs";
+import { IdentityProviderAttributeMappingRepository } from "./provider/mapper/attribute.mjs";
+import { IdentityProviderPermissionMappingRepository } from "./provider/mapper/permission.mjs";
+import { IdentityProviderRoleMappingRepository } from "./provider/mapper/role.mjs";
+import "./provider/index.mjs";
+import { ClientIdentityRepository } from "./client.mjs";
+import { RobotIdentityRepository } from "./robot.mjs";
+import { UserIdentityRepository } from "./user.mjs";
+export { ClientIdentityRepository, IdentityProviderAccountRepository, IdentityProviderAttributeMappingRepository, IdentityProviderPermissionMappingRepository, IdentityProviderRoleMappingRepository, RobotIdentityRepository, UserIdentityRepository };

package/dist/app/modules/identity/repositories/provider/account/index.d.ts

@@ -0,0 +1,2 @@
+export * from './module.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/app/modules/identity/repositories/provider/account/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/app/modules/identity/repositories/provider/account/index.ts"],"names":[],"mappings":"AAOA,cAAc,aAAa,CAAC"}

package/dist/app/modules/identity/repositories/provider/account/index.mjs

@@ -0,0 +1,2 @@
+import { IdentityProviderAccountRepository } from "./module.mjs";
+export { IdentityProviderAccountRepository };

package/dist/app/modules/identity/repositories/provider/account/module.d.ts

@@ -0,0 +1,8 @@
+import type { IdentityProviderAccount } from '@authup/core-kit';
+import type { DeepPartial } from 'typeorm';
+import type { IIdentityProviderAccountRepository, IdentityProviderIdentity } from '../../../../../../core/index.ts';
+export declare class IdentityProviderAccountRepository implements IIdentityProviderAccountRepository {
+    findOneByProviderIdentity(identity: IdentityProviderIdentity): Promise<IdentityProviderAccount | null>;
+    save(entity: DeepPartial<IdentityProviderAccount>): Promise<IdentityProviderAccount>;
+}
+//# sourceMappingURL=module.d.ts.map

package/dist/app/modules/identity/repositories/provider/account/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../../../../../../src/app/modules/identity/repositories/provider/account/module.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,kBAAkB,CAAC;AAChE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,SAAS,CAAC;AAE3C,OAAO,KAAK,EAAE,kCAAkC,EAAE,wBAAwB,EAAE,MAAM,iCAAiC,CAAC;AAGpH,qBAAa,iCAAkC,YAAW,kCAAkC;IAClF,yBAAyB,CAAC,QAAQ,EAAE,wBAAwB,GAAG,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC;IAatG,IAAI,CAAC,MAAM,EAAE,WAAW,CAAC,uBAAuB,CAAC,GAAG,OAAO,CAAC,uBAAuB,CAAC;CAM7F"}

package/dist/app/modules/identity/repositories/provider/account/module.mjs

@@ -0,0 +1,22 @@
+import { IdentityProviderAccountEntity } from "../../../../../../adapters/database/domains/identity-provider-account/entity.mjs";
+import "../../../../../../adapters/database/domains/index.mjs";
+import { useDataSource } from "typeorm-extension";
+//#region src/app/modules/identity/repositories/provider/account/module.ts
+var IdentityProviderAccountRepository = class {
+	async findOneByProviderIdentity(identity) {
+		return (await useDataSource()).getRepository(IdentityProviderAccountEntity).findOne({
+			where: {
+				provider_user_id: identity.id,
+				provider_id: identity.provider.id
+			},
+			relations: ["user"]
+		});
+	}
+	async save(entity) {
+		return (await useDataSource()).getRepository(IdentityProviderAccountEntity).save(entity);
+	}
+};
+//#endregion
+export { IdentityProviderAccountRepository };
+
+//# sourceMappingURL=module.mjs.map

package/dist/app/modules/identity/repositories/provider/account/module.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.mjs","names":["useDataSource","IdentityProviderAccountEntity","IdentityProviderAccountRepository","findOneByProviderIdentity","identity","dataSource","repository","getRepository","findOne","where","provider_user_id","id","provider_id","provider","relations","save","entity"],"sources":["../../../../../../../src/app/modules/identity/repositories/provider/account/module.ts"],"sourcesContent":["/*\n * Copyright (c) 2025.\n * Author Peter Placzek (tada5hi)\n * For the full copyright and license information,\n * view the LICENSE file that was distributed with this source code.\n */\n\nimport type { IdentityProviderAccount } from '@authup/core-kit';\nimport type { DeepPartial } from 'typeorm';\nimport { useDataSource } from 'typeorm-extension';\nimport type { IIdentityProviderAccountRepository, IdentityProviderIdentity } from '../../../../../../core/index.ts';\nimport { IdentityProviderAccountEntity } from '../../../../../../adapters/database/domains/index.ts';\n\nexport class IdentityProviderAccountRepository implements IIdentityProviderAccountRepository {\n    async findOneByProviderIdentity(identity: IdentityProviderIdentity): Promise<IdentityProviderAccount | null> {\n        const dataSource = await useDataSource();\n        const repository = dataSource.getRepository(IdentityProviderAccountEntity);\n\n        return repository.findOne({\n            where: {\n                provider_user_id: identity.id,\n                provider_id: identity.provider.id,\n            },\n            relations: ['user'],\n        });\n    }\n\n    async save(entity: DeepPartial<IdentityProviderAccount>): Promise<IdentityProviderAccount> {\n        const dataSource = await useDataSource();\n        const repository = dataSource.getRepository(IdentityProviderAccountEntity);\n\n        return repository.save(entity);\n    }\n}\n"],"mappings":";;;;AAaA,IAAaE,oCAAb,MAAaA;CACT,MAAMC,0BAA0BC,UAA6E;AAIzG,UAFmBC,MADML,eAAAA,EACKO,cAAcN,8BAErCK,CAAWE,QAAQ;GACtBC,OAAO;IACHC,kBAAkBN,SAASO;IAC3BC,aAAaR,SAASS,SAASF;IACnC;GACAG,WAAW,CAAC,OAAO;GACvB,CAAA;;CAGJ,MAAMC,KAAKC,QAAgF;AAIvF,UAFmBX,MADML,eAAAA,EACKO,cAAcN,8BAErCK,CAAWS,KAAKC,OAAAA"}

package/dist/app/modules/identity/repositories/provider/index.d.ts

@@ -0,0 +1,3 @@
+export * from './account/index.ts';
+export * from './mapper/index.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/app/modules/identity/repositories/provider/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/app/modules/identity/repositories/provider/index.ts"],"names":[],"mappings":"AAOA,cAAc,oBAAoB,CAAC;AACnC,cAAc,mBAAmB,CAAC"}

package/dist/app/modules/identity/repositories/provider/index.mjs

@@ -0,0 +1,7 @@
+import { IdentityProviderAccountRepository } from "./account/module.mjs";
+import "./account/index.mjs";
+import { IdentityProviderAttributeMappingRepository } from "./mapper/attribute.mjs";
+import { IdentityProviderPermissionMappingRepository } from "./mapper/permission.mjs";
+import { IdentityProviderRoleMappingRepository } from "./mapper/role.mjs";
+import "./mapper/index.mjs";
+export { IdentityProviderAccountRepository, IdentityProviderAttributeMappingRepository, IdentityProviderPermissionMappingRepository, IdentityProviderRoleMappingRepository };

package/dist/app/modules/identity/repositories/provider/mapper/attribute.d.ts

@@ -0,0 +1,6 @@
+import type { IdentityProviderAttributeMapping } from '@authup/core-kit';
+import type { IIdentityProviderAttributeMappingRepository } from '../../../../../../core/index.ts';
+export declare class IdentityProviderAttributeMappingRepository implements IIdentityProviderAttributeMappingRepository {
+    findByProviderId(providerId: string): Promise<IdentityProviderAttributeMapping[]>;
+}
+//# sourceMappingURL=attribute.d.ts.map

package/dist/app/modules/identity/repositories/provider/mapper/attribute.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attribute.d.ts","sourceRoot":"","sources":["../../../../../../../src/app/modules/identity/repositories/provider/mapper/attribute.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,gCAAgC,EAAE,MAAM,kBAAkB,CAAC;AAEzE,OAAO,KAAK,EAAE,2CAA2C,EAAE,MAAM,iCAAiC,CAAC;AAGnG,qBAAa,0CAA2C,YAAW,2CAA2C;IACpG,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,gCAAgC,EAAE,CAAC;CAM1F"}

package/dist/app/modules/identity/repositories/provider/mapper/attribute.mjs

@@ -0,0 +1,13 @@
+import { IdentityProviderAttributeMappingEntity } from "../../../../../../adapters/database/domains/identity-provider-attribute-mapping/entity.mjs";
+import "../../../../../../adapters/database/domains/index.mjs";
+import { useDataSource } from "typeorm-extension";
+//#region src/app/modules/identity/repositories/provider/mapper/attribute.ts
+var IdentityProviderAttributeMappingRepository = class {
+	async findByProviderId(providerId) {
+		return (await useDataSource()).getRepository(IdentityProviderAttributeMappingEntity).findBy({ provider_id: providerId });
+	}
+};
+//#endregion
+export { IdentityProviderAttributeMappingRepository };
+
+//# sourceMappingURL=attribute.mjs.map

package/dist/app/modules/identity/repositories/provider/mapper/attribute.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"attribute.mjs","names":["useDataSource","IdentityProviderAttributeMappingEntity","IdentityProviderAttributeMappingRepository","findByProviderId","providerId","dataSource","repository","getRepository","findBy","provider_id"],"sources":["../../../../../../../src/app/modules/identity/repositories/provider/mapper/attribute.ts"],"sourcesContent":["/*\n * Copyright (c) 2025.\n * Author Peter Placzek (tada5hi)\n * For the full copyright and license information,\n * view the LICENSE file that was distributed with this source code.\n */\n\nimport type { IdentityProviderAttributeMapping } from '@authup/core-kit';\nimport { useDataSource } from 'typeorm-extension';\nimport type { IIdentityProviderAttributeMappingRepository } from '../../../../../../core/index.ts';\nimport { IdentityProviderAttributeMappingEntity } from '../../../../../../adapters/database/domains/index.ts';\n\nexport class IdentityProviderAttributeMappingRepository implements IIdentityProviderAttributeMappingRepository {\n    async findByProviderId(providerId: string): Promise<IdentityProviderAttributeMapping[]> {\n        const dataSource = await useDataSource();\n        const repository = dataSource.getRepository(IdentityProviderAttributeMappingEntity);\n\n        return repository.findBy({ provider_id: providerId });\n    }\n}\n"],"mappings":";;;;AAYA,IAAaE,6CAAb,MAAaA;CACT,MAAMC,iBAAiBC,YAAiE;AAIpF,UAFmBC,MADML,eAAAA,EACKO,cAAcN,uCAErCK,CAAWE,OAAO,EAAEC,aAAaL,YAAW,CAAA"}

package/dist/app/modules/identity/repositories/provider/mapper/index.d.ts

@@ -0,0 +1,4 @@
+export * from './attribute.ts';
+export * from './permission.ts';
+export * from './role.ts';
+//# sourceMappingURL=index.d.ts.map

package/dist/app/modules/identity/repositories/provider/mapper/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../../src/app/modules/identity/repositories/provider/mapper/index.ts"],"names":[],"mappings":"AAOA,cAAc,gBAAgB,CAAC;AAC/B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC"}

package/dist/app/modules/identity/repositories/provider/mapper/index.mjs

@@ -0,0 +1,4 @@
+import { IdentityProviderAttributeMappingRepository } from "./attribute.mjs";
+import { IdentityProviderPermissionMappingRepository } from "./permission.mjs";
+import { IdentityProviderRoleMappingRepository } from "./role.mjs";
+export { IdentityProviderAttributeMappingRepository, IdentityProviderPermissionMappingRepository, IdentityProviderRoleMappingRepository };

package/dist/app/modules/identity/repositories/provider/mapper/permission.d.ts

@@ -0,0 +1,6 @@
+import type { IdentityProviderPermissionMapping } from '@authup/core-kit';
+import type { IIdentityProviderPermissionMappingRepository } from '../../../../../../core/index.ts';
+export declare class IdentityProviderPermissionMappingRepository implements IIdentityProviderPermissionMappingRepository {
+    findByProviderId(providerId: string): Promise<IdentityProviderPermissionMapping[]>;
+}
+//# sourceMappingURL=permission.d.ts.map

package/dist/app/modules/identity/repositories/provider/mapper/permission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission.d.ts","sourceRoot":"","sources":["../../../../../../../src/app/modules/identity/repositories/provider/mapper/permission.ts"],"names":[],"mappings":"AAOA,OAAO,KAAK,EAAE,iCAAiC,EAAE,MAAM,kBAAkB,CAAC;AAE1E,OAAO,KAAK,EAAE,4CAA4C,EAAE,MAAM,iCAAiC,CAAC;AAGpG,qBAAa,2CAA4C,YAAW,4CAA4C;IACtG,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,iCAAiC,EAAE,CAAC;CAM3F"}

package/dist/app/modules/identity/repositories/provider/mapper/permission.mjs

@@ -0,0 +1,13 @@
+import { IdentityProviderPermissionMappingEntity } from "../../../../../../adapters/database/domains/identity-provider-permission-mapping/entity.mjs";
+import "../../../../../../adapters/database/domains/index.mjs";
+import { useDataSource } from "typeorm-extension";
+//#region src/app/modules/identity/repositories/provider/mapper/permission.ts
+var IdentityProviderPermissionMappingRepository = class {
+	async findByProviderId(providerId) {
+		return (await useDataSource()).getRepository(IdentityProviderPermissionMappingEntity).findBy({ provider_id: providerId });
+	}
+};
+//#endregion
+export { IdentityProviderPermissionMappingRepository };
+
+//# sourceMappingURL=permission.mjs.map

package/dist/app/modules/identity/repositories/provider/mapper/permission.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"permission.mjs","names":["useDataSource","IdentityProviderPermissionMappingEntity","IdentityProviderPermissionMappingRepository","findByProviderId","providerId","dataSource","repository","getRepository","findBy","provider_id"],"sources":["../../../../../../../src/app/modules/identity/repositories/provider/mapper/permission.ts"],"sourcesContent":["/*\n * Copyright (c) 2025.\n * Author Peter Placzek (tada5hi)\n * For the full copyright and license information,\n * view the LICENSE file that was distributed with this source code.\n */\n\nimport type { IdentityProviderPermissionMapping } from '@authup/core-kit';\nimport { useDataSource } from 'typeorm-extension';\nimport type { IIdentityProviderPermissionMappingRepository } from '../../../../../../core/index.ts';\nimport { IdentityProviderPermissionMappingEntity } from '../../../../../../adapters/database/domains/index.ts';\n\nexport class IdentityProviderPermissionMappingRepository implements IIdentityProviderPermissionMappingRepository {\n    async findByProviderId(providerId: string): Promise<IdentityProviderPermissionMapping[]> {\n        const dataSource = await useDataSource();\n        const repository = dataSource.getRepository(IdentityProviderPermissionMappingEntity);\n\n        return repository.findBy({ provider_id: providerId });\n    }\n}\n"],"mappings":";;;;AAYA,IAAaE,8CAAb,MAAaA;CACT,MAAMC,iBAAiBC,YAAkE;AAIrF,UAFmBC,MADML,eAAAA,EACKO,cAAcN,wCAErCK,CAAWE,OAAO,EAAEC,aAAaL,YAAW,CAAA"}