@tstdl/base 0.93.78 → 0.93.81

package/document-management/server/drizzle/meta/_journal.json

@@ -5,22 +5,8 @@
     {
       "idx": 0,
       "version": "7",
-      "when": 1750253838549,
-      "tag": "0000_ordinary_pretty_boy",
-      "breakpoints": true
-    },
-    {
-      "idx": 1,
-      "version": "7",
-      "when": 1764857079867,
-      "tag": "0001_lyrical_wong",
-      "breakpoints": true
-    },
-    {
-      "idx": 2,
-      "version": "7",
-      "when": 1767824153882,
-      "tag": "0002_round_warbird",
+      "when": 1767826943882,
+      "tag": "0000_glamorous_lorna_dane",
       "breakpoints": true
     }
   ]

package/examples/api/authentication.js

@@ -17,7 +17,8 @@ import { timeout } from '../../utils/timing.js';
 import { Agent } from 'undici';
 async function serverTest() {
     const authenticationService = await injectAsync(AuthenticationServerService);
-    await authenticationService.setCredentials('foobar', 'mysuperdupersecret-fvhc54w');
+    const subject = await authenticationService.resolveSubject({ subject: 'foobar' });
+    await authenticationService.setCredentials(subject, 'mysuperdupersecret-fvhc54w');
 }
 async function clientTest() {
     const authenticationService = inject(AuthenticationClientService);
@@ -25,7 +26,7 @@ async function clientTest() {
     await timeout(250); // allow server to initialize
     const passwordCheckResult = await authenticationService.checkSecret('123456');
     console.log({ 'password check for "123456"': passwordCheckResult });
-    await authenticationService.login('foobar', 'mysuperdupersecret-fvhc54w');
+    await authenticationService.login({ subject: 'foobar' }, 'mysuperdupersecret-fvhc54w');
     authenticationService.token$.subscribe((token) => console.log({ token }));
 }
 async function test() {

package/examples/api/custom-authentication.js

@@ -18,7 +18,7 @@ import { AuthenticationAncillaryService, AuthenticationApiController, Authentica
 import { configureUndiciHttpClientAdapter } from '../../http/client/adapters/undici.adapter.js';
 import { configureHttpClient } from '../../http/client/module.js';
 import { configureNodeHttpServer } from '../../http/server/node/module.js';
-import { Singleton } from '../../injector/decorators.js';
+import { Singleton } from '../../injector/index.js';
 import { inject, injectAsync } from '../../injector/inject.js';
 import { configureLocalMessageBus } from '../../message-bus/local/module.js';
 import { WebServerModule } from '../../module/modules/index.js';
@@ -65,17 +65,18 @@ __decorate([
 ], AuthenticationData.prototype, "deviceId", void 0);
 const CustomAuthenticationApiClient = getAuthenticationApiClient(CustomTokenPaylod, AuthenticationData, emptyObjectSchema);
 let CustomAuthenticationAncillaryService = class CustomAuthenticationAncillaryService extends AuthenticationAncillaryService {
-    getTokenPayload(_subject, authenticationData) {
+    getTokenPayload(_subject, authenticationData, _context) {
         return { deviceRegistrationId: `registration:${authenticationData.deviceId}` };
     }
-    resolveSubject() {
-        throw new Error('Method not implemented.');
+    async resolveSubjects(data) {
+        const subjects = await this.subjectRepository.loadManyByQuery({ id: data.subject });
+        return subjects;
     }
-    handleInitSecretReset() {
+    canImpersonate(_token, _subject, _authenticationData) {
         throw new Error('Method not implemented.');
     }
-    canImpersonate() {
-        throw new Error('Method not implemented.');
+    handleInitSecretReset() {
+        // send mail
     }
 };
 CustomAuthenticationAncillaryService = __decorate([
@@ -83,13 +84,14 @@ CustomAuthenticationAncillaryService = __decorate([
 ], CustomAuthenticationAncillaryService);
 async function serverTest() {
     const authenticationService = await injectAsync(AuthenticationServerService);
-    await authenticationService.setCredentials('foobar', 'supersecret-dupidupudoo9275');
+    const subject = await authenticationService.resolveSubject({ subject: 'foobar' });
+    await authenticationService.setCredentials(subject, 'supersecret-dupidupudoo9275');
 }
 async function clientTest(application) {
     const authenticationService = inject(AuthenticationClientService);
     await timeout(1500); // allow server to initialize
     authenticationService.initialize();
-    await authenticationService.login('foobar', 'supersecret-dupidupudoo9275');
+    await authenticationService.login({ subject: 'foobar' }, 'supersecret-dupidupudoo9275');
     authenticationService.token$.subscribe((token) => console.log({ token }));
     application.requestShutdown();
 }

package/orm/server/drizzle/schema-converter.js

@@ -33,19 +33,10 @@ export function getColumnDefinitionsMap(table) {
     return table[columnDefinitionsMapSymbol];
 }
 export function _getDrizzleTableFromType(type, fallbackSchemaName) {
-    const metadata = reflectionRegistry.getMetadata(type);
-    assertDefined(metadata, `Type ${type.name} does not have reflection metadata.`);
-    const tableReflectionDatas = [];
-    for (let currentMetadata = metadata; isNotNullOrUndefined(currentMetadata?.parent); currentMetadata = reflectionRegistry.getMetadata(currentMetadata.parent)) {
-        const tableReflectionData = currentMetadata.data.tryGet('orm');
-        if (isDefined(tableReflectionData)) {
-            tableReflectionDatas.push(tableReflectionData);
-        }
-    }
+    const tableReflectionDatas = getTableReflectionDatas(type);
     const mergedTableReflectionData = tableReflectionDatas.reduceRight((merged, data) => ({ ...merged, ...data }), {});
-    const tableReflectionData = tableReflectionDatas[0];
     const schema = assertDefinedPass(mergedTableReflectionData.schema ?? fallbackSchemaName, 'Table schema not provided');
-    const tableName = tableReflectionData?.name ?? getDefaultTableName(type);
+    const tableName = getTableName(type);
     const dbSchema = getDbSchema(schema);
     const columnDefinitions = getPostgresColumnEntries(type, dbSchema, tableName);
     const columnDefinitionsMap = new Map(columnDefinitions.map((column) => [column.objectPath.path, column]));
@@ -194,7 +185,7 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
                     const foreignTable = getDrizzleTableFromType(tenantReferenceData.target(), dbSchema.schemaName);
                     const nonTenantColumn = tenantReferenceData.targetColumn ?? 'id';
                     return foreignKey({
-                        name: getForeignKeyName(tableName, [nonTenantColumn]),
+                        name: getForeignKeyName(tableName, getTableName(tenantReferenceData.target()), [nonTenantColumn]),
                         columns: [getColumn(table, 'tenantId'), getColumn(table, columnDefinition.name)],
                         foreignColumns: [getColumn(foreignTable, 'tenantId'), getColumn(foreignTable, nonTenantColumn)],
                     });
@@ -204,7 +195,7 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
                 return tableReflectionData.foreignKeys?.map((foreignKeyData) => {
                     const foreignTable = getDrizzleTableFromType(foreignKeyData.target(), dbSchema.schemaName);
                     return foreignKey({
-                        name: foreignKeyData.options?.name ?? getForeignKeyName(tableName, foreignKeyData.columns, { naming: foreignKeyData.options?.naming }),
+                        name: foreignKeyData.options?.name ?? getForeignKeyName(tableName, getTableName(foreignKeyData.target()), foreignKeyData.columns, { naming: foreignKeyData.options?.naming }),
                         columns: foreignKeyData.columns.map((column) => getColumn(table, column)),
                         foreignColumns: foreignKeyData.foreignColumns.map((column) => getColumn(foreignTable, column)),
                     });
@@ -227,6 +218,25 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
     drizzleSchema[columnDefinitionsMapSymbol] = columnDefinitionsMap;
     return drizzleSchema;
 }
+function unwrapSchema(schema) {
+    let nullable = false;
+    let array = false;
+    let currentSchema = schema;
+    while (true) {
+        if ((currentSchema instanceof NullableSchema) || (currentSchema instanceof OptionalSchema)) {
+            nullable = true;
+            currentSchema = currentSchema.schema;
+        }
+        else if (currentSchema instanceof ArraySchema) {
+            array = true;
+            currentSchema = currentSchema.itemSchema;
+        }
+        else {
+            break;
+        }
+    }
+    return { schema: currentSchema, nullable, array };
+}
 function getPostgresColumnEntries(type, dbSchema, tableName, path = new JsonPath({ dollar: false }), prefix = '') {
     const metadata = reflectionRegistry.getMetadata(type);
     assertDefined(metadata, `Type ${type.name} does not have reflection metadata (path: ${path.toString()}).`);
@@ -269,23 +279,8 @@ function getPostgresColumnEntries(type, dbSchema, tableName, path = new JsonPath
     return entries;
 }
 function getPostgresColumn(tableName, columnName, dbSchema, propertySchema, reflectionData, options, context) {
-    let nullable = false;
-    let array = false;
-    let baseSchema = propertySchema;
-    while (true) {
-        if ((baseSchema instanceof NullableSchema) || (baseSchema instanceof OptionalSchema)) {
-            nullable = true;
-            baseSchema = baseSchema.schema;
-        }
-        else if (baseSchema instanceof ArraySchema) {
-            array = true;
-            baseSchema = baseSchema.itemSchema;
-        }
-        else {
-            break;
-        }
-    }
-    let column = getPostgresBaseColumn(columnName, dbSchema, baseSchema, reflectionData, context);
+    const { schema, nullable, array } = unwrapSchema(propertySchema);
+    let column = getPostgresBaseColumn(columnName, dbSchema, schema, reflectionData, context);
     if (array) {
         column = column.array();
     }
@@ -371,8 +366,34 @@ function getIndexName(tableName, columnsOrBaseName, options) {
 function getUniqueName(tableName, columnsOrBaseName, options) {
     return getIdentifier(tableName, columnsOrBaseName, 'unique', options);
 }
-function getForeignKeyName(tableName, columnsOrBaseName, options) {
-    return getIdentifier(tableName, columnsOrBaseName, 'fkey', options);
+function getForeignKeyName(tableName, foreignTableName, columnsOrBaseName, options) {
+    const middle = isString(columnsOrBaseName) ? columnsOrBaseName : getColumnNames(columnsOrBaseName).join('_');
+    const identifier = `${getTablePrefix(tableName, options?.naming)}_${middle}_${getTablePrefix(foreignTableName, options?.naming)}_fkey`;
+    if (identifier.length > 63) {
+        if (options?.naming != 'abbreviated-table') {
+            return getForeignKeyName(tableName, foreignTableName, columnsOrBaseName, { naming: 'abbreviated-table' });
+        }
+        throw new Error(`Identifier "${identifier}" for table "${tableName}" is too long. Maximum length is 63 characters.`);
+    }
+    console.log(tableName, foreignTableName, columnsOrBaseName, 'Foreign key name:', identifier);
+    return identifier;
+}
+function getTableName(type) {
+    const tableReflectionDatas = getTableReflectionDatas(type);
+    const tableReflectionData = tableReflectionDatas[0];
+    return tableReflectionData?.name ?? getDefaultTableName(type);
+}
+function getTableReflectionDatas(type) {
+    const metadata = reflectionRegistry.getMetadata(type);
+    assertDefined(metadata, `Type ${type.name} does not have reflection metadata.`);
+    const tableReflectionDatas = [];
+    for (let currentMetadata = metadata; isNotNullOrUndefined(currentMetadata?.parent); currentMetadata = reflectionRegistry.getMetadata(currentMetadata.parent)) {
+        const tableReflectionData = currentMetadata.data.tryGet('orm');
+        if (isDefined(tableReflectionData)) {
+            tableReflectionDatas.push(tableReflectionData);
+        }
+    }
+    return tableReflectionDatas;
 }
 function getIdentifier(tableName, columnsOrBaseName, suffix, options) {
     const middle = isString(columnsOrBaseName) ? columnsOrBaseName : getColumnNames(columnsOrBaseName).join('_');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.93.78",
+  "version": "0.93.81",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"

package/authentication/server/drizzle/0000_calm_warlock.sql

@@ -1,28 +0,0 @@
-CREATE TABLE "authentication"."credentials" (
-	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
-	"subject" text NOT NULL,
-	"hash_version" integer NOT NULL,
-	"salt" "bytea" NOT NULL,
-	"hash" "bytea" NOT NULL,
-	"revision" integer NOT NULL,
-	"revision_timestamp" timestamp with time zone NOT NULL,
-	"create_timestamp" timestamp with time zone NOT NULL,
-	"delete_timestamp" timestamp with time zone,
-	"attributes" jsonb DEFAULT '{}'::jsonb NOT NULL,
-	CONSTRAINT "credentials_subject_unique" UNIQUE("subject")
-);
---> statement-breakpoint
-CREATE TABLE "authentication"."session" (
-	"id" uuid PRIMARY KEY DEFAULT gen_random_uuid() NOT NULL,
-	"subject" text NOT NULL,
-	"begin" timestamp with time zone NOT NULL,
-	"end" timestamp with time zone NOT NULL,
-	"refresh_token_hash_version" integer NOT NULL,
-	"refresh_token_salt" "bytea" NOT NULL,
-	"refresh_token_hash" "bytea" NOT NULL,
-	"revision" integer NOT NULL,
-	"revision_timestamp" timestamp with time zone NOT NULL,
-	"create_timestamp" timestamp with time zone NOT NULL,
-	"delete_timestamp" timestamp with time zone,
-	"attributes" jsonb DEFAULT '{}'::jsonb NOT NULL
-);