@tstdl/base 0.93.140 → 0.93.142

package/mail/module.d.ts

@@ -1,3 +1,4 @@
+import { Injector } from '../injector/injector.js';
 import { type DatabaseConfig } from '../orm/server/index.js';
 import type { Type } from '../types/index.js';
 import { MailClient, MailClientConfig } from './mail.client.js';
@@ -7,9 +8,12 @@ export declare class MailModuleConfig {
     defaultClientConfig?: MailClientConfig;
     client?: Type<MailClient>;
     defaultData?: DefaultMailData;
+    autoMigrate?: boolean;
 }
 /**
  * configure mail module
  */
-export declare function configureMail(config: MailModuleConfig): void;
+export declare function configureMail({ injector, ...config }: MailModuleConfig & {
+    injector?: Injector;
+}): void;
 export declare function migrateMailSchema(): Promise<void>;

package/mail/module.js

@@ -1,6 +1,6 @@
 import { inject } from '../injector/index.js';
 import { Injector } from '../injector/injector.js';
-import { Database, migrate } from '../orm/server/index.js';
+import { Database, migrate, registerDatabaseMigration } from '../orm/server/index.js';
 import { isDefined } from '../utils/type-guards.js';
 import { MailClient, MailClientConfig } from './mail.client.js';
 import { MAIL_DEFAULT_DATA } from './tokens.js';
@@ -9,20 +9,25 @@ export class MailModuleConfig {
     defaultClientConfig;
     client;
     defaultData;
+    autoMigrate;
 }
 /**
  * configure mail module
  */
-export function configureMail(config) {
-    Injector.register(MailModuleConfig, { useValue: config });
+export function configureMail({ injector, ...config }) {
+    const targetInjector = injector ?? Injector;
+    targetInjector.register(MailModuleConfig, { useValue: config });
     if (isDefined(config.defaultClientConfig)) {
-        Injector.registerSingleton(MailClientConfig, { useValue: config.defaultClientConfig });
+        targetInjector.registerSingleton(MailClientConfig, { useValue: config.defaultClientConfig });
     }
     if (isDefined(config.client)) {
-        Injector.registerSingleton(MailClient, { useToken: config.client });
+        targetInjector.registerSingleton(MailClient, { useToken: config.client });
     }
     if (isDefined(config.defaultData)) {
-        Injector.registerSingleton(MAIL_DEFAULT_DATA, { useValue: config.defaultData });
+        targetInjector.registerSingleton(MAIL_DEFAULT_DATA, { useValue: config.defaultData });
+    }
+    if (config.autoMigrate != false) {
+        registerDatabaseMigration('Mail', migrateMailSchema, { injector });
     }
 }
 export async function migrateMailSchema() {

package/module/modules/web-server.module.js

@@ -18,7 +18,7 @@ export class WebServerModuleConfiguration {
 }
 ;
 let WebServerModule = class WebServerModule extends Module {
-    config = inject(WebServerModuleConfiguration);
+    config = inject(WebServerModuleConfiguration, undefined, { optional: true });
     httpServer = inject(HttpServer);
     apiGateway = inject(ApiGateway);
     apiControllers = inject(API_CONTROLLERS);
@@ -37,7 +37,7 @@ let WebServerModule = class WebServerModule extends Module {
     }
     async _run(cancellationSignal) {
         this.initialize();
-        await this.httpServer.listen(this.config.port ?? 8000);
+        await this.httpServer.listen(this.config?.port ?? 8000);
         const closePromise = cancellationSignal.wait().then(async () => {
             await this.httpServer[Symbol.asyncDispose]();
         });
@@ -58,5 +58,4 @@ export { WebServerModule };
 export function configureWebServerModule({ injector, ...config } = {}) {
     const targetInjector = injector ?? Injector;
     targetInjector.register(WebServerModuleConfiguration, { useValue: config });
-    targetInjector.registerSingleton(WebServerModule, { useClass: WebServerModule });
 }

package/notification/server/module.d.ts

@@ -11,6 +11,7 @@ export declare class NotificationConfiguration {
      * Defaults to 30 days.
      */
     autoArchiveAfter?: number;
+    autoMigrate?: boolean;
 }
 export declare function configureNotification({ injector, ...config }: NotificationConfiguration & {
     injector?: Injector;

package/notification/server/module.js

@@ -1,5 +1,5 @@
 import { inject, Injector } from '../../injector/index.js';
-import { Database, migrate } from '../../orm/server/index.js';
+import { Database, migrate, registerDatabaseMigration } from '../../orm/server/index.js';
 import { isDefined } from '../../utils/type-guards.js';
 import { NotificationAncillaryService } from './services/notification-ancillary.service.js';
 export class NotificationConfiguration {
@@ -11,6 +11,7 @@ export class NotificationConfiguration {
      * Defaults to 30 days.
      */
     autoArchiveAfter;
+    autoMigrate;
 }
 export function configureNotification({ injector, ...config }) {
     const targetInjector = injector ?? Injector;
@@ -18,6 +19,9 @@ export function configureNotification({ injector, ...config }) {
     if (isDefined(config.ancillaryService)) {
         targetInjector.register(NotificationAncillaryService, { useToken: config.ancillaryService });
     }
+    if (config.autoMigrate != false) {
+        registerDatabaseMigration('Notification', migrateNotificationSchema, { injector });
+    }
 }
 /**
  * Migrates the notification schema.

package/notification/tests/notification-api.test.js

@@ -1,5 +1,5 @@
 import { Subject } from 'rxjs';
-import { beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
+import { afterEach, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
 import { SubjectService } from '../../authentication/server/subject.service.js';
 import { clearTenantData, setupIntegrationTest } from '../../testing/index.js';
 import { NotificationChannel } from '../models/index.js';
@@ -44,6 +44,10 @@ describe('Notification API (Integration)', () => {
     beforeEach(() => {
         vi.clearAllMocks();
     });
+    afterEach(async () => {
+        await clearTenantData(database, schema, ['in_app', 'in_app_archive', 'log', 'preference', 'web_push_subscription'], tenantId);
+        await clearTenantData(database, 'authentication', ['user', 'subject'], tenantId);
+    });
     const createMockContext = (params = {}) => ({
         parameters: params,
         abortSignal: new AbortController().signal,

package/notification/tests/notification-flow.test.js

@@ -4,12 +4,12 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
+import { afterEach, beforeAll, beforeEach, describe, expect, test, vi } from 'vitest';
 import { SubjectService } from '../../authentication/server/subject.service.js';
 import { runInInjectionContext, Singleton } from '../../injector/index.js';
 import { MailService } from '../../mail/mail.service.js';
 import { injectRepository } from '../../orm/server/index.js';
-import { clearTenantData, setupIntegrationTest, truncateTables } from '../../testing/index.js';
+import { clearTenantData, setupIntegrationTest } from '../../testing/index.js';
 import { InAppNotification, NotificationChannel, NotificationLogEntity, NotificationStatus, WebPushSubscription } from '../models/index.js';
 import { configureNotification } from '../server/module.js';
 import { EmailChannelProvider } from '../server/providers/email-channel-provider.js';
@@ -34,7 +34,7 @@ describe('Notification Flow (Integration)', () => {
     let subjectService;
     let mailServiceMock;
     const schema = 'notification';
-    const tenantId = crypto.randomUUID();
+    let tenantId;
     beforeAll(async () => {
         ({ injector, database } = await setupIntegrationTest({
             orm: { schema },
@@ -63,10 +63,13 @@ describe('Notification Flow (Integration)', () => {
         worker.registerProvider(NotificationChannel.InApp, injector.resolve(InAppChannelProvider));
     });
     beforeEach(async () => {
-        await truncateTables(database, schema, ['log', 'in_app', 'in_app_archive', 'type', 'preference', 'web_push_subscription']);
-        await clearTenantData(database, 'authentication', ['user', 'subject'], tenantId);
+        tenantId = crypto.randomUUID();
         vi.clearAllMocks();
     });
+    afterEach(async () => {
+        await clearTenantData(database, schema, ['in_app', 'in_app_archive', 'log', 'preference', 'web_push_subscription'], tenantId);
+        await clearTenantData(database, 'authentication', ['user', 'subject'], tenantId);
+    });
     test('should execute full notification flow with escalation', async () => {
         await runInInjectionContext(injector, async () => {
             const logRepo = injectRepository(NotificationLogEntity);

package/orm/decorators.d.ts

@@ -3,7 +3,7 @@
  * Defines decorators for ORM entities and columns, used to configure database schema mapping.
  */
 import type { SQL } from 'drizzle-orm';
-import type { ExtraConfigColumn } from 'drizzle-orm/pg-core';
+import type { ExtraConfigColumn, UpdateDeleteAction } from 'drizzle-orm/pg-core';
 import type { LiteralUnion, SetRequired } from 'type-fest';
 import { type SpecificCreateDecoratorOptions } from '../reflection/index.js';
 import type { AbstractConstructor, Record, TypedOmit } from '../types/index.js';
@@ -40,8 +40,7 @@ export type WhereBuilder<T extends BaseEntity = BaseEntity> = SqlBuilder<T, Quer
 export type OrmTableReflectionData<T extends BaseEntity = BaseEntity> = {
     name?: string;
     schema?: string;
-    compoundPrimaryKeyName?: string;
-    compoundPrimaryKeyNaming?: NamingStrategy;
+    primaryKey?: PrimaryKeyReflectionData<T>;
     unique?: UniqueReflectionData[];
     index?: IndexReflectionData[];
     paradeIndex?: ParadeIndexReflectionData<T>;
@@ -87,12 +86,21 @@ type ReferenceReflectionData<T extends AnyEntity = AnyEntity> = {
     target: () => EntityType<T>;
     targetColumn?: TargetColumnPath<T>;
     excludeTenant?: boolean;
+    onDelete?: UpdateDeleteAction;
+    onUpdate?: UpdateDeleteAction;
+};
+export type PrimaryKeyReflectionData<T extends BaseEntity = any> = {
+    columns?: ValueOrProvider<(TargetColumnPath<T> | SQL | ExtraConfigColumn)[], ExtraConfigColumnsFromType<EntityType<T>>>;
+    options?: {
+        name?: string;
+        naming?: NamingStrategy;
+    };
 };
 /**
  * Reflection data for unique constraints.
  */
-export type UniqueReflectionData = {
-    columns?: string[];
+export type UniqueReflectionData<T extends BaseEntity = any> = {
+    columns?: ValueOrProvider<(TargetColumnPath<T> | SQL | ExtraConfigColumn)[], ExtraConfigColumnsFromType<EntityType<T>>>;
     options?: {
         name?: string;
         naming?: NamingStrategy;
@@ -122,6 +130,8 @@ export type ForeignKeyReflectionData = {
     options?: {
         name?: string;
         naming?: NamingStrategy;
+        onDelete?: UpdateDeleteAction;
+        onUpdate?: UpdateDeleteAction;
     };
 };
 export type IndexOptions<T extends BaseEntity> = {
@@ -290,6 +300,13 @@ export declare function Table(name?: string, options?: TableOptions): ClassDecor
  * @param options Table options including name and schema.
  */
 export declare function Table(options?: TableOptions): ClassDecorator;
+/**
+ * Define a composite primary key on multiple columns.
+ * @template T The entity type.
+ * @param columns An array of property names included in the primary key.
+ * @param options Additional primary key options.
+ */
+export declare function PrimaryKey<T extends AnyEntity>(columns: Columns<T>, options?: PrimaryKeyReflectionData['options']): ClassDecorator;
 /**
  * Define a foreign key relationship.
  * @param target A function returning the referenced entity type.

package/orm/decorators.js

@@ -71,7 +71,7 @@ export function PrimaryKeyProperty() {
 export function Reference(target, targetColumnOrOptions) {
     const targetColumn = (isString(targetColumnOrOptions) ? targetColumnOrOptions : targetColumnOrOptions?.targetColumn);
     const options = isString(targetColumnOrOptions) ? undefined : targetColumnOrOptions;
-    return createColumnDecorator({ references: [{ target, targetColumn, excludeTenant: options?.excludeTenant }] });
+    return createColumnDecorator({ references: [{ target, targetColumn, excludeTenant: options?.excludeTenant, onDelete: options?.onDelete, onUpdate: options?.onUpdate }] });
 }
 export { 
 /** @deprecated use {@link Reference} instead. */
@@ -113,6 +113,15 @@ export function Table(nameOrOptions, optionsOrNothing) {
         : filterUndefinedObjectProperties({ name, schema });
     return createTableDecorator(data);
 }
+/**
+ * Define a composite primary key on multiple columns.
+ * @template T The entity type.
+ * @param columns An array of property names included in the primary key.
+ * @param options Additional primary key options.
+ */
+export function PrimaryKey(columns, options) {
+    return createTableDecorator({ primaryKey: { columns, options } });
+}
 /**
  * Define a foreign key relationship.
  * @param target A function returning the referenced entity type.

package/orm/server/bootstrap.d.ts

@@ -0,0 +1,11 @@
+import { type ProvidersItem } from '../../injector/injector.js';
+/**
+ * Provides the ORM bootstrap functionality by returning an initializer provider.
+ * This will run database extensions and migrations during application startup.
+ * @returns A provider item.
+ */
+export declare function provideOrm(): ProvidersItem;
+/**
+ * Bootstraps the ORM by running database extensions and migrations within an advisory lock.
+ */
+export declare function bootstrapOrm(): Promise<void>;

package/orm/server/bootstrap.js

@@ -0,0 +1,31 @@
+import { sql } from 'drizzle-orm';
+import { provideInitializer } from '../../application/providers.js';
+import { inject, runInInjectionContext } from '../../injector/inject.js';
+import { Injector } from '../../injector/injector.js';
+import { Database } from './database.js';
+import { runDatabaseExtensions } from './extension.js';
+import { runDatabaseMigrationsCore } from './migration.js';
+/**
+ * Provides the ORM bootstrap functionality by returning an initializer provider.
+ * This will run database extensions and migrations during application startup.
+ * @returns A provider item.
+ */
+export function provideOrm() {
+    return provideInitializer(bootstrapOrm);
+}
+/**
+ * Bootstraps the ORM by running database extensions and migrations within an advisory lock.
+ */
+export async function bootstrapOrm() {
+    const injector = inject(Injector);
+    const database = inject(Database);
+    const lockId = 123456789; // Fixed lock ID for database setup
+    await database.execute(sql `SELECT pg_advisory_lock(${lockId})`);
+    try {
+        await runInInjectionContext(injector, async () => await runDatabaseExtensions());
+        await runInInjectionContext(injector, async () => await runDatabaseMigrationsCore());
+    }
+    finally {
+        await database.execute(sql `SELECT pg_advisory_unlock(${lockId})`);
+    }
+}

package/orm/server/drizzle/schema-converter.d.ts

@@ -1,4 +1,4 @@
-import { type PgEnum, type PgSchema, type PgTableWithColumns } from 'drizzle-orm/pg-core';
+import { type PgColumn, type PgEnum, type PgSchema, type PgTableWithColumns } from 'drizzle-orm/pg-core';
 import type { AbstractConstructor, Enumeration } from '../../../types/index.js';
 import { type EntityType } from '../../entity.js';
 import type { ColumnDefinition, ColumnDefinitionsMap, PgTableFromType } from '../types.js';
@@ -13,4 +13,6 @@ export declare function getColumnDefinitionsMap(table: PgTableWithColumns<any>):
 export declare function _getDrizzleTableFromType<T extends EntityType, S extends string>(type: T, fallbackSchemaName?: S): PgTableFromType<T, S>;
 export declare function isTableOwning(type: AbstractConstructor): boolean;
 export declare function getPgEnum(schema: string | PgSchema, enumeration: Enumeration, context?: ConverterContext): PgEnum<[string, ...string[]]>;
+export declare function getPrimaryKeyColumnDefinitions(type: EntityType, table: PgTableFromType, columnDefinitions?: ColumnDefinition[], columnDefinitionsMap?: ColumnDefinitionsMap): ColumnDefinition[];
+export declare function getPrimaryKeyColumns(type: EntityType, table: PgTableFromType, columnDefinitions?: ColumnDefinition[], columnDefinitionsMap?: ColumnDefinitionsMap): PgColumn[];
 export {};

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

@@ -15,13 +15,13 @@ import { typeExtends } from '../../../utils/index.js';
 import { merge } from '../../../utils/merge.js';
 import { compileDereferencer } from '../../../utils/object/dereference.js';
 import { fromEntries, mapObjectKeysToSnakeCase, objectEntries } from '../../../utils/object/object.js';
-import { assertDefined, assertDefinedPass, isArray, isDefined, isNotNull, isNotNullOrUndefined, isNull, isString, isUndefined } from '../../../utils/type-guards.js';
+import { assertDefined, assertDefinedPass, isArray, isDefined, isNotNull, isNull, isString, isUndefined } from '../../../utils/type-guards.js';
 import { resolveValueOrProvider } from '../../../utils/value-or-provider.js';
 import { bytea, numericDate, timestamp, tsvector } from '../../data-types/index.js';
 import { TenantBaseEntity, TenantEntity } from '../../entity.js';
 import { getEnumName } from '../../enums.js';
 import { JsonSchema, NumericDateSchema, NumericSchema, TimestampSchema, TsVectorSchema, UuidSchema } from '../../schemas/index.js';
-import { getInheritanceMetadata, isChildEntity } from '../../utils.js';
+import { getEntitySchema, getEntityTableName, getInheritanceMetadata, getTableReflectionDatas, isChildEntity } from '../../utils.js';
 import { decryptBytes, encryptBytes } from '../encryption.js';
 import { convertQuery, resolveTargetColumn, resolveTargetColumns } from '../query-converter.js';
 const getDbSchema = memoizeSingle(pgSchema);
@@ -42,13 +42,18 @@ export function getColumnDefinitionsMap(table) {
 export function _getDrizzleTableFromType(type, fallbackSchemaName) {
     const tableReflectionDatas = getTableReflectionDatas(type);
     const mergedTableReflectionData = tableReflectionDatas.reduceRight((merged, data) => ({ ...merged, ...data }), {});
-    const schema = assertDefinedPass(mergedTableReflectionData.schema ?? fallbackSchemaName, 'Table schema not provided');
-    const tableName = getTableName(type);
+    const schema = getEntitySchema(type, fallbackSchemaName);
+    const tableName = getEntityTableName(type);
     const dbSchema = getDbSchema(schema);
     const inheritanceMetadata = getInheritanceMetadata(type);
     const allColumnDefinitions = getPostgresColumnEntries(type, dbSchema, tableName, undefined, '', { filterInherited: false }, type);
+    const primaryKeyPropertyNames = new Set(isDefined(mergedTableReflectionData.primaryKey?.columns)
+        ? resolveValueOrProvider(mergedTableReflectionData.primaryKey.columns, {}).filter((c) => isString(c))
+        : []);
     const columnDefinitions = allColumnDefinitions.filter((cd) => !isChildEntity(type)
         || !cd.inherited
+        || (cd.reflectionData?.primaryKey == true)
+        || primaryKeyPropertyNames.has(cd.objectPath.path)
         || (cd.objectPath.path == 'id')
         || (cd.objectPath.path == 'tenantId')
         || (cd.objectPath.path == inheritanceMetadata?.discriminatorColumn));
@@ -100,23 +105,43 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
         }
         return builder;
     }
-    function buildInheritanceCompositeUniqueConstraint(table) {
-        const inheritanceMetadata = mergedTableReflectionData.inheritance;
+    function getInheritanceColumns(inheritanceTable, inheritanceType) {
+        const inheritanceMetadata = getInheritanceMetadata(inheritanceType);
         const discriminatorColumn = inheritanceMetadata.discriminatorColumn;
-        const hasTenantId = isDefined(table['tenantId']);
+        const pkColumnDefinitions = getPrimaryKeyColumnDefinitions(inheritanceType, inheritanceTable, columnDefinitions, columnDefinitionsMap);
+        const discriminatorColumnObject = inheritanceTable[discriminatorColumn];
+        const hasTenantId = pkColumnDefinitions.some((d) => d.objectPath.path == 'tenantId');
+        const tenantIdColumn = hasTenantId ? inheritanceTable['tenantId'] : undefined;
         const columns = [
-            ...(hasTenantId ? [table['tenantId']] : []),
-            table[discriminatorColumn],
-            table['id'],
+            ...(isDefined(tenantIdColumn) ? [tenantIdColumn] : []),
+            discriminatorColumnObject,
+            ...pkColumnDefinitions.filter((d) => d.objectPath.path != 'tenantId').map((d) => inheritanceTable[d.name]),
+        ];
+        const identifierParts = [
+            ...(hasTenantId ? ['tenantId'] : []),
+            discriminatorColumn,
+            ...pkColumnDefinitions.filter((d) => d.objectPath.path != 'tenantId').map((d) => d.objectPath.path),
         ];
+        return { columns, identifierParts };
+    }
+    function buildInheritanceCompositeUniqueConstraint(table) {
+        const { columns } = getInheritanceColumns(table, type);
         return unique(getUniqueName(tableName, columns)).on(...columns);
     }
     function buildPrimaryKey(table) {
-        const columns = primaryKeyColumnDefinitions
-            .toSorted(compareByValueSelectionToOrder(['tenantId', 'id', orderRest], (columnDefinition) => columnDefinition.name))
-            .map((columnDefinition) => table[columnDefinition.name]);
+        const primaryKeyData = mergedTableReflectionData.primaryKey;
+        const resolvedColumns = isDefined(primaryKeyData?.columns) ? resolveValueOrProvider(primaryKeyData.columns, table) : undefined;
+        const columns = match(resolvedColumns)
+            .with(P.nonNullable, (primaryColumns) => primaryColumns.map((columnValue) => {
+            if (columnValue instanceof SQL) {
+                return columnValue;
+            }
+            return getColumn(table, columnValue);
+        }))
+            .with(undefined, () => getPrimaryKeyColumns(type, table, columnDefinitions, columnDefinitionsMap))
+            .exhaustive();
         return primaryKey({
-            name: mergedTableReflectionData.compoundPrimaryKeyName ?? getPrimaryKeyName(tableName, columns, { naming: mergedTableReflectionData.compoundPrimaryKeyNaming }),
+            name: primaryKeyData?.options?.name ?? getPrimaryKeyName(tableName, columns, { naming: primaryKeyData?.options?.naming }),
             columns,
         });
     }
@@ -128,22 +153,14 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
             constraints.push(buildInheritanceCompositeUniqueConstraint(table));
         }
         if (isDefined(inheritanceMetadata) && isDefined(childEntityMetadata)) {
-            const hasTenantId = isDefined(table['tenantId']);
+            const parentType = reflectionRegistry.getMetadata(type).parent;
+            const parentTable = getDrizzleTableFromType(parentType, schema);
+            const { columns: foreignKeyColumns, identifierParts: foreignKeyIdentifierParts } = getInheritanceColumns(table, type);
+            const { columns: parentForeignKeyColumns } = getInheritanceColumns(parentTable, parentType);
             constraints.push(check(getIdentifier(tableName, discriminatorColumn, 'check'), eq(table[discriminatorColumn], sql.raw(`'${childEntityMetadata.discriminatorValue}'`))), foreignKey({
-                name: getForeignKeyName(tableName, getTableName(reflectionRegistry.getMetadata(type).parent), [...(hasTenantId ? ['tenantId'] : []), discriminatorColumn, 'id']),
-                columns: [
-                    ...(hasTenantId ? [table['tenantId']] : []),
-                    table[discriminatorColumn],
-                    table['id'],
-                ],
-                foreignColumns: (() => {
-                    const parentTable = getDrizzleTableFromType(reflectionRegistry.getMetadata(type).parent, schema);
-                    return [
-                        ...(hasTenantId ? [parentTable['tenantId']] : []),
-                        parentTable[discriminatorColumn],
-                        parentTable.id,
-                    ];
-                })(),
+                name: getForeignKeyName(tableName, getEntityTableName(parentType), foreignKeyIdentifierParts),
+                columns: foreignKeyColumns,
+                foreignColumns: parentForeignKeyColumns,
             }).onDelete('cascade'));
         }
         return constraints;
@@ -222,7 +239,7 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
         return builder;
     }
     const primaryKeyColumnDefinitions = columnDefinitions.filter((columnDefinition) => (columnDefinition.reflectionData?.primaryKey == true) || (columnDefinition.objectPath.path == 'id' && columnDefinition.reflectionData?.primaryKey != false));
-    const skipPrimaryKey = primaryKeyColumnDefinitions.length > 1;
+    const skipPrimaryKey = (primaryKeyColumnDefinitions.length > 1) || isDefined(mergedTableReflectionData.primaryKey?.columns);
     const columnEntries = columnDefinitions.map((entry) => [entry.name, entry.buildType({ skipPrimaryKey })]);
     const drizzleSchema = dbSchema.table(tableName, fromEntries(columnEntries), (drizzleTable) => {
         const table = drizzleTable;
@@ -231,7 +248,7 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
         const bm25Index = buildParadeIndex(table);
         const checks = tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.checks).filter(isDefined).map((data) => check(data.name, data.builder(table)));
         return [
-            ...((primaryKeyColumnDefinitions.length > 1)
+            ...(skipPrimaryKey
                 ? [buildPrimaryKey(table)]
                 : []),
             ...buildInheritanceConstraints(table),
@@ -247,7 +264,7 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
                     const foreignTable = getDrizzleTableFromType(tenantReferenceData.target(), dbSchema.schemaName);
                     const nonTenantColumn = tenantReferenceData.targetColumn ?? 'id';
                     return foreignKey({
-                        name: getForeignKeyName(tableName, getTableName(tenantReferenceData.target()), [nonTenantColumn]),
+                        name: getForeignKeyName(tableName, getEntityTableName(tenantReferenceData.target()), [nonTenantColumn]),
                         columns: [getColumn(table, 'tenantId'), getColumn(table, columnDefinition.name)],
                         foreignColumns: [getColumn(foreignTable, 'tenantId'), getColumn(foreignTable, nonTenantColumn)],
                     });
@@ -257,15 +274,23 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
                 return tableReflectionData.foreignKeys?.map((foreignKeyData) => {
                     const foreignKeyTarget = foreignKeyData.target();
                     const foreignTable = getDrizzleTableFromType(foreignKeyTarget, dbSchema.schemaName);
-                    return foreignKey({
-                        name: foreignKeyData.options?.name ?? getForeignKeyName(tableName, getTableName(foreignKeyData.target()), foreignKeyData.columns, { naming: foreignKeyData.options?.naming }),
+                    let builder = foreignKey({
+                        name: foreignKeyData.options?.name ?? getForeignKeyName(tableName, getEntityTableName(foreignKeyData.target()), foreignKeyData.columns, { naming: foreignKeyData.options?.naming }),
                         columns: foreignKeyData.columns.map((column) => getColumn(table, column)),
                         foreignColumns: foreignKeyData.foreignColumns.map((column) => getColumn(foreignTable, column)),
                     });
+                    if (isDefined(foreignKeyData.options?.onDelete)) {
+                        builder = builder.onDelete(foreignKeyData.options.onDelete);
+                    }
+                    if (isDefined(foreignKeyData.options?.onUpdate)) {
+                        builder = builder.onUpdate(foreignKeyData.options.onUpdate);
+                    }
+                    return builder;
                 }) ?? [];
             }),
             ...tableReflectionDatas.flatMap((tableReflectionData) => tableReflectionData.unique).filter(isDefined).map((data) => {
-                const columns = data.columns?.map((column) => getColumn(table, column));
+                const resolvedColumns = resolveValueOrProvider(data.columns, table);
+                const columns = resolvedColumns.map((column) => getColumn(table, column));
                 let constraint = unique(data.options?.name ?? getUniqueName(tableName, columns, { naming: data.options?.naming })).on(...columns);
                 if (data.options?.nulls == 'not distinct') {
                     constraint = constraint.nullsNotDistinct();
@@ -398,7 +423,7 @@ function getPostgresColumn(tableName, columnName, dbSchema, propertySchema, refl
     if (((reflectionData.primaryKey == true) || (context.property == 'id' && reflectionData.primaryKey != false)) && (options.skipPrimaryKey != true)) {
         column = column.primaryKey();
     }
-    for (const { target, targetColumn, excludeTenant } of reflectionData.references ?? []) {
+    for (const { target, targetColumn, excludeTenant, onDelete, onUpdate } of reflectionData.references ?? []) {
         column = column.references(() => {
             const targetType = target();
             if ((excludeTenant != true) && (typeExtends(context.type, TenantBaseEntity) || typeExtends(context.type, TenantEntity)) && (typeExtends(targetType, TenantBaseEntity) || typeExtends(targetType, TenantEntity))) {
@@ -406,7 +431,7 @@ function getPostgresColumn(tableName, columnName, dbSchema, propertySchema, refl
             }
             const targetTable = getDrizzleTableFromType(targetType, dbSchema.schemaName);
             return targetTable[(targetColumn ?? 'id')];
-        });
+        }, { onDelete, onUpdate });
     }
     return column;
 }
@@ -462,8 +487,29 @@ export function getPgEnum(schema, enumeration, context) {
     }
     return dbEnum;
 }
-function getDefaultTableName(type) {
-    return toSnakeCase(isString(type.entityName) ? type.entityName : type.name.replace(/\d+$/u, ''));
+export function getPrimaryKeyColumnDefinitions(type, table, columnDefinitions, columnDefinitionsMap) {
+    const tableReflectionDatas = getTableReflectionDatas(type);
+    const mergedTableReflectionData = tableReflectionDatas.reduceRight((merged, data) => ({ ...merged, ...data }), {});
+    const resolvedColumnDefinitions = columnDefinitions ?? getColumnDefinitions(table);
+    const resolvedColumnDefinitionsMap = columnDefinitionsMap ?? getColumnDefinitionsMap(table);
+    const primaryKeyData = mergedTableReflectionData.primaryKey;
+    let definitions;
+    if (isDefined(primaryKeyData?.columns)) {
+        const resolvedColumns = resolveValueOrProvider(primaryKeyData.columns, table);
+        definitions = resolvedColumns.map((columnValue) => {
+            if (columnValue instanceof SQL) {
+                throw new NotSupportedError('SQL in primary key is not supported by Repository.');
+            }
+            return assertDefinedPass(resolvedColumnDefinitionsMap.get(columnValue), `Could not map primary key property ${columnValue} to column.`);
+        });
+    }
+    else {
+        definitions = resolvedColumnDefinitions.filter((columnDefinition) => (columnDefinition.reflectionData?.primaryKey == true) || (columnDefinition.objectPath.path == 'id' && columnDefinition.reflectionData?.primaryKey != false));
+    }
+    return definitions.toSorted(compareByValueSelectionToOrder(['tenantId', 'id', orderRest], (columnDefinition) => columnDefinition.objectPath.path));
+}
+export function getPrimaryKeyColumns(type, table, columnDefinitions, columnDefinitionsMap) {
+    return getPrimaryKeyColumnDefinitions(type, table, columnDefinitions, columnDefinitionsMap).map((def) => table[def.name]);
 }
 function getPrimaryKeyName(tableName, columnsOrBaseName, options) {
     return getIdentifier(tableName, columnsOrBaseName, 'pk', options);
@@ -486,23 +532,6 @@ function getForeignKeyName(tableName, foreignTableName, columnsOrBaseName, optio
     }
     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('_');
     const identifier = `${getTablePrefix(tableName, options?.naming)}_${middle}_${suffix}`;

package/orm/server/encryption.d.ts

@@ -12,7 +12,6 @@ export declare function encryptBytes(bytes: Uint8Array<ArrayBuffer>, key: Crypto
  * @param bytes The byte array to decrypt (must include version and IV).
  * @param key The CryptoKey to use for decryption.
  * @returns A promise that resolves to the original decrypted byte array.
- * @throws {DetailsError} If decryption fails (e.g., wrong key, corrupted data).
  * @throws {Error} If the encryption version is invalid.
  */
 export declare function decryptBytes(bytes: Uint8Array, key: CryptoKey): Promise<Uint8Array<ArrayBuffer>>;

package/orm/server/encryption.js

@@ -3,7 +3,6 @@
  * Provides utility functions for encrypting and decrypting byte arrays using AES-GCM.
  * It includes versioning to handle potential future changes in the encryption format.
  */
-import { DetailsError } from '../../errors/index.js';
 import { decrypt, encrypt } from '../../utils/cryptography.js';
 import { getRandomBytes } from '../../utils/random.js';
 import { assert } from '../../utils/type-guards.js';
@@ -36,7 +35,6 @@ export async function encryptBytes(bytes, key) {
  * @param bytes The byte array to decrypt (must include version and IV).
  * @param key The CryptoKey to use for decryption.
  * @returns A promise that resolves to the original decrypted byte array.
- * @throws {DetailsError} If decryption fails (e.g., wrong key, corrupted data).
  * @throws {Error} If the encryption version is invalid.
  */
 export async function decryptBytes(bytes, key) {
@@ -49,7 +47,6 @@ export async function decryptBytes(bytes, key) {
         return new Uint8Array(decrypted);
     }
     catch (error) {
-        // Wrap decryption errors for better context
-        throw new DetailsError('Decrypt error', error);
+        throw new Error('Decryption failed.', { cause: error });
     }
 }

package/orm/server/extension.d.ts

@@ -0,0 +1,14 @@
+import { Injector } from '../../injector/index.js';
+export type DatabaseExtension = {
+    name: string;
+};
+export declare const DATABASE_EXTENSION: import("../../injector/index.js").InjectionToken<DatabaseExtension, never>;
+/**
+ * Registers a database extension in the provided injector.
+ * @param name - The name of the extension.
+ * @param options - Optional injector.
+ */
+export declare function registerDatabaseExtension(name: string, { injector }?: {
+    injector?: Injector;
+}): void;
+export declare function runDatabaseExtensions(): Promise<void>;