@authup/server-core 1.0.0-beta.35 → 1.0.0-beta.37

package/dist/app/modules/config/read/env.mjs

@@ -0,0 +1,65 @@
+import { ConfigEnvironmentVariableName } from "../constants.mjs";
+import { oneOf, read, readArray, readBool, readInt } from "envix";
+import { hasEnvDataSourceOptions, readDataSourceOptionsFromEnv } from "typeorm-extension";
+//#region src/app/modules/config/read/env.ts
+function readConfigRawFromEnv() {
+	const options = {};
+	const env = read(ConfigEnvironmentVariableName.NODE_ENV);
+	if (env) options.env = env;
+	const writableDirectoryPath = read(ConfigEnvironmentVariableName.WRITABLE_DIRECTORY_PATH);
+	if (writableDirectoryPath) options.writableDirectoryPath = writableDirectoryPath;
+	if (hasEnvDataSourceOptions()) options.db = readDataSourceOptionsFromEnv();
+	const redis = oneOf([readBool(ConfigEnvironmentVariableName.REDIS), read(ConfigEnvironmentVariableName.REDIS)]);
+	if (typeof redis !== "undefined") options.redis = redis;
+	const smtp = oneOf([readBool(ConfigEnvironmentVariableName.SMTP), read(ConfigEnvironmentVariableName.SMTP)]);
+	if (typeof smtp !== "undefined") options.smtp = smtp;
+	const host = read(ConfigEnvironmentVariableName.HOST);
+	if (host) options.host = host;
+	const port = readInt(ConfigEnvironmentVariableName.PORT);
+	if (port) options.port = Number.parseInt(`${port}`, 10);
+	const publicURL = read(ConfigEnvironmentVariableName.PUBLIC_URL);
+	if (publicURL) options.publicUrl = publicURL;
+	const tokenAccessMaxAge = readInt(ConfigEnvironmentVariableName.TOKEN_ACCESS_MAX_AGE);
+	if (typeof tokenAccessMaxAge !== "undefined") options.tokenAccessMaxAge = tokenAccessMaxAge;
+	const tokenRefreshMaxAge = readInt(ConfigEnvironmentVariableName.TOKEN_REFRESH_MAX_AGE);
+	if (typeof tokenRefreshMaxAge !== "undefined") options.tokenRefreshMaxAge = tokenRefreshMaxAge;
+	const registrationEnabled = readBool(ConfigEnvironmentVariableName.REGISTRATION_ENABLED);
+	if (typeof registrationEnabled !== "undefined") options.registrationEnabled = registrationEnabled;
+	const emailVerificationEnabled = readBool(ConfigEnvironmentVariableName.EMAIL_VERIFICATION_ENABLED);
+	if (typeof emailVerificationEnabled !== "undefined") options.emailVerificationEnabled = emailVerificationEnabled;
+	const passwordRecoveryEnabled = readBool(ConfigEnvironmentVariableName.PASSWORD_RECOVERY_ENABLED);
+	if (typeof passwordRecoveryEnabled !== "undefined") options.passwordRecoveryEnabled = passwordRecoveryEnabled;
+	const clientBasicAuth = readBool(ConfigEnvironmentVariableName.CLIENT_AUTH_BASIC);
+	if (typeof clientBasicAuth !== "undefined") options.clientAuthBasic = clientBasicAuth;
+	const clientSystemEnabled = readBool(ConfigEnvironmentVariableName.CLIENT_SYSTEM_ENABLED);
+	if (typeof clientSystemEnabled !== "undefined") options.clientSystemEnabled = clientSystemEnabled;
+	const clientAdminSecret = read(ConfigEnvironmentVariableName.CLIENT_SYSTEM_SECRET);
+	if (clientAdminSecret) options.clientSystemSecret = clientAdminSecret;
+	const clientAdminSecretReset = readBool(ConfigEnvironmentVariableName.CLIENT_SYSTEM_SECRET_RESET);
+	if (typeof clientAdminSecretReset !== "undefined") options.clientSystemSecretReset = clientAdminSecretReset;
+	const userBasicAuth = readBool(ConfigEnvironmentVariableName.USER_AUTH_BASIC);
+	if (typeof userBasicAuth !== "undefined") options.userAuthBasic = userBasicAuth;
+	const userAdminEnabled = readBool(ConfigEnvironmentVariableName.USER_ADMIN_ENABLED);
+	if (typeof userAdminEnabled !== "undefined") options.userAdminEnabled = userAdminEnabled;
+	const userAdminPassword = read(ConfigEnvironmentVariableName.USER_ADMIN_PASSWORD);
+	if (userAdminPassword) options.userAdminPassword = userAdminPassword;
+	const userAdminPasswordReset = readBool(ConfigEnvironmentVariableName.USER_ADMIN_PASSWORD_RESET);
+	if (typeof userAdminPasswordReset !== "undefined") options.userAdminPasswordReset = userAdminPasswordReset;
+	const robotBasicAuth = readBool(ConfigEnvironmentVariableName.ROBOT_AUTH_BASIC);
+	if (typeof robotBasicAuth !== "undefined") options.robotAuthBasic = robotBasicAuth;
+	const robotAdminEnabled = readBool(ConfigEnvironmentVariableName.ROBOT_ADMIN_ENABLED);
+	if (typeof robotAdminEnabled !== "undefined") options.robotAdminEnabled = robotAdminEnabled;
+	const robotAdminSecret = read(ConfigEnvironmentVariableName.ROBOT_ADMIN_SECRET);
+	if (robotAdminSecret) options.robotAdminSecret = robotAdminSecret;
+	const robotAdminSecretReset = readBool(ConfigEnvironmentVariableName.ROBOT_ADMIN_SECRET_RESET);
+	if (typeof robotAdminSecretReset !== "undefined") options.robotAdminSecretReset = robotAdminSecretReset;
+	const permissions = readArray(ConfigEnvironmentVariableName.PERMISSIONS);
+	if (permissions && permissions.length > 0) options.permissions = permissions;
+	const permissionsDefaultPolicyAssignment = readBool(ConfigEnvironmentVariableName.PERMISSIONS_DEFAULT_POLICY_ASSIGNMENT);
+	if (typeof permissionsDefaultPolicyAssignment !== "undefined") options.permissionsDefaultPolicyAssignment = permissionsDefaultPolicyAssignment;
+	return options;
+}
+//#endregion
+export { readConfigRawFromEnv };
+
+//# sourceMappingURL=env.mjs.map

package/dist/app/modules/config/read/env.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"env.mjs","names":["oneOf","read","readArray","readBool","readInt","hasEnvDataSourceOptions","readDataSourceOptionsFromEnv","ConfigEnvironmentVariableName","readConfigRawFromEnv","options","env","NODE_ENV","writableDirectoryPath","WRITABLE_DIRECTORY_PATH","db","redis","REDIS","smtp","SMTP","host","HOST","port","PORT","Number","parseInt","publicURL","PUBLIC_URL","publicUrl","tokenAccessMaxAge","TOKEN_ACCESS_MAX_AGE","tokenRefreshMaxAge","TOKEN_REFRESH_MAX_AGE","registrationEnabled","REGISTRATION_ENABLED","emailVerificationEnabled","EMAIL_VERIFICATION_ENABLED","passwordRecoveryEnabled","PASSWORD_RECOVERY_ENABLED","clientBasicAuth","CLIENT_AUTH_BASIC","clientAuthBasic","clientSystemEnabled","CLIENT_SYSTEM_ENABLED","clientAdminSecret","CLIENT_SYSTEM_SECRET","clientSystemSecret","clientAdminSecretReset","CLIENT_SYSTEM_SECRET_RESET","clientSystemSecretReset","userBasicAuth","USER_AUTH_BASIC","userAuthBasic","userAdminEnabled","USER_ADMIN_ENABLED","userAdminPassword","USER_ADMIN_PASSWORD","userAdminPasswordReset","USER_ADMIN_PASSWORD_RESET","robotBasicAuth","ROBOT_AUTH_BASIC","robotAuthBasic","robotAdminEnabled","ROBOT_ADMIN_ENABLED","robotAdminSecret","ROBOT_ADMIN_SECRET","robotAdminSecretReset","ROBOT_ADMIN_SECRET_RESET","permissions","PERMISSIONS","length","permissionsDefaultPolicyAssignment","PERMISSIONS_DEFAULT_POLICY_ASSIGNMENT"],"sources":["../../../../../src/app/modules/config/read/env.ts"],"sourcesContent":["/*\n * Copyright (c) 2022-2024.\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 {\n    oneOf, \n    read, \n    readArray, \n    readBool, \n    readInt,\n} from 'envix';\nimport { hasEnvDataSourceOptions, readDataSourceOptionsFromEnv } from 'typeorm-extension';\nimport type { BetterSqlite3ConnectionOptions } from 'typeorm/driver/better-sqlite3/BetterSqlite3ConnectionOptions.js';\nimport type { MysqlConnectionOptions } from 'typeorm/driver/mysql/MysqlConnectionOptions.js';\nimport type { PostgresConnectionOptions } from 'typeorm/driver/postgres/PostgresConnectionOptions.js';\n\nimport { ConfigEnvironmentVariableName } from '../constants.ts';\nimport type { ConfigInput } from '../types.ts';\n\nexport function readConfigRawFromEnv() : ConfigInput {\n    const options : ConfigInput = {};\n\n    const env = read(ConfigEnvironmentVariableName.NODE_ENV);\n    if (env) {\n        options.env = env;\n    }\n\n    const writableDirectoryPath = read(ConfigEnvironmentVariableName.WRITABLE_DIRECTORY_PATH);\n    if (writableDirectoryPath) {\n        options.writableDirectoryPath = writableDirectoryPath;\n    }\n\n    // -------------------------------------------------------------\n\n    if (hasEnvDataSourceOptions()) {\n        // todo: type casting should be avoided\n        options.db = readDataSourceOptionsFromEnv() as MysqlConnectionOptions |\n        PostgresConnectionOptions |\n        BetterSqlite3ConnectionOptions;\n    }\n\n    const redis = oneOf([\n        readBool(ConfigEnvironmentVariableName.REDIS),\n        read(ConfigEnvironmentVariableName.REDIS),\n    ]);\n    if (typeof redis !== 'undefined') {\n        options.redis = redis;\n    }\n\n    const smtp = oneOf([\n        readBool(ConfigEnvironmentVariableName.SMTP),\n        read(ConfigEnvironmentVariableName.SMTP),\n    ]);\n    if (typeof smtp !== 'undefined') {\n        options.smtp = smtp;\n    }\n\n    // -------------------------------------------------------------\n\n    const host = read(ConfigEnvironmentVariableName.HOST);\n    if (host) {\n        options.host = host;\n    }\n\n    const port = readInt(ConfigEnvironmentVariableName.PORT);\n    if (port) {\n        options.port = Number.parseInt(`${port}`, 10);\n    }\n\n    const publicURL = read(ConfigEnvironmentVariableName.PUBLIC_URL);\n    if (publicURL) {\n        options.publicUrl = publicURL;\n    }\n\n    const tokenAccessMaxAge = readInt(ConfigEnvironmentVariableName.TOKEN_ACCESS_MAX_AGE);\n    if (typeof tokenAccessMaxAge !== 'undefined') {\n        options.tokenAccessMaxAge = tokenAccessMaxAge;\n    }\n\n    const tokenRefreshMaxAge = readInt(ConfigEnvironmentVariableName.TOKEN_REFRESH_MAX_AGE);\n    if (typeof tokenRefreshMaxAge !== 'undefined') {\n        options.tokenRefreshMaxAge = tokenRefreshMaxAge;\n    }\n\n    const registrationEnabled = readBool(ConfigEnvironmentVariableName.REGISTRATION_ENABLED);\n    if (typeof registrationEnabled !== 'undefined') {\n        options.registrationEnabled = registrationEnabled;\n    }\n\n    const emailVerificationEnabled = readBool(ConfigEnvironmentVariableName.EMAIL_VERIFICATION_ENABLED);\n    if (typeof emailVerificationEnabled !== 'undefined') {\n        options.emailVerificationEnabled = emailVerificationEnabled;\n    }\n\n    const passwordRecoveryEnabled = readBool(ConfigEnvironmentVariableName.PASSWORD_RECOVERY_ENABLED);\n    if (typeof passwordRecoveryEnabled !== 'undefined') {\n        options.passwordRecoveryEnabled = passwordRecoveryEnabled;\n    }\n\n    // ---------------------------------------------------------------\n\n    const clientBasicAuth = readBool(ConfigEnvironmentVariableName.CLIENT_AUTH_BASIC);\n    if (typeof clientBasicAuth !== 'undefined') {\n        options.clientAuthBasic = clientBasicAuth;\n    }\n\n    const clientSystemEnabled = readBool(ConfigEnvironmentVariableName.CLIENT_SYSTEM_ENABLED);\n    if (typeof clientSystemEnabled !== 'undefined') {\n        options.clientSystemEnabled = clientSystemEnabled;\n    }\n\n    const clientAdminSecret = read(ConfigEnvironmentVariableName.CLIENT_SYSTEM_SECRET);\n    if (clientAdminSecret) {\n        options.clientSystemSecret = clientAdminSecret;\n    }\n\n    const clientAdminSecretReset = readBool(ConfigEnvironmentVariableName.CLIENT_SYSTEM_SECRET_RESET);\n    if (typeof clientAdminSecretReset !== 'undefined') {\n        options.clientSystemSecretReset = clientAdminSecretReset;\n    }\n\n    // ---------------------------------------------------------------\n\n    const userBasicAuth = readBool(ConfigEnvironmentVariableName.USER_AUTH_BASIC);\n    if (typeof userBasicAuth !== 'undefined') {\n        options.userAuthBasic = userBasicAuth;\n    }\n\n    const userAdminEnabled = readBool(ConfigEnvironmentVariableName.USER_ADMIN_ENABLED);\n    if (typeof userAdminEnabled !== 'undefined') {\n        options.userAdminEnabled = userAdminEnabled;\n    }\n\n    const userAdminPassword = read(ConfigEnvironmentVariableName.USER_ADMIN_PASSWORD);\n    if (userAdminPassword) {\n        options.userAdminPassword = userAdminPassword;\n    }\n\n    const userAdminPasswordReset = readBool(ConfigEnvironmentVariableName.USER_ADMIN_PASSWORD_RESET);\n    if (typeof userAdminPasswordReset !== 'undefined') {\n        options.userAdminPasswordReset = userAdminPasswordReset;\n    }\n\n    // ---------------------------------------------------------------\n\n    const robotBasicAuth = readBool(ConfigEnvironmentVariableName.ROBOT_AUTH_BASIC);\n    if (typeof robotBasicAuth !== 'undefined') {\n        options.robotAuthBasic = robotBasicAuth;\n    }\n\n    const robotAdminEnabled = readBool(ConfigEnvironmentVariableName.ROBOT_ADMIN_ENABLED);\n    if (typeof robotAdminEnabled !== 'undefined') {\n        options.robotAdminEnabled = robotAdminEnabled;\n    }\n\n    const robotAdminSecret = read(ConfigEnvironmentVariableName.ROBOT_ADMIN_SECRET);\n    if (robotAdminSecret) {\n        options.robotAdminSecret = robotAdminSecret;\n    }\n\n    const robotAdminSecretReset = readBool(ConfigEnvironmentVariableName.ROBOT_ADMIN_SECRET_RESET);\n    if (typeof robotAdminSecretReset !== 'undefined') {\n        options.robotAdminSecretReset = robotAdminSecretReset;\n    }\n\n    // ---------------------------------------------------------------\n\n    const permissions = readArray(ConfigEnvironmentVariableName.PERMISSIONS);\n    if (permissions && permissions.length > 0) {\n        options.permissions = permissions;\n    }\n\n    const permissionsDefaultPolicyAssignment = readBool(ConfigEnvironmentVariableName.PERMISSIONS_DEFAULT_POLICY_ASSIGNMENT);\n    if (typeof permissionsDefaultPolicyAssignment !== 'undefined') {\n        options.permissionsDefaultPolicyAssignment = permissionsDefaultPolicyAssignment;\n    }\n\n    return options;\n}\n"],"mappings":"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"}

package/dist/app/modules/config/read/fs.mjs

@@ -0,0 +1,34 @@
+import { Container } from "confinity";
+//#region src/app/modules/config/read/fs.ts
+async function readConfigRawFromFS(options = {}) {
+	const container = new Container({
+		prefix: "authup",
+		cwd: options.cwd
+	});
+	if (options.file) await container.loadFile(options.file);
+	else await container.load();
+	const raw = container.get("server.core") || {};
+	const db = container.get([
+		"db",
+		"server.db",
+		"server.core.db"
+	]);
+	if (db) raw.db = db;
+	const redis = container.get([
+		"redis",
+		"server.redis",
+		"server.core.redis"
+	]);
+	if (redis) raw.redis = redis;
+	const smtp = container.get([
+		"smtp",
+		"server.smtp",
+		"server.core.smtp"
+	]);
+	if (smtp) raw.smtp = smtp;
+	return raw;
+}
+//#endregion
+export { readConfigRawFromFS };
+
+//# sourceMappingURL=fs.mjs.map

package/dist/app/modules/config/read/fs.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.mjs","names":["Container","readConfigRawFromFS","options","container","prefix","cwd","file","loadFile","load","raw","get","db","redis","smtp"],"sources":["../../../../../src/app/modules/config/read/fs.ts"],"sourcesContent":["/*\n * Copyright (c) 2024.\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 { Container } from 'confinity';\nimport type { ConfigInput } from '../types.ts';\nimport type { ConfigReadFsOptions } from './types.ts';\n\nexport async function readConfigRawFromFS(options: ConfigReadFsOptions = {}) {\n    const container = new Container({\n        prefix: 'authup',\n        cwd: options.cwd,\n    });\n\n    if (options.file) {\n        await container.loadFile(options.file);\n    } else {\n        await container.load();\n    }\n\n    const raw : ConfigInput = container.get('server.core') || {};\n\n    const db = container.get([\n        'db',\n        'server.db',\n        'server.core.db',\n    ]);\n    if (db) {\n        raw.db = db;\n    }\n\n    const redis = container.get([\n        'redis',\n        'server.redis',\n        'server.core.redis',\n    ]);\n    if (redis) {\n        raw.redis = redis;\n    }\n\n    const smtp = container.get([\n        'smtp',\n        'server.smtp',\n        'server.core.smtp',\n    ]);\n    if (smtp) {\n        raw.smtp = smtp;\n    }\n\n    return raw;\n}\n"],"mappings":";;AAWA,eAAsBC,oBAAoBC,UAA+B,EAAE,EAAA;CACvE,MAAMC,YAAY,IAAIH,UAAU;EAC5BI,QAAQ;EACRC,KAAKH,QAAQG;EACjB,CAAA;AAEA,KAAIH,QAAQI,KACR,OAAMH,UAAUI,SAASL,QAAQI,KAAI;KAErC,OAAMH,UAAUK,MAAI;CAGxB,MAAMC,MAAoBN,UAAUO,IAAI,cAAA,IAAkB,EAAC;CAE3D,MAAMC,KAAKR,UAAUO,IAAI;EACrB;EACA;EACA;EACH,CAAA;AACD,KAAIC,GACAF,KAAIE,KAAKA;CAGb,MAAMC,QAAQT,UAAUO,IAAI;EACxB;EACA;EACA;EACH,CAAA;AACD,KAAIE,MACAH,KAAIG,QAAQA;CAGhB,MAAMC,OAAOV,UAAUO,IAAI;EACvB;EACA;EACA;EACH,CAAA;AACD,KAAIG,KACAJ,KAAII,OAAOA;AAGf,QAAOJ"}

package/dist/app/modules/config/read/index.mjs

@@ -0,0 +1,4 @@
+import { readConfigRawFromEnv } from "./env.mjs";
+import { readConfigRawFromFS } from "./fs.mjs";
+import { readConfigRaw } from "./module.mjs";
+export { readConfigRaw, readConfigRawFromEnv, readConfigRawFromFS };

package/dist/app/modules/config/read/module.mjs

@@ -0,0 +1,21 @@
+import { readConfigRawFromEnv } from "./env.mjs";
+import { readConfigRawFromFS } from "./fs.mjs";
+import { merge } from "smob";
+//#region src/app/modules/config/read/module.ts
+async function readConfigRaw(options = {}) {
+	if (options.fs && options.env) {
+		const fs = await readConfigRawFromFS(boolableToObject(options.fs));
+		return merge(readConfigRawFromEnv(), fs);
+	}
+	if (options.fs) return readConfigRawFromFS(boolableToObject(options.fs));
+	if (options.env) return readConfigRawFromEnv();
+	return {};
+}
+function boolableToObject(input) {
+	if (typeof input === "boolean") return {};
+	return input;
+}
+//#endregion
+export { readConfigRaw };
+
+//# sourceMappingURL=module.mjs.map

package/dist/app/modules/config/read/module.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.mjs","names":["merge","readConfigRawFromEnv","readConfigRawFromFS","readConfigRaw","options","fs","env","fsOptions","boolableToObject","input"],"sources":["../../../../../src/app/modules/config/read/module.ts"],"sourcesContent":["/*\n * Copyright (c) 2024-2024.\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 { merge } from 'smob';\nimport type { ConfigInput } from '../types.ts';\nimport { readConfigRawFromEnv } from './env.ts';\nimport { readConfigRawFromFS } from './fs.ts';\nimport type { ConfigRawReadOptions } from './types.ts';\n\nexport async function readConfigRaw(options: ConfigRawReadOptions = {}) : Promise<ConfigInput> {\n    if (options.fs && options.env) {\n        const fsOptions = boolableToObject(options.fs);\n        const fs = await readConfigRawFromFS(fsOptions);\n        const env = readConfigRawFromEnv();\n\n        return merge(env, fs);\n    }\n\n    if (options.fs) {\n        const fsOptions = boolableToObject(options.fs);\n        return readConfigRawFromFS(fsOptions);\n    }\n\n    if (options.env) {\n        return readConfigRawFromEnv();\n    }\n\n    return {};\n}\n\nfunction boolableToObject<T>(input: T | boolean) : T {\n    if (typeof input === 'boolean') {\n        return {} as T;\n    }\n\n    return input;\n}\n"],"mappings":";;;;AAaA,eAAsBG,cAAcC,UAAgC,EAAE,EAAA;AAClE,KAAIA,QAAQC,MAAMD,QAAQE,KAAK;EAE3B,MAAMD,KAAK,MAAMH,oBADCM,iBAAiBJ,QAAQC,GACNE,CAAAA;AAGrC,SAAOP,MAFKC,sBAECK,EAAKD,GAAAA;;AAGtB,KAAID,QAAQC,GAER,QAAOH,oBADWM,iBAAiBJ,QAAQC,GAChBE,CAAAA;AAG/B,KAAIH,QAAQE,IACR,QAAOL,sBAAAA;AAGX,QAAO,EAAC;;AAGZ,SAASO,iBAAoBC,OAAkB;AAC3C,KAAI,OAAOA,UAAU,UACjB,QAAO,EAAC;AAGZ,QAAOA"}

package/dist/app/modules/config/read/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/app/modules/config/types.mjs

@@ -0,0 +1 @@
+export {};

package/dist/app/modules/constants.mjs

@@ -0,0 +1,21 @@
+//#region src/app/modules/constants.ts
+const ModuleName = {
+	CONFIG: "config",
+	LOGGER: "logger",
+	CACHE: "cache",
+	MAIL: "mail",
+	RUNTIME: "runtime",
+	SWAGGER: "swagger",
+	DATABASE: "database",
+	PROVISIONING: "provisioning",
+	LDAP: "ldap",
+	AUTHENTICATION: "authentication",
+	IDENTITY: "identity",
+	OAUTH2: "oauth2",
+	COMPONENTS: "components",
+	HTTP: "http"
+};
+//#endregion
+export { ModuleName };
+
+//# sourceMappingURL=constants.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","names":["ModuleName","CONFIG","LOGGER","CACHE","MAIL","RUNTIME","SWAGGER","DATABASE","PROVISIONING","LDAP","AUTHENTICATION","IDENTITY","OAUTH2","COMPONENTS","HTTP"],"sources":["../../../src/app/modules/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\nexport const ModuleName = {\n    CONFIG: 'config',\n    LOGGER: 'logger',\n    CACHE: 'cache',\n    MAIL: 'mail',\n    RUNTIME: 'runtime',\n    SWAGGER: 'swagger',\n    DATABASE: 'database',\n    PROVISIONING: 'provisioning',\n    LDAP: 'ldap',\n    AUTHENTICATION: 'authentication',\n    IDENTITY: 'identity',\n    OAUTH2: 'oauth2',\n    COMPONENTS: 'components',\n    HTTP: 'http',\n} as const;\n"],"mappings":";AAOA,MAAaA,aAAa;CACtBC,QAAQ;CACRC,QAAQ;CACRC,OAAO;CACPC,MAAM;CACNC,SAAS;CACTC,SAAS;CACTC,UAAU;CACVC,cAAc;CACdC,MAAM;CACNC,gBAAgB;CAChBC,UAAU;CACVC,QAAQ;CACRC,YAAY;CACZC,MAAM;CACV"}

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

@@ -0,0 +1,7 @@
+import { TypedToken } from "eldin";
+//#region src/app/modules/database/constants.ts
+const DatabaseInjectionKey = { DataSource: new TypedToken("DataSource") };
+//#endregion
+export { DatabaseInjectionKey };
+
+//# sourceMappingURL=constants.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.mjs","names":["TypedToken","DatabaseInjectionKey","DataSource"],"sources":["../../../../src/app/modules/database/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 type { DataSource } from 'typeorm';\nimport { TypedToken } from 'eldin';\n\nexport const DatabaseInjectionKey = { DataSource: new TypedToken<DataSource>('DataSource') } as const;\n"],"mappings":";;AAUA,MAAaC,uBAAuB,EAAEC,YAAY,IAAIF,WAAuB,aAAA,EAAc"}

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

@@ -0,0 +1,26 @@
+import { DatabaseInjectionKey } from "./constants.mjs";
+import { DatabaseModule } from "./module.mjs";
+import { RealmRepositoryAdapter } from "./repositories/realm/repository.mjs";
+import { ClientRepositoryAdapter } from "./repositories/client/repository.mjs";
+import { ClientPermissionRepositoryAdapter } from "./repositories/client-permission/repository.mjs";
+import { ClientRoleRepositoryAdapter } from "./repositories/client-role/repository.mjs";
+import { ClientScopeRepositoryAdapter } from "./repositories/client-scope/repository.mjs";
+import { IdentityProviderRepositoryAdapter } from "./repositories/identity-provider/repository.mjs";
+import { PermissionRepositoryAdapter } from "./repositories/permission/repository.mjs";
+import { PermissionPolicyRepositoryAdapter } from "./repositories/permission-policy/repository.mjs";
+import { PermissionDatabaseProvider } from "./repositories/permission-provider/module.mjs";
+import { PolicyRepositoryAdapter } from "./repositories/policy/repository.mjs";
+import { RobotRepositoryAdapter } from "./repositories/robot/repository.mjs";
+import { RobotPermissionRepositoryAdapter } from "./repositories/robot-permission/repository.mjs";
+import { RobotRoleRepositoryAdapter } from "./repositories/robot-role/repository.mjs";
+import { RoleRepositoryAdapter } from "./repositories/role/repository.mjs";
+import { RoleAttributeRepositoryAdapter } from "./repositories/role-attribute/repository.mjs";
+import { RolePermissionRepositoryAdapter } from "./repositories/role-permission/repository.mjs";
+import { ScopeRepositoryAdapter } from "./repositories/scope/repository.mjs";
+import { UserRepositoryAdapter } from "./repositories/user/repository.mjs";
+import { UserAttributeRepositoryAdapter } from "./repositories/user-attribute/repository.mjs";
+import { UserPermissionRepositoryAdapter } from "./repositories/user-permission/repository.mjs";
+import { UserRoleRepositoryAdapter } from "./repositories/user-role/repository.mjs";
+import { IdentityProviderRoleMappingRepositoryAdapter } from "./repositories/identity-provider-role-mapping/repository.mjs";
+import "./repositories/index.mjs";
+export { ClientPermissionRepositoryAdapter, ClientRepositoryAdapter, ClientRoleRepositoryAdapter, ClientScopeRepositoryAdapter, DatabaseInjectionKey, DatabaseModule, IdentityProviderRepositoryAdapter, IdentityProviderRoleMappingRepositoryAdapter, PermissionDatabaseProvider, PermissionPolicyRepositoryAdapter, PermissionRepositoryAdapter, PolicyRepositoryAdapter, RealmRepositoryAdapter, RobotPermissionRepositoryAdapter, RobotRepositoryAdapter, RobotRoleRepositoryAdapter, RoleAttributeRepositoryAdapter, RolePermissionRepositoryAdapter, RoleRepositoryAdapter, ScopeRepositoryAdapter, UserAttributeRepositoryAdapter, UserPermissionRepositoryAdapter, UserRepositoryAdapter, UserRoleRepositoryAdapter };

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

@@ -0,0 +1,116 @@
+import { setDomainEventPublisher } from "../../../adapters/database/event-publisher/module.mjs";
+import "../../../adapters/database/event-publisher/index.mjs";
+import { CacheInjectionKey } from "../cache/constants.mjs";
+import { ModuleName } from "../constants.mjs";
+import { ConfigInjectionKey } from "../config/constants.mjs";
+import "../config/index.mjs";
+import "../cache/index.mjs";
+import { DatabaseInjectionKey } from "./constants.mjs";
+import { DatabaseQueryResultCache } from "../../../adapters/database/cache/module.mjs";
+import { DataSourceOptionsBuilder } from "../../../adapters/database/data-source/options/module.mjs";
+import { setDataSourceSync, unsetDataSourceSync } from "../../../adapters/database/data-source/singleton.mjs";
+import { isDatabaseTypeSupported, isDatabaseTypeSupportedForEnvironment } from "../../../adapters/database/helpers/is-supported.mjs";
+import "../../../adapters/database/index.mjs";
+import { LoggerInjectionKey } from "../logger/constants.mjs";
+import "../logger/index.mjs";
+import { DataSource, InstanceChecker } from "typeorm";
+import { DomainEventPublisher, DomainEventRedisPublisher, DomainEventSocketPublisher, createRedisClient } from "@authup/server-kit";
+import { AuthupError } from "@authup/errors";
+import { checkDatabase, createDatabase, setDataSource, synchronizeDatabaseSchema, unsetDataSource } from "typeorm-extension";
+//#region src/app/modules/database/module.ts
+var DatabaseModule = class {
+	name;
+	dependencies;
+	optionsBuilder;
+	options;
+	constructor(options = {}) {
+		this.name = ModuleName.DATABASE;
+		this.dependencies = [ModuleName.CONFIG, ModuleName.LOGGER];
+		this.optionsBuilder = new DataSourceOptionsBuilder();
+		this.options = options;
+	}
+	async setup(container) {
+		const logger = container.resolve(LoggerInjectionKey);
+		if (this.options.prepareBuild) await this.options.prepareBuild(container);
+		const dataSourceOptions = await this.buildDataSourceOptions(container);
+		if (this.options.setup) await this.options.setup(container, dataSourceOptions);
+		else await this.setupDatabase(container, dataSourceOptions);
+		const dataSource = new DataSource(dataSourceOptions);
+		logger.debug("Establishing database connection...");
+		await dataSource.initialize();
+		logger.debug("Established database connection.");
+		setDataSource(dataSource);
+		setDataSourceSync(dataSource);
+		if (this.options.migrate) await this.options.migrate(container, dataSource);
+		else await this.migrate(container, dataSource);
+		container.register(DatabaseInjectionKey.DataSource, { useValue: dataSource });
+		this.registerRepositories(container, dataSource);
+		this.registerEventPublisher(container);
+	}
+	async teardown(container) {
+		const dataSource = container.tryResolve(DatabaseInjectionKey.DataSource);
+		if (dataSource.success) {
+			await dataSource.data.destroy();
+			container.unregister(DatabaseInjectionKey.DataSource);
+		}
+		unsetDataSource();
+		unsetDataSourceSync();
+	}
+	async setupDatabase(container, options) {
+		const logger = container.resolve(LoggerInjectionKey);
+		if (!(await checkDatabase({ options })).exists) {
+			logger.debug("Creating database...");
+			await createDatabase({
+				options,
+				synchronize: false,
+				ifNotExist: true
+			});
+			logger.debug("Created database");
+		}
+	}
+	async migrate(container, dataSource) {
+		const logger = container.resolve(LoggerInjectionKey);
+		logger.debug("Migrating database...");
+		await synchronizeDatabaseSchema(dataSource);
+		logger.debug("Migrated database");
+	}
+	/**
+	* Load data source options for connection.
+	*
+	* @protected
+	*/ async buildDataSourceOptions(container) {
+		const config = container.resolve(ConfigInjectionKey);
+		let options;
+		if (config.db) options = this.optionsBuilder.buildWith(config.db);
+		else options = this.optionsBuilder.buildWithEnv();
+		if (!isDatabaseTypeSupported(options.type)) throw new AuthupError(`Database type ${options.type} is not supported (only: mysql, better-sqlite3 and postgres).`);
+		if (!isDatabaseTypeSupportedForEnvironment(options.type, config.env)) throw new AuthupError(`Database type ${options.type} is not supported for ${config.env}.`);
+		const cacheResult = container.tryResolve(CacheInjectionKey);
+		if (cacheResult.success) Object.assign(options, { cache: { provider() {
+			return new DatabaseQueryResultCache(cacheResult.data);
+		} } });
+		return options;
+	}
+	registerRepositories(container, dataSource) {
+		const entities = dataSource.options.entities || [];
+		if (!Array.isArray(entities)) return;
+		for (const entity of entities) {
+			if (InstanceChecker.isEntitySchema(entity)) continue;
+			container.register(entity, { useFactory: () => dataSource.getRepository(entity) });
+		}
+	}
+	registerEventPublisher(container) {
+		const config = container.resolve(ConfigInjectionKey);
+		const publisher = new DomainEventPublisher();
+		if (config.redis) {
+			const client = createRedisClient(config.redis);
+			publisher.mount(new DomainEventRedisPublisher(client));
+			publisher.mount(new DomainEventSocketPublisher(client));
+		}
+		setDomainEventPublisher(publisher);
+	}
+};
+//#endregion
+export { DatabaseModule };
+
+//# sourceMappingURL=module.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"module.mjs","names":["DomainEventPublisher","DomainEventRedisPublisher","DomainEventSocketPublisher","createRedisClient","AuthupError","DataSource","InstanceChecker","checkDatabase","createDatabase","setDataSource","synchronizeDatabaseSchema","unsetDataSource","DataSourceOptionsBuilder","DatabaseQueryResultCache","isDatabaseTypeSupported","isDatabaseTypeSupportedForEnvironment","setDataSourceSync","unsetDataSourceSync","setDomainEventPublisher","CacheInjectionKey","ModuleName","DatabaseInjectionKey","ConfigInjectionKey","LoggerInjectionKey","DatabaseModule","name","dependencies","optionsBuilder","options","DATABASE","CONFIG","LOGGER","setup","container","logger","resolve","prepareBuild","dataSourceOptions","buildDataSourceOptions","setupDatabase","dataSource","debug","initialize","migrate","register","useValue","registerRepositories","registerEventPublisher","teardown","tryResolve","success","data","destroy","unregister","check","exists","synchronize","ifNotExist","config","db","buildWith","buildWithEnv","type","env","cacheResult","Object","assign","cache","provider","entities","Array","isArray","entity","isEntitySchema","useFactory","getRepository","publisher","redis","client","mount"],"sources":["../../../../src/app/modules/database/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 {\n    DomainEventPublisher, \n    DomainEventRedisPublisher,\n    DomainEventSocketPublisher, \n    createRedisClient,\n} from '@authup/server-kit';\nimport { AuthupError } from '@authup/errors';\nimport type { DataSourceOptions } from 'typeorm';\nimport { DataSource, InstanceChecker } from 'typeorm';\nimport {\n    checkDatabase,\n    createDatabase,\n    setDataSource,\n    synchronizeDatabaseSchema,\n    unsetDataSource,\n} from 'typeorm-extension';\nimport {\n    DataSourceOptionsBuilder,\n    DatabaseQueryResultCache,\n    isDatabaseTypeSupported,\n    isDatabaseTypeSupportedForEnvironment,\n    setDataSourceSync,\n    unsetDataSourceSync,\n} from '../../../adapters/database/index.ts';\nimport { setDomainEventPublisher } from '../../../adapters/database/event-publisher/index.ts';\nimport { CacheInjectionKey } from '../cache/index.ts';\nimport type { IModule } from 'orkos';\nimport { ModuleName } from '../constants.ts';\nimport { DatabaseInjectionKey } from './constants.ts';\nimport { ConfigInjectionKey } from '../config/index.ts';\nimport type { IContainer } from 'eldin';\nimport { LoggerInjectionKey } from '../logger/index.ts';\n\nexport type DatabaseModuleOptions = {\n    prepareBuild?: (container: IContainer) => Promise<void>;\n    setup?: (container: IContainer, options: DataSourceOptions) => Promise<void>;\n    migrate?: (container: IContainer, dataSource: DataSource) => Promise<void>;\n};\n\nexport class DatabaseModule implements IModule {\n    readonly name: string;\n\n    readonly dependencies: string[];\n\n    protected optionsBuilder : DataSourceOptionsBuilder;\n\n    protected options: DatabaseModuleOptions;\n\n    constructor(options: DatabaseModuleOptions = {}) {\n        this.name = ModuleName.DATABASE;\n        this.dependencies = [ModuleName.CONFIG, ModuleName.LOGGER];\n\n        this.optionsBuilder = new DataSourceOptionsBuilder();\n        this.options = options;\n    }\n\n    async setup(container: IContainer): Promise<void> {\n        const logger = container.resolve(LoggerInjectionKey);\n\n        if (this.options.prepareBuild) {\n            await this.options.prepareBuild(container);\n        }\n\n        const dataSourceOptions = await this.buildDataSourceOptions(container);\n\n        if (this.options.setup) {\n            await this.options.setup(container, dataSourceOptions);\n        } else {\n            await this.setupDatabase(container, dataSourceOptions);\n        }\n\n        const dataSource = new DataSource(dataSourceOptions);\n\n        logger.debug('Establishing database connection...');\n        await dataSource.initialize();\n        logger.debug('Established database connection.');\n\n        // todo: maybe remove this\n        setDataSource(dataSource);\n        setDataSourceSync(dataSource);\n\n        if (this.options.migrate) {\n            await this.options.migrate(container, dataSource);\n        } else {\n            await this.migrate(container, dataSource);\n        }\n\n        container.register(DatabaseInjectionKey.DataSource, { useValue: dataSource });\n\n        this.registerRepositories(container, dataSource);\n        this.registerEventPublisher(container);\n    }\n\n    async teardown(container: IContainer): Promise<void> {\n        const dataSource = container.tryResolve(DatabaseInjectionKey.DataSource);\n        if (dataSource.success) {\n            await dataSource.data.destroy();\n\n            container.unregister(DatabaseInjectionKey.DataSource);\n        }\n\n        unsetDataSource();\n        unsetDataSourceSync();\n    }\n\n    // ----------------------------------------------------\n\n    protected async setupDatabase(container: IContainer, options: DataSourceOptions): Promise<void> {\n        const logger = container.resolve(LoggerInjectionKey);\n\n        const check = await checkDatabase({ options });\n\n        if (!check.exists) {\n            logger.debug('Creating database...');\n            await createDatabase({\n                options,\n                synchronize: false,\n                ifNotExist: true, \n            });\n            logger.debug('Created database');\n        }\n    }\n\n    protected async migrate(container: IContainer, dataSource: DataSource): Promise<void> {\n        const logger = container.resolve(LoggerInjectionKey);\n\n        logger.debug('Migrating database...');\n        await synchronizeDatabaseSchema(dataSource);\n        logger.debug('Migrated database');\n    }\n\n    // ----------------------------------------------------\n\n    /**\n     * Load data source options for connection.\n     *\n     * @protected\n     */\n    protected async buildDataSourceOptions(container: IContainer) : Promise<DataSourceOptions> {\n        const config = container.resolve(ConfigInjectionKey);\n\n        let options : DataSourceOptions | undefined;\n        if (config.db) {\n            options = this.optionsBuilder.buildWith(config.db);\n        } else {\n            options = this.optionsBuilder.buildWithEnv();\n        }\n\n        if (!isDatabaseTypeSupported(options.type)) {\n            throw new AuthupError(`Database type ${options.type} is not supported (only: mysql, better-sqlite3 and postgres).`);\n        }\n\n        if (!isDatabaseTypeSupportedForEnvironment(options.type, config.env)) {\n            throw new AuthupError(`Database type ${options.type} is not supported for ${config.env}.`);\n        }\n\n        const cacheResult = container.tryResolve(CacheInjectionKey);\n        if (cacheResult.success) {\n            Object.assign(options, {\n                cache: {\n                    provider() {\n                        return new DatabaseQueryResultCache(cacheResult.data);\n                    },\n                },\n            } satisfies Partial<DataSourceOptions>);\n        }\n\n        return options;\n    }\n\n    protected registerRepositories(container: IContainer, dataSource: DataSource) : void {\n        const entities = dataSource.options.entities || [];\n        if (!Array.isArray(entities)) {\n            return;\n        }\n\n        for (const entity of entities) {\n            if (InstanceChecker.isEntitySchema(entity)) {\n                continue;\n            }\n\n            // eslint-disable-next-line @typescript-eslint/ban-ts-comment\n            // @ts-expect-error\n            container.register(entity, { useFactory: () => dataSource.getRepository(entity) });\n        }\n    }\n\n    // todo: move, wrong place\n    protected registerEventPublisher(container: IContainer) {\n        const config = container.resolve(ConfigInjectionKey);\n\n        const publisher = new DomainEventPublisher();\n        if (config.redis) {\n            const client = createRedisClient(config.redis);\n\n            publisher.mount(new DomainEventRedisPublisher(client));\n            publisher.mount(new DomainEventSocketPublisher(client));\n        }\n\n        setDomainEventPublisher(publisher);\n    }\n}\n"],"mappings":"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"}

package/dist/app/modules/database/repositories/client/index.mjs

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

package/dist/app/modules/database/repositories/client/repository.mjs

@@ -0,0 +1,131 @@
+import { ClientEntity } from "../../../../../adapters/database/domains/client/entity.mjs";
+import "../../../../../adapters/database/domains/index.mjs";
+import { DatabaseConflictError } from "../../../../../adapters/database/errors/conflict.mjs";
+import "../../../../../adapters/database/index.mjs";
+import { translateWhereConditions } from "../helpers.mjs";
+import { RealmRepositoryAdapter } from "../realm/repository.mjs";
+import { isUUID } from "@authup/kit";
+import { applyQuery, isEntityUnique, validateEntityJoinColumns } from "typeorm-extension";
+//#region src/app/modules/database/repositories/client/repository.ts
+var ClientRepositoryAdapter = class {
+	repository;
+	realmRepository;
+	constructor(ctx) {
+		this.repository = ctx.repository;
+		this.realmRepository = new RealmRepositoryAdapter(ctx.realmRepository);
+	}
+	async findMany(query) {
+		const qb = this.repository.createQueryBuilder("client");
+		qb.groupBy("client.id");
+		const { pagination } = applyQuery(qb, query, {
+			defaultAlias: "client",
+			fields: {
+				default: [
+					"id",
+					"active",
+					"built_in",
+					"name",
+					"display_name",
+					"description",
+					"secret_hashed",
+					"secret_encrypted",
+					"base_url",
+					"root_url",
+					"redirect_uri",
+					"grant_types",
+					"scope",
+					"is_confidential",
+					"realm_id",
+					"updated_at",
+					"created_at"
+				],
+				allowed: ["secret"]
+			},
+			filters: { allowed: [
+				"id",
+				"name",
+				"realm_id",
+				"realm.name"
+			] },
+			pagination: { maxLimit: 50 },
+			relations: {
+				allowed: ["realm"],
+				onJoin: (_property, key, q) => {
+					q.addGroupBy(`${key}.id`);
+				}
+			},
+			sort: { allowed: [
+				"id",
+				"created_at",
+				"updated_at"
+			] }
+		});
+		const [entities, total] = await qb.getManyAndCount();
+		return {
+			data: entities,
+			meta: {
+				total,
+				...pagination
+			}
+		};
+	}
+	findOneById(id) {
+		return this.findOneBy({ id });
+	}
+	async findOneByName(name, realmKey) {
+		const qb = this.repository.createQueryBuilder("client");
+		qb.where("client.name LIKE :name", { name });
+		if (realmKey) {
+			const realm = await this.realmRepository.resolve(realmKey);
+			if (realm) qb.andWhere("client.realm_id = :realmId", { realmId: realm.id });
+		}
+		return qb.getOne();
+	}
+	async findOneByIdOrName(idOrName, realm) {
+		return isUUID(idOrName) ? this.findOneById(idOrName) : this.findOneByName(idOrName, realm);
+	}
+	async findManyBy(where) {
+		return this.repository.findBy(translateWhereConditions(where));
+	}
+	async findOneBy(where) {
+		return this.repository.findOneBy(translateWhereConditions(where));
+	}
+	async findOneWithSecret(where) {
+		const qb = this.repository.createQueryBuilder("client");
+		Object.entries(where).forEach(([key, value]) => {
+			qb.andWhere(`client.${key} = :${key}`, { [key]: value });
+		});
+		qb.addSelect("client.secret");
+		return qb.getOne();
+	}
+	create(data) {
+		return this.repository.create(data);
+	}
+	merge(entity, data) {
+		return this.repository.merge(entity, data);
+	}
+	async save(entity) {
+		return this.repository.save(entity);
+	}
+	async remove(entity) {
+		await this.repository.remove(entity);
+	}
+	async validateJoinColumns(data) {
+		await validateEntityJoinColumns(data, {
+			dataSource: this.repository.manager.connection,
+			entityTarget: ClientEntity
+		});
+	}
+	async checkUniqueness(data, existing) {
+		if (!await isEntityUnique({
+			dataSource: this.repository.manager.connection,
+			entityTarget: ClientEntity,
+			entity: data,
+			entityExisting: existing
+		})) throw new DatabaseConflictError();
+	}
+};
+//#endregion
+export { ClientRepositoryAdapter };
+
+//# sourceMappingURL=repository.mjs.map

package/dist/app/modules/database/repositories/client/repository.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"repository.mjs","names":["isUUID","applyQuery","isEntityUnique","validateEntityJoinColumns","DatabaseConflictError","translateWhereConditions","ClientEntity","RealmRepositoryAdapter","ClientRepositoryAdapter","repository","realmRepository","ctx","findMany","query","qb","createQueryBuilder","groupBy","pagination","defaultAlias","fields","default","allowed","filters","maxLimit","relations","onJoin","_property","key","q","addGroupBy","sort","entities","total","getManyAndCount","data","meta","findOneById","id","findOneBy","findOneByName","name","realmKey","where","realm","resolve","andWhere","realmId","getOne","findOneByIdOrName","idOrName","findManyBy","findBy","findOneWithSecret","Object","entries","forEach","value","addSelect","create","merge","entity","save","remove","validateJoinColumns","dataSource","manager","connection","entityTarget","checkUniqueness","existing","isUnique","entityExisting"],"sources":["../../../../../../src/app/modules/database/repositories/client/repository.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 { Client, Realm } from '@authup/core-kit';\nimport { isUUID } from '@authup/kit';\nimport type { Repository } from 'typeorm';\nimport { applyQuery, isEntityUnique, validateEntityJoinColumns } from 'typeorm-extension';\nimport type { EntityRepositoryFindManyResult, IClientRepository, IRealmRepository } from '../../../../../core/index.ts';\nimport { DatabaseConflictError } from '../../../../../adapters/database/index.ts';\nimport { translateWhereConditions } from '../helpers.ts';\nimport { ClientEntity } from '../../../../../adapters/database/domains/index.ts';\nimport { RealmRepositoryAdapter } from '../realm/repository.ts';\n\nexport type ClientRepositoryAdapterContext = {\n    repository: Repository<Client>,\n    realmRepository: Repository<Realm>,\n};\n\nexport class ClientRepositoryAdapter implements IClientRepository {\n    private readonly repository: Repository<Client>;\n\n    private readonly realmRepository: IRealmRepository;\n\n    constructor(ctx: ClientRepositoryAdapterContext) {\n        this.repository = ctx.repository;\n        this.realmRepository = new RealmRepositoryAdapter(ctx.realmRepository);\n    }\n\n    async findMany(query: Record<string, any>): Promise<EntityRepositoryFindManyResult<Client>> {\n        const qb = this.repository.createQueryBuilder('client');\n        qb.groupBy('client.id');\n\n        const { pagination } = applyQuery(qb, query, {\n            defaultAlias: 'client',\n            fields: {\n                default: [\n                    'id',\n                    'active',\n                    'built_in',\n                    'name',\n                    'display_name',\n                    'description',\n                    'secret_hashed',\n                    'secret_encrypted',\n                    'base_url',\n                    'root_url',\n                    'redirect_uri',\n                    'grant_types',\n                    'scope',\n                    'is_confidential',\n                    'realm_id',\n                    'updated_at',\n                    'created_at',\n                ],\n                allowed: ['secret'],\n            },\n            filters: { allowed: ['id', 'name', 'realm_id', 'realm.name'] },\n            pagination: { maxLimit: 50 },\n            relations: {\n                allowed: ['realm'],\n                onJoin: (_property: string, key: string, q: any) => {\n                    q.addGroupBy(`${key}.id`);\n                },\n            },\n            sort: { allowed: ['id', 'created_at', 'updated_at'] },\n        });\n\n        const [entities, total] = await qb.getManyAndCount();\n\n        return {\n            data: entities,\n            meta: {\n                total,\n                ...pagination,\n            },\n        };\n    }\n\n    findOneById(id: string): Promise<Client | null> {\n        return this.findOneBy({ id });\n    }\n\n    async findOneByName(name: string, realmKey?: string): Promise<Client | null> {\n        const qb = this.repository.createQueryBuilder('client');\n        qb.where('client.name LIKE :name', { name });\n\n        if (realmKey) {\n            const realm = await this.realmRepository.resolve(realmKey);\n            if (realm) {\n                qb.andWhere('client.realm_id = :realmId', { realmId: realm.id });\n            }\n        }\n\n        return qb.getOne();\n    }\n\n    async findOneByIdOrName(idOrName: string, realm?: string): Promise<Client | null> {\n        return isUUID(idOrName) ?\n            this.findOneById(idOrName) :\n            this.findOneByName(idOrName, realm);\n    }\n\n    async findManyBy(where: Record<string, any>): Promise<Client[]> {\n        return this.repository.findBy(translateWhereConditions(where));\n    }\n\n    async findOneBy(where: Record<string, any>): Promise<Client | null> {\n        return this.repository.findOneBy(translateWhereConditions(where));\n    }\n\n    async findOneWithSecret(where: Record<string, any>): Promise<Client | null> {\n        const qb = this.repository.createQueryBuilder('client');\n\n        Object.entries(where).forEach(([key, value]) => {\n            qb.andWhere(`client.${key} = :${key}`, { [key]: value });\n        });\n\n        qb.addSelect('client.secret');\n\n        return qb.getOne();\n    }\n\n    create(data: Partial<Client>): Client {\n        return this.repository.create(data);\n    }\n\n    merge(entity: Client, data: Partial<Client>): Client {\n        return this.repository.merge(entity, data);\n    }\n\n    async save(entity: Client): Promise<Client> {\n        return this.repository.save(entity);\n    }\n\n    async remove(entity: Client): Promise<void> {\n        await this.repository.remove(entity);\n    }\n\n    async validateJoinColumns(data: Partial<Client>): Promise<void> {\n        await validateEntityJoinColumns(data, {\n            dataSource: this.repository.manager.connection,\n            entityTarget: ClientEntity,\n        });\n    }\n\n    async checkUniqueness(data: Partial<Client>, existing?: Client): Promise<void> {\n        const isUnique = await isEntityUnique({\n            dataSource: this.repository.manager.connection,\n            entityTarget: ClientEntity,\n            entity: data,\n            entityExisting: existing,\n        });\n\n        if (!isUnique) {\n            throw new DatabaseConflictError();\n        }\n    }\n}\n"],"mappings":"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"}

package/dist/app/modules/database/repositories/client-permission/index.mjs

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

package/dist/app/modules/database/repositories/client-permission/repository.mjs

@@ -0,0 +1,76 @@
+import { ClientPermissionEntity } from "../../../../../adapters/database/domains/client-permission/entity.mjs";
+import "../../../../../adapters/database/domains/index.mjs";
+import { translateWhereConditions } from "../helpers.mjs";
+import { applyQuery, validateEntityJoinColumns } from "typeorm-extension";
+//#region src/app/modules/database/repositories/client-permission/repository.ts
+var ClientPermissionRepositoryAdapter = class {
+	repository;
+	constructor(repository) {
+		this.repository = repository;
+	}
+	async findMany(query) {
+		const qb = this.repository.createQueryBuilder("clientPermission");
+		qb.groupBy("clientPermission.id");
+		const { pagination } = applyQuery(qb, query, {
+			defaultAlias: "clientPermission",
+			filters: { allowed: ["client_id", "permission_id"] },
+			relations: {
+				allowed: ["client", "permission"],
+				onJoin: (_property, key, q) => {
+					q.addGroupBy(`${key}.id`);
+				}
+			},
+			sort: { allowed: [
+				"id",
+				"created_at",
+				"updated_at"
+			] },
+			pagination: { maxLimit: 50 }
+		});
+		const [entities, total] = await qb.getManyAndCount();
+		return {
+			data: entities,
+			meta: {
+				total,
+				...pagination
+			}
+		};
+	}
+	findOneById(id) {
+		return this.findOneBy({ id });
+	}
+	findOneByName(_name) {
+		return Promise.resolve(null);
+	}
+	findOneByIdOrName(idOrName) {
+		return this.findOneById(idOrName);
+	}
+	async findManyBy(where) {
+		return this.repository.findBy(translateWhereConditions(where));
+	}
+	async findOneBy(where) {
+		return this.repository.findOneBy(translateWhereConditions(where));
+	}
+	create(data) {
+		return this.repository.create(data);
+	}
+	merge(entity, data) {
+		return this.repository.merge(entity, data);
+	}
+	async save(entity) {
+		return this.repository.save(entity);
+	}
+	async remove(entity) {
+		await this.repository.remove(entity);
+	}
+	async validateJoinColumns(data) {
+		await validateEntityJoinColumns(data, {
+			dataSource: this.repository.manager.connection,
+			entityTarget: ClientPermissionEntity
+		});
+	}
+};
+//#endregion
+export { ClientPermissionRepositoryAdapter };
+
+//# sourceMappingURL=repository.mjs.map