@tstdl/base 0.93.140 → 0.93.141

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

@@ -10,7 +10,7 @@ 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, NotificationChannel, NotificationLogEntity, NotificationStatus, WebPushSubscription } from '../models/index.js';
+import { InAppNotification, InAppNotificationArchive, NotificationChannel, NotificationLogEntity, NotificationPreference, NotificationStatus, NotificationType, 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';
@@ -63,7 +63,7 @@ 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 truncateTables(database, schema, [NotificationLogEntity, InAppNotification, InAppNotificationArchive, NotificationType, NotificationPreference, WebPushSubscription]);
         await clearTenantData(database, 'authentication', ['user', 'subject'], tenantId);
         vi.clearAllMocks();
     });

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';
@@ -87,6 +87,8 @@ type ReferenceReflectionData<T extends AnyEntity = AnyEntity> = {
     target: () => EntityType<T>;
     targetColumn?: TargetColumnPath<T>;
     excludeTenant?: boolean;
+    onDelete?: UpdateDeleteAction;
+    onUpdate?: UpdateDeleteAction;
 };
 /**
  * Reflection data for unique constraints.
@@ -122,6 +124,8 @@ export type ForeignKeyReflectionData = {
     options?: {
         name?: string;
         naming?: NamingStrategy;
+        onDelete?: UpdateDeleteAction;
+        onUpdate?: UpdateDeleteAction;
     };
 };
 export type IndexOptions<T extends BaseEntity> = {

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. */

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, 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,8 +42,8 @@ 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);
@@ -130,7 +130,7 @@ export function _getDrizzleTableFromType(type, fallbackSchemaName) {
         if (isDefined(inheritanceMetadata) && isDefined(childEntityMetadata)) {
             const hasTenantId = isDefined(table['tenantId']);
             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']),
+                name: getForeignKeyName(tableName, getEntityTableName(reflectionRegistry.getMetadata(type).parent), [...(hasTenantId ? ['tenantId'] : []), discriminatorColumn, 'id']),
                 columns: [
                     ...(hasTenantId ? [table['tenantId']] : []),
                     table[discriminatorColumn],
@@ -247,7 +247,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,11 +257,18 @@ 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) => {
@@ -398,7 +405,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 +413,7 @@ function getPostgresColumn(tableName, columnName, dbSchema, propertySchema, refl
             }
             const targetTable = getDrizzleTableFromType(targetType, dbSchema.schemaName);
             return targetTable[(targetColumn ?? 'id')];
-        });
+        }, { onDelete, onUpdate });
     }
     return column;
 }
@@ -462,9 +469,6 @@ export function getPgEnum(schema, enumeration, context) {
     }
     return dbEnum;
 }
-function getDefaultTableName(type) {
-    return toSnakeCase(isString(type.entityName) ? type.entityName : type.name.replace(/\d+$/u, ''));
-}
 function getPrimaryKeyName(tableName, columnsOrBaseName, options) {
     return getIdentifier(tableName, columnsOrBaseName, 'pk', options);
 }
@@ -486,23 +490,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/index.d.ts

@@ -1,11 +1,6 @@
-/**
- * @module
- * Barrel file exporting core server-side ORM functionalities.
- * Includes database connection, schema management, repositories, transactions,
- * and query conversion utilities.
- */
 export * from './database-schema.js';
 export * from './database.js';
+export * from './migration.js';
 export * from './module.js';
 export * from './query-converter.js';
 export * from './repository-config.js';

package/orm/server/index.js

@@ -1,11 +1,6 @@
-/**
- * @module
- * Barrel file exporting core server-side ORM functionalities.
- * Includes database connection, schema management, repositories, transactions,
- * and query conversion utilities.
- */
 export * from './database-schema.js';
 export * from './database.js';
+export * from './migration.js';
 export * from './module.js';
 export * from './query-converter.js';
 export * from './repository-config.js';

package/orm/server/migration.d.ts

@@ -0,0 +1,19 @@
+import { Injector, type ProvidersItem } from '../../injector/index.js';
+export type DatabaseMigration = {
+    name: string;
+    migrate: () => void | Promise<void>;
+    dependencies?: string[];
+};
+export declare const DATABASE_MIGRATION: import("../../injector/index.js").InjectionToken<DatabaseMigration, never>;
+/**
+ * Registers a database migration in the provided injector.
+ * @param name - The unique name of the migration.
+ * @param migrate - The migration function.
+ * @param options - Optional injector and dependencies.
+ */
+export declare function registerDatabaseMigration(name: string, migrate: () => void | Promise<void>, { injector, dependencies }?: {
+    injector?: Injector;
+    dependencies?: string[];
+}): void;
+export declare function provideDatabaseMigrator(): ProvidersItem;
+export declare function runDatabaseMigrations(): Promise<void>;

package/orm/server/migration.js

@@ -0,0 +1,72 @@
+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.
+ * @param name - The unique name of the migration.
+ * @param migrate - The migration function.
+ * @param options - Optional injector and dependencies.
+ */
+export function registerDatabaseMigration(name, migrate, { injector, dependencies } = {}) {
+    const targetInjector = injector ?? Injector;
+    targetInjector.register(DATABASE_MIGRATION, { useValue: { name, migrate, dependencies } }, { multi: true });
+}
+export function provideDatabaseMigrator() {
+    return provideInitializer(runDatabaseMigrations);
+}
+export async function runDatabaseMigrations() {
+    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) {
+        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})`);
+    }
+}
+function sortMigrations(migrations) {
+    const result = [];
+    const visited = new Set();
+    const visiting = new Set();
+    const migrationMap = new Map(migrations.map((m) => [m.name, m]));
+    function visit(name) {
+        if (visited.has(name)) {
+            return;
+        }
+        if (visiting.has(name)) {
+            throw new Error(`Circular dependency detected in database migrations: ${name}`);
+        }
+        visiting.add(name);
+        const migration = migrationMap.get(name);
+        if (isDefined(migration?.dependencies)) {
+            for (const dependency of migration.dependencies) {
+                visit(dependency);
+            }
+        }
+        visiting.delete(name);
+        visited.add(name);
+        if (isDefined(migration)) {
+            result.push(migration);
+        }
+    }
+    for (const migration of migrations) {
+        visit(migration.name);
+    }
+    return result;
+}

package/orm/server/repository.d.ts

@@ -18,7 +18,7 @@ type EntityRepositoryContext = {
     encryptionSecret: Uint8Array<ArrayBuffer> | undefined;
     transformContext: TransformContext | Promise<TransformContext> | undefined;
 };
-type InferSelect<T extends BaseEntity = BaseEntity> = PgTableFromType<EntityType<T>>['$inferSelect'];
+export type InferSelect<T extends BaseEntity = BaseEntity> = PgTableFromType<EntityType<T>>['$inferSelect'];
 export declare class EntityRepository<T extends BaseEntity = BaseEntity> extends Transactional<EntityRepositoryContext> implements Resolvable<EntityType<T>> {
     #private;
     readonly type: EntityType<T>;

package/orm/server/transaction.d.ts

@@ -1,15 +1,18 @@
+/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
 import { PgTransaction as DrizzlePgTransaction, type PgQueryResultHKT, type PgTransactionConfig } from 'drizzle-orm/pg-core';
 import type { Record } from '../../types/index.js';
 import type { Database } from './database.js';
 export type PgTransaction = DrizzlePgTransaction<PgQueryResultHKT, Record, Record>;
 export { DrizzlePgTransaction };
 export type TransactionConfig = PgTransactionConfig;
-export declare abstract class Transaction implements AsyncDisposable {
+export declare class Transaction implements AsyncDisposable {
     #private;
+    readonly pgTransaction: PgTransaction;
     readonly afterCommit: import("../../utils/async-hook/index.js").AsyncHook<never, never, unknown>;
     readonly parent?: Transaction;
     manualCommit: boolean;
-    constructor(parent?: Transaction);
+    constructor(pgTransaction: PgTransaction, parent?: Transaction);
+    static create(session: Database | PgTransaction, config?: TransactionConfig, parent?: Transaction): Promise<Transaction>;
     [Symbol.asyncDispose](): Promise<void>;
     withManualCommit(): void;
     /**
@@ -19,14 +22,6 @@ export declare abstract class Transaction implements AsyncDisposable {
     use<T>(handler: () => Promise<T>): Promise<T>;
     commit(): Promise<void>;
     rollback(): Promise<void>;
-    protected abstract _commit(): void | Promise<void>;
-    protected abstract _rollback(): void | Promise<void>;
-}
-export declare class DrizzleTransaction extends Transaction {
-    #private;
-    readonly pgTransaction: PgTransaction;
-    constructor(pgTransaction: PgTransaction, parent?: Transaction);
-    static create(session: Database | PgTransaction, config?: TransactionConfig, parent?: Transaction): Promise<DrizzleTransaction>;
     protected _commit(): Promise<void>;
     protected _rollback(): Promise<void>;
     private setTransactionResultPromise;

package/orm/server/transaction.js

@@ -1,16 +1,37 @@
+/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
 import { PgTransaction as DrizzlePgTransaction } from 'drizzle-orm/pg-core';
 import { DeferredPromise } from '../../promise/deferred-promise.js';
 import { asyncHook } from '../../utils/async-hook/index.js';
 export { DrizzlePgTransaction };
 export class Transaction {
+    #deferPromise = new DeferredPromise();
+    #pgTransactionResultPromise;
     #useCounter = 0;
     #done = false;
+    pgTransaction;
     afterCommit = asyncHook();
     parent;
     manualCommit = false;
-    constructor(parent) {
+    constructor(pgTransaction, parent) {
+        this.pgTransaction = pgTransaction;
         this.parent = parent;
     }
+    static async create(session, config, parent) {
+        const instancePromise = new DeferredPromise();
+        const pgTransactionResultPromise = session.transaction(async (tx) => {
+            const transaction = new Transaction(tx, parent);
+            instancePromise.resolve(transaction);
+            await transaction.#deferPromise;
+        }, config);
+        pgTransactionResultPromise.catch((error) => {
+            if (instancePromise.pending) {
+                instancePromise.reject(error);
+            }
+        });
+        const transaction = await instancePromise;
+        transaction.setTransactionResultPromise(pgTransactionResultPromise);
+        return transaction;
+    }
     async [Symbol.asyncDispose]() {
         if (!this.#done) {
             await this.rollback();
@@ -67,31 +88,6 @@ export class Transaction {
         this.#done = true;
         await this._rollback();
     }
-}
-export class DrizzleTransaction extends Transaction {
-    #deferPromise = new DeferredPromise();
-    pgTransaction;
-    #pgTransactionResultPromise;
-    constructor(pgTransaction, parent) {
-        super(parent);
-        this.pgTransaction = pgTransaction;
-    }
-    static async create(session, config, parent) {
-        const instancePromise = new DeferredPromise();
-        const pgTransactionResultPromise = session.transaction(async (tx) => {
-            const transaction = new DrizzleTransaction(tx, parent);
-            instancePromise.resolve(transaction);
-            await transaction.#deferPromise;
-        }, config);
-        pgTransactionResultPromise.catch((error) => {
-            if (instancePromise.pending) {
-                instancePromise.reject(error);
-            }
-        });
-        const transaction = await instancePromise;
-        transaction.setTransactionResultPromise(pgTransactionResultPromise);
-        return transaction;
-    }
     async _commit() {
         this.#deferPromise.resolve();
         await this.#pgTransactionResultPromise;

package/orm/server/transactional.js

@@ -4,7 +4,7 @@ import { Injector } from '../../injector/index.js';
 import { inject, injectAsync, runInInjectionContext } from '../../injector/inject.js';
 import { isDefined, isNull, isUndefined } from '../../utils/type-guards.js';
 import { Database } from './database.js';
-import { DrizzleTransaction, Transaction } from './transaction.js';
+import { Transaction } from './transaction.js';
 const transactionCache = new WeakMap();
 const { getCurrentTransactionalContext, isInTransactionalContext, runInTransactionalContext, tryGetCurrentTransactionalContext } = createContextProvider('Transactional');
 export { getCurrentTransactionalContext, isInTransactionalContext, runInTransactionalContext, tryGetCurrentTransactionalContext };
@@ -58,7 +58,7 @@ export class Transactional {
             }
         }
         const parentTransaction = tryGetTstdlTransaction(this.session);
-        const transaction = await DrizzleTransaction.create(this.session, config, parentTransaction);
+        const transaction = await Transaction.create(this.session, config, parentTransaction);
         transactionCache.set(transaction.pgTransaction, transaction);
         return transaction;
     }
@@ -77,7 +77,7 @@ export class Transactional {
             return this;
         }
         const context = {
-            session: session,
+            session,
             instances: this.#instances,
             data: this.getTransactionalContextData(),
         };

package/orm/tests/database-migration.test.d.ts

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

package/orm/tests/database-migration.test.js

@@ -0,0 +1,82 @@
+import { APPLICATION_INITIALIZER } from '../../application/application.js';
+import { runInInjectionContext } from '../../injector/inject.js';
+import { DATABASE_MIGRATION, provideDatabaseMigrator, runDatabaseMigrations } from '../../orm/server/migration.js';
+import { setupIntegrationTest } from '../../testing/index.js';
+import { describe, expect, it } from 'vitest';
+describe('Database Migration Orchestration', () => {
+    it('should have DATABASE_MIGRATION token defined', () => {
+        expect(DATABASE_MIGRATION).toBeDefined();
+    });
+    it('should provide database migrator as application initializer', () => {
+        const provider = provideDatabaseMigrator();
+        expect(provider.provide).toBe(APPLICATION_INITIALIZER);
+        expect(provider.useValue).toBe(runDatabaseMigrations);
+        expect(provider.multi).toBe(true);
+    });
+    it('should register and resolve a migration', async () => {
+        const { injector } = await setupIntegrationTest();
+        let migrated = false;
+        const migration = {
+            name: 'test-migration',
+            migrate: async () => {
+                migrated = true;
+            },
+        };
+        injector.register(DATABASE_MIGRATION, { useValue: migration }, { multi: true });
+        const migrations = injector.resolveAll(DATABASE_MIGRATION);
+        expect(migrations).toHaveLength(1);
+        const firstMigration = migrations[0];
+        expect(firstMigration.name).toBe('test-migration');
+        await firstMigration.migrate();
+        expect(migrated).toBe(true);
+    });
+    it('should run migrations in the correct order based on dependencies', async () => {
+        const { injector } = await setupIntegrationTest();
+        const executionOrder = [];
+        const migrationA = {
+            name: 'migration-a',
+            migrate: async () => {
+                executionOrder.push('a');
+            },
+            dependencies: ['migration-b'],
+        };
+        const migrationB = {
+            name: 'migration-b',
+            migrate: async () => {
+                executionOrder.push('b');
+            },
+        };
+        const migrationC = {
+            name: 'migration-c',
+            migrate: async () => {
+                executionOrder.push('c');
+            },
+            dependencies: ['migration-a'],
+        };
+        injector.register(DATABASE_MIGRATION, { useValue: migrationA }, { multi: true });
+        injector.register(DATABASE_MIGRATION, { useValue: migrationB }, { multi: true });
+        injector.register(DATABASE_MIGRATION, { useValue: migrationC }, { multi: true });
+        await runInInjectionContext(injector, async () => {
+            await runDatabaseMigrations();
+        });
+        expect(executionOrder).toEqual(['b', 'a', 'c']);
+    });
+    it('should throw on circular dependency', async () => {
+        const { injector } = await setupIntegrationTest();
+        const migrationA = {
+            name: 'migration-a',
+            migrate: async () => { },
+            dependencies: ['migration-b'],
+        };
+        const migrationB = {
+            name: 'migration-b',
+            migrate: async () => { },
+            dependencies: ['migration-a'],
+        };
+        injector.register(DATABASE_MIGRATION, { useValue: migrationA }, { multi: true });
+        injector.register(DATABASE_MIGRATION, { useValue: migrationB }, { multi: true });
+        await runInInjectionContext(injector, async () => {
+            await expect(runDatabaseMigrations()).rejects.toThrow('Circular dependency detected');
+        });
+    });
+});

package/orm/tests/encryption.test.js

@@ -1,4 +1,3 @@
-import { DetailsError } from '../../errors/index.js';
 import { describe, expect, test } from 'vitest';
 import { decryptBytes, encryptBytes } from '../server/encryption.js';
 describe('ORM Encryption', () => {
@@ -12,15 +11,15 @@ describe('ORM Encryption', () => {
         const decrypted = await decryptBytes(encrypted, key);
         expect(new TextDecoder().decode(decrypted)).toBe('Hello, ORM Encryption!');
     });
-    test('should throw DetailsError on corrupted data', async () => {
+    test('should throw Error on corrupted data', async () => {
         const key = await generateKey();
         const data = new TextEncoder().encode('Corrupt me');
         const encrypted = await encryptBytes(data, key);
         // Corrupt the ciphertext (last byte)
         const lastIndex = encrypted.length - 1;
         encrypted[lastIndex] = encrypted[lastIndex] ^ 1;
-        await expect(decryptBytes(encrypted, key)).rejects.toThrow(DetailsError);
-        await expect(decryptBytes(encrypted, key)).rejects.toThrow('Decrypt error');
+        await expect(decryptBytes(encrypted, key)).rejects.toThrow(Error);
+        await expect(decryptBytes(encrypted, key)).rejects.toThrow('Decryption failed.');
     });
     test('should throw error on invalid version', async () => {
         const key = await generateKey();

package/orm/utils.d.ts

@@ -4,8 +4,8 @@
  */
 import { type PropertyMetadata } from '../reflection/registry.js';
 import type { AbstractConstructor } from '../types/index.js';
-import type { InheritanceMetadata } from './decorators.js';
-import type { BaseEntity, Entity } from './entity.js';
+import type { InheritanceMetadata, OrmTableReflectionData } from './decorators.js';
+import type { BaseEntity, Entity, EntityType } from './entity.js';
 /**
  * Converts an array of entities into a Map keyed by entity ID.
  * @template T - The entity type, must extend `Entity` (i.e., have an `id` property).
@@ -24,3 +24,18 @@ export declare function getEntityIds(entities: (Entity | BaseEntity)[]): string[
 export declare function isChildEntity(type: AbstractConstructor): boolean;
 export declare function getInheritanceMetadata(type: AbstractConstructor): InheritanceMetadata | undefined;
 export declare function getOwnProperties(type: AbstractConstructor): PropertyMetadata[];
+/**
+ * Gets the database schema name for a given entity type, traversing the inheritance hierarchy.
+ * @param type The entity class.
+ * @param fallback Optional fallback schema name if none is defined in metadata.
+ * @returns The resolved schema name.
+ */
+export declare function getEntitySchema(type: AbstractConstructor, fallback?: string): string;
+/**
+ * Gets the database table name for a given entity type, traversing the inheritance hierarchy.
+ * @param type The entity class.
+ * @returns The resolved table name.
+ */
+export declare function getEntityTableName(type: AbstractConstructor): string;
+export declare function getDefaultTableName(type: EntityType): string;
+export declare function getTableReflectionDatas(type: EntityType): OrmTableReflectionData[];