@tstdl/base 0.93.141 → 0.93.142

package/authentication/client/authentication.service.d.ts

@@ -27,6 +27,7 @@ export declare class AuthenticationClientService<AdditionalTokenPayload extends
     private readonly logger;
     private readonly disposeSignal;
     private readonly forceRefreshRequested;
+    private readonly forceRefreshRequested$;
     private clockOffset;
     private initialized;
     private refreshLoopPromise;

package/authentication/client/authentication.service.js

@@ -70,6 +70,7 @@ let AuthenticationClientService = class AuthenticationClientService {
     logger = inject(Logger, 'AuthenticationService');
     disposeSignal = inject(CancellationSignal).fork();
     forceRefreshRequested = signal(false);
+    forceRefreshRequested$ = toObservable(this.forceRefreshRequested);
     clockOffset = 0;
     initialized = false;
     refreshLoopPromise;
@@ -435,7 +436,7 @@ let AuthenticationClientService = class AuthenticationClientService {
                     this.token$.pipe(filter((t) => t != currentToken)),
                 ];
                 if (!forceRefresh) {
-                    wakeUpSignals.push(toObservable(this.forceRefreshRequested).pipe(filter((v) => v)));
+                    wakeUpSignals.push(this.forceRefreshRequested$.pipe(filter((requested) => requested)));
                 }
                 if (delay > 0) {
                     await firstValueFrom(race([timer(delay), ...wakeUpSignals]), { defaultValue: undefined });
@@ -451,7 +452,7 @@ let AuthenticationClientService = class AuthenticationClientService {
                     timer(2500),
                     from(this.disposeSignal),
                     this.token$.pipe(filter((t) => t != currentToken)),
-                    toObservable(this.forceRefreshRequested).pipe(filter((requested) => requested), skip(this.forceRefreshRequested() ? 1 : 0)),
+                    this.forceRefreshRequested$.pipe(filter((requested) => requested), skip(this.forceRefreshRequested() ? 1 : 0)),
                 ]), { defaultValue: undefined });
             }
         }

package/circuit-breaker/circuit-breaker.d.ts

@@ -6,15 +6,15 @@ export declare const CircuitBreakerState: {
     readonly HalfOpen: "half-open";
 };
 export type CircuitBreakerState = EnumType<typeof CircuitBreakerState>;
-export interface CircuitBreakerConfig {
+export type CircuitBreakerConfig = {
     threshold: number;
     resetTimeout: number;
-}
-export interface CircuitBreakerCheckResult {
+};
+export type CircuitBreakerCheckResult = {
     allowed: boolean;
     state: CircuitBreakerState;
     isProbe?: boolean;
-}
+};
 export type CircuitBreakerArgument = string | (CircuitBreakerConfig & {
     key: string;
 });
@@ -29,4 +29,6 @@ export declare abstract class CircuitBreaker implements Resolvable<CircuitBreake
     abstract recordSuccess(): Promise<void>;
     /** Records a failure, potentially tripping the breaker to Open. */
     abstract recordFailure(): Promise<void>;
+    /** Records multiple failures at once. */
+    abstract recordFailures(count: number): Promise<void>;
 }

package/circuit-breaker/postgres/circuit-breaker.d.ts

@@ -4,4 +4,5 @@ export declare class PostgresCircuitBreakerService extends CircuitBreaker {
     check(): Promise<CircuitBreakerCheckResult>;
     recordSuccess(): Promise<void>;
     recordFailure(): Promise<void>;
+    recordFailures(count: number): Promise<void>;
 }

package/circuit-breaker/postgres/circuit-breaker.js

@@ -43,8 +43,11 @@ let PostgresCircuitBreakerService = class PostgresCircuitBreakerService extends
         await this.#repository.tryDeleteByQuery({ key: this.#key });
     }
     async recordFailure() {
+        await this.recordFailures(1);
+    }
+    async recordFailures(count) {
         const table = this.#repository.table;
-        const initialTrip = 1 >= this.#threshold;
+        const initialTrip = count >= this.#threshold;
         const initialState = initialTrip ? CircuitBreakerState.Open : CircuitBreakerState.Closed;
         const initialResetTimestamp = initialTrip
             ? sql `${TRANSACTION_TIMESTAMP} + ${interval(this.#resetTimeout, 'milliseconds')}`
@@ -52,16 +55,16 @@ let PostgresCircuitBreakerService = class PostgresCircuitBreakerService extends
         await this.#repository.upsert(['key'], {
             key: this.#key,
             state: initialState,
-            failureCount: 1,
+            failureCount: count,
             resetTimestamp: initialResetTimestamp,
         }, {
-            failureCount: sql `${table.failureCount} + 1`,
+            failureCount: sql `${table.failureCount} + ${count}`,
             state: sql `CASE
-          WHEN ${table.failureCount} + 1 >= ${this.#threshold} THEN ${CircuitBreakerState.Open}
+          WHEN ${table.failureCount} + ${count} >= ${this.#threshold} THEN ${CircuitBreakerState.Open}
           ELSE ${table.state}
         END`,
             resetTimestamp: sql `CASE
-          WHEN ${table.failureCount} + 1 >= ${this.#threshold} THEN ${TRANSACTION_TIMESTAMP} + ${interval(this.#resetTimeout, 'milliseconds')}
+          WHEN ${table.failureCount} + ${count} >= ${this.#threshold} THEN ${TRANSACTION_TIMESTAMP} + ${interval(this.#resetTimeout, 'milliseconds')}
           ELSE ${table.resetTimestamp}
         END`,
         });

package/circuit-breaker/tests/circuit-breaker.test.js

@@ -90,4 +90,24 @@ describe('Circuit Breaker (Standalone) Tests', () => {
         expect(result.allowed).toBe(false);
         expect(result.state).toBe(CircuitBreakerState.Open);
     });
+    it('should trip to Open after threshold failures via recordFailures', async () => {
+        const breaker = provider.provide(`cb-bulk-trip-${Date.now()}`, { threshold: 5, resetTimeout: 1000 });
+        // 1. Bulk Failure (Threshold Not Reached)
+        await breaker.recordFailures(3);
+        let result = await breaker.check();
+        expect(result.state).toBe(CircuitBreakerState.Closed);
+        // 2. Bulk Failure (Threshold Reached)
+        await breaker.recordFailures(2);
+        result = await breaker.check();
+        expect(result.allowed).toBe(false);
+        expect(result.state).toBe(CircuitBreakerState.Open);
+    });
+    it('should trip to Open after threshold failures via single large recordFailures', async () => {
+        const breaker = provider.provide(`cb-single-bulk-trip-${Date.now()}`, { threshold: 5, resetTimeout: 1000 });
+        // Single large bulk failure exceeding threshold
+        await breaker.recordFailures(10);
+        const result = await breaker.check();
+        expect(result.allowed).toBe(false);
+        expect(result.state).toBe(CircuitBreakerState.Open);
+    });
 });

package/examples/document-management/main.js

@@ -24,7 +24,7 @@ import { PrettyPrintLogFormatter, provideConsoleLogTransport } from '../../logge
 import { configureLocalMessageBus } from '../../message-bus/index.js';
 import { WebServerModule } from '../../module/index.js';
 import { configureS3ObjectStorage } from '../../object-storage/s3/index.js';
-import { configureOrm, provideDatabaseMigrator } from '../../orm/server/index.js';
+import { configureOrm, provideOrm } from '../../orm/server/index.js';
 import { configurePostgresRateLimiter } from '../../rate-limit/postgres/module.js';
 import { configureDefaultSignalsImplementation } from '../../signals/implementation/configure.js';
 import { configurePostgresTaskQueue } from '../../task-queue/postgres/index.js';
@@ -173,5 +173,5 @@ Application.run('DocumentManagementTest', [
     provideModule(main, WebServerModule),
     provideSignalHandler(),
     provideConsoleLogTransport(PrettyPrintLogFormatter),
-    provideDatabaseMigrator(),
+    provideOrm(),
 ]);

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,13 +4,13 @@ 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 { InAppNotification, InAppNotificationArchive, NotificationChannel, NotificationLogEntity, NotificationPreference, NotificationStatus, NotificationType, WebPushSubscription } from '../models/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';
 import { NotificationAncillaryService } from '../server/services/notification-ancillary.service.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, [NotificationLogEntity, InAppNotification, InAppNotificationArchive, NotificationType, NotificationPreference, WebPushSubscription]);
-        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

@@ -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>;
@@ -90,11 +89,18 @@ type ReferenceReflectionData<T extends AnyEntity = AnyEntity> = {
     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;
@@ -294,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

@@ -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,7 +15,7 @@ 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, isArray, isDefined, isNotNull, 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';
@@ -47,8 +47,13 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
     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, getEntityTableName(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),
@@ -272,7 +289,8 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
                 }) ?? [];
             }),
             ...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();
@@ -469,6 +487,30 @@ export function getPgEnum(schema, enumeration, context) {
     }
     return dbEnum;
 }
+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);
 }

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>;

package/orm/server/extension.js

@@ -0,0 +1,27 @@
+import { sql } from 'drizzle-orm';
+import { injectionToken, Injector } from '../../injector/index.js';
+import { inject, injectAll } from '../../injector/inject.js';
+import { Logger } from '../../logger/index.js';
+import { Database } from './database.js';
+export const DATABASE_EXTENSION = injectionToken('DatabaseExtension');
+/**
+ * Registers a database extension in the provided injector.
+ * @param name - The name of the extension.
+ * @param options - Optional injector.
+ */
+export function registerDatabaseExtension(name, { injector } = {}) {
+    const targetInjector = injector ?? Injector;
+    targetInjector.register(DATABASE_EXTENSION, { useValue: { name } }, { multi: true });
+}
+export async function runDatabaseExtensions() {
+    const database = inject(Database);
+    const logger = inject(Logger, 'DatabaseExtensionOrchestrator');
+    const extensions = injectAll(DATABASE_EXTENSION, undefined, { optional: true });
+    if (extensions.length == 0) {
+        return;
+    }
+    for (const extension of extensions) {
+        logger.info(`Ensuring database extension: ${extension.name}`);
+        await database.execute(sql.raw(`CREATE EXTENSION IF NOT EXISTS "${extension.name}"`));
+    }
+}

package/orm/server/index.d.ts

@@ -1,5 +1,7 @@
 export * from './database-schema.js';
 export * from './database.js';
+export * from './bootstrap.js';
+export * from './extension.js';
 export * from './migration.js';
 export * from './module.js';
 export * from './query-converter.js';

package/orm/server/index.js

@@ -1,5 +1,7 @@
 export * from './database-schema.js';
 export * from './database.js';
+export * from './bootstrap.js';
+export * from './extension.js';
 export * from './migration.js';
 export * from './module.js';
 export * from './query-converter.js';

package/orm/server/migration.d.ts

@@ -1,4 +1,4 @@
-import { Injector, type ProvidersItem } from '../../injector/index.js';
+import { Injector } from '../../injector/index.js';
 export type DatabaseMigration = {
     name: string;
     migrate: () => void | Promise<void>;
@@ -15,5 +15,4 @@ export declare function registerDatabaseMigration(name: string, migrate: () => v
     injector?: Injector;
     dependencies?: string[];
 }): void;
-export declare function provideDatabaseMigrator(): ProvidersItem;
-export declare function runDatabaseMigrations(): Promise<void>;
+export declare function runDatabaseMigrationsCore(migrations?: DatabaseMigration[]): Promise<void>;

package/orm/server/migration.js

@@ -1,10 +1,7 @@
-import { sql } from 'drizzle-orm';
-import { provideInitializer } from '../../application/providers.js';
 import { injectionToken, Injector } from '../../injector/index.js';
 import { inject, injectAll, runInInjectionContext } from '../../injector/inject.js';
 import { Logger } from '../../logger/index.js';
 import { isDefined } from '../../utils/type-guards.js';
-import { Database } from './database.js';
 export const DATABASE_MIGRATION = injectionToken('DatabaseMigration');
 /**
  * Registers a database migration in the provided injector.
@@ -16,28 +13,17 @@ export function registerDatabaseMigration(name, migrate, { injector, dependencie
     const targetInjector = injector ?? Injector;
     targetInjector.register(DATABASE_MIGRATION, { useValue: { name, migrate, dependencies } }, { multi: true });
 }
-export function provideDatabaseMigrator() {
-    return provideInitializer(runDatabaseMigrations);
-}
-export async function runDatabaseMigrations() {
+export async function runDatabaseMigrationsCore(migrations) {
     const injector = inject(Injector);
-    const database = inject(Database);
     const logger = inject(Logger, 'DatabaseMigrationOrchestrator');
-    const migrations = injectAll(DATABASE_MIGRATION, undefined, { optional: true });
-    if (migrations.length == 0) {
+    const actualMigrations = migrations ?? injectAll(DATABASE_MIGRATION, undefined, { optional: true });
+    if (actualMigrations.length == 0) {
         return;
     }
-    const lockId = 123456789; // Fixed lock ID for migrations
-    await database.execute(sql `SELECT pg_advisory_lock(${lockId})`);
-    try {
-        const sortedMigrations = sortMigrations(migrations);
-        for (const migration of sortedMigrations) {
-            logger.info(`Running database migration: ${migration.name}`);
-            await runInInjectionContext(injector, async () => await migration.migrate());
-        }
-    }
-    finally {
-        await database.execute(sql `SELECT pg_advisory_unlock(${lockId})`);
+    const sortedMigrations = sortMigrations(actualMigrations);
+    for (const migration of sortedMigrations) {
+        logger.info(`Running database migration: ${migration.name}`);
+        await runInInjectionContext(injector, async () => await migration.migrate());
     }
 }
 function sortMigrations(migrations) {

package/orm/server/repository.d.ts

@@ -1,3 +1,4 @@
+/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
 import { SQL, type SQLWrapper } from 'drizzle-orm';
 import type { AnyPgTable, PgColumn, PgInsertValue, PgSelectBuilder, PgUpdateSetSource, SelectedFields } from 'drizzle-orm/pg-core';
 import { afterResolve, resolveArgumentType, type Resolvable } from '../../injector/interfaces.js';