@tstdl/base 0.93.140 → 0.93.142

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,11 +1,8 @@
-/**
- * @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 './bootstrap.js';
+export * from './extension.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,8 @@
-/**
- * @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 './bootstrap.js';
+export * from './extension.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,18 @@
+import { Injector } 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 runDatabaseMigrationsCore(migrations?: DatabaseMigration[]): Promise<void>;

package/orm/server/migration.js

@@ -0,0 +1,58 @@
+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';
+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 async function runDatabaseMigrationsCore(migrations) {
+    const injector = inject(Injector);
+    const logger = inject(Logger, 'DatabaseMigrationOrchestrator');
+    const actualMigrations = migrations ?? injectAll(DATABASE_MIGRATION, undefined, { optional: true });
+    if (actualMigrations.length == 0) {
+        return;
+    }
+    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) {
+    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

@@ -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';
@@ -18,7 +19,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/repository.js

@@ -1,3 +1,4 @@
+/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
 var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -26,7 +27,7 @@ import { millisecondsPerSecond } from '../../utils/units.js';
 import { Entity } from '../entity.js';
 import { distance, isSimilar, isStrictWordSimilar, isWordSimilar, TRANSACTION_TIMESTAMP, tsHeadline, tsRankCd } from '../sqls/index.js';
 import { getInheritanceMetadata, isChildEntity } from '../utils.js';
-import { getColumnDefinitions, getColumnDefinitionsMap, getDrizzleTableFromType, getTableColumnDefinitions, isTableOwning } from './drizzle/schema-converter.js';
+import { getColumnDefinitions, getColumnDefinitionsMap, getDrizzleTableFromType, getPrimaryKeyColumnDefinitions, getPrimaryKeyColumns, getTableColumnDefinitions, isTableOwning } from './drizzle/schema-converter.js';
 import { convertQuery, getTsQuery, getTsVector, resolveTargetColumn } from './query-converter.js';
 import { EntityRepositoryConfig } from './repository-config.js';
 import { ENCRYPTION_SECRET } from './tokens.js';
@@ -54,6 +55,8 @@ let EntityRepository = class EntityRepository extends Transactional {
     #baseTableWithMetadata = this.#baseTable;
     #columnDefinitions = this.#context.columnDefinitions ?? getColumnDefinitions(this.#table);
     #columnDefinitionsMap = this.#context.columnDefinitionsMap ?? getColumnDefinitionsMap(this.#table);
+    #primaryKeyColumns = getPrimaryKeyColumns(this.type, this.#table);
+    #primaryKeyColumnNames = this.#primaryKeyColumns.map((column) => column.name);
     #joinedTables = this.#tablesChain.filter((info) => info.table != this.#table).map((info) => info.table);
     #inheritanceMetadata = getInheritanceMetadata(this.type);
     #subclasses = this.#inheritanceMetadata?.subclasses ?? [];
@@ -64,6 +67,7 @@ let EntityRepository = class EntityRepository extends Transactional {
             type: subclass,
             table,
             tablesChain,
+            primaryKeyColumns: getPrimaryKeyColumns(subclass, table),
             columnDefinitions: getColumnDefinitions(table),
             discriminatorValue: reflectionRegistry.getMetadata(subclass)?.data.tryGet('orm')?.childEntity?.discriminatorValue, // eslint-disable-line @typescript-eslint/no-non-null-asserted-optional-chain
         };
@@ -84,7 +88,7 @@ let EntityRepository = class EntityRepository extends Transactional {
     })();
     #defaultSelection = fromEntries(this.#columnDefinitions.map((column) => [column.name, this.resolveTargetColumn(column)]));
     #upsertManyExcludedMapping = fromEntries(this.#tableColumnDefinitions
-        .filter((column) => column.name != this.#table.id.name)
+        .filter((column) => !this.#primaryKeyColumnNames.includes(column.name))
         .map((column) => [column.name, sql `excluded.${sql.identifier(this.getColumn(column).name)}`]));
     #expirationColumns = this.#columnDefinitions.filter((column) => isDefined(column.reflectionData?.expirationField));
     #softExpirationColumns = this.#expirationColumns.filter((column) => column.reflectionData.expirationField.mode == 'soft');
@@ -679,7 +683,7 @@ let EntityRepository = class EntityRepository extends Transactional {
             const transformContext = await this.getTransformContext();
             const results = {};
             let generatedId = entity.id;
-            for (const { table, columnDefinitions } of this.#tablesChain) {
+            for (const { table, columnDefinitions, primaryKeyColumns } of this.#tablesChain) {
                 const tableColumnNames = columnDefinitions.map((def) => def.name);
                 const tableColumnNamesSet = new Set(tableColumnNames);
                 const filteredTarget = isDefined(wheres?.target) ? this.filterQuery(wheres.target, tableColumnNamesSet) : undefined;
@@ -695,7 +699,7 @@ let EntityRepository = class EntityRepository extends Transactional {
                 });
                 const tableTarget = isTargetInTable
                     ? targetPaths.map((path) => resolveTargetColumn(path, table, this.#columnDefinitionsMap))
-                    : [table.id];
+                    : primaryKeyColumns;
                 const [row] = await transaction.pgTransaction
                     .insert(table)
                     .values({ ...columns, ...(isDefined(generatedId) ? { id: generatedId } : {}) })
@@ -758,7 +762,7 @@ let EntityRepository = class EntityRepository extends Transactional {
             if (generatedIds.length != entities.length) {
                 generatedIds = undefined;
             }
-            for (const { table, columnDefinitions } of this.#tablesChain) {
+            for (const { table, columnDefinitions, primaryKeyColumns } of this.#tablesChain) {
                 const tableColumnNames = columnDefinitions.map((def) => def.name);
                 const tableColumnNamesSet = new Set(tableColumnNames);
                 const filteredTarget = isDefined(wheres?.target) ? this.filterQuery(wheres.target, tableColumnNamesSet) : undefined;
@@ -772,10 +776,11 @@ let EntityRepository = class EntityRepository extends Transactional {
                     }
                     return columns;
                 }));
+                const primaryKeyColumnNames = primaryKeyColumns.map((pk) => pk.name);
                 const mappedUpdate = isDefined(update)
                     ? await this._mapToTableUpdate(update, transformContext, table, columnDefinitions)
                     : {
-                        ...fromEntries(columnDefinitions.filter((column) => column.name != table.id.name).map((column) => [column.name, sql `excluded.${sql.identifier(resolveTargetColumn(column, table, this.#columnDefinitionsMap).name)}`])),
+                        ...fromEntries(columnDefinitions.filter((column) => !primaryKeyColumnNames.includes(column.name)).map((column) => [column.name, sql `excluded.${sql.identifier(resolveTargetColumn(column, table, this.#columnDefinitionsMap).name)}`])),
                         ...((table == this.#baseTable) ? this._getMetadataUpdate(update) : undefined),
                     };
                 const targetPaths = toArray(target);
@@ -785,7 +790,7 @@ let EntityRepository = class EntityRepository extends Transactional {
                 });
                 const tableTarget = isTargetInTable
                     ? targetPaths.map((path) => resolveTargetColumn(path, table, this.#columnDefinitionsMap))
-                    : [table.id];
+                    : primaryKeyColumns;
                 const rows = await transaction.pgTransaction
                     .insert(table)
                     .values(values)
@@ -1455,7 +1460,10 @@ let EntityRepository = class EntityRepository extends Transactional {
         return sql `${this.#baseTableWithMetadata.attributes} || ${JSON.stringify(attributes)}::jsonb`;
     }
     applyJoins(dbQuery) {
-        return this.#joinedTables.reduce((query, joinedTable) => query.innerJoin(joinedTable, eq(this.#table.id, joinedTable.id)), dbQuery);
+        return this.#tablesChain.filter((info) => info.table != this.#table).reduce((query, info) => {
+            const conditions = info.primaryKeyColumnDefinitions.map((def) => eq(this.#table[def.name], info.table[def.name]));
+            return query.innerJoin(info.table, and(...conditions));
+        }, dbQuery);
     }
     getTablesChain(type) {
         const chain = [];
@@ -1463,7 +1471,9 @@ let EntityRepository = class EntityRepository extends Transactional {
         while (true) {
             const table = getDrizzleTableFromType(currentType, this.#schema);
             const columnDefinitions = getTableColumnDefinitions(table);
-            chain.unshift({ table, type: currentType, columnDefinitions });
+            const primaryKeyColumnDefinitions = getPrimaryKeyColumnDefinitions(currentType, table);
+            const primaryKeyColumns = getPrimaryKeyColumns(currentType, table, primaryKeyColumnDefinitions);
+            chain.unshift({ table, type: currentType, columnDefinitions, primaryKeyColumnDefinitions, primaryKeyColumns });
             const parentType = reflectionRegistry.getMetadata(currentType)?.parent;
             if (isNullOrUndefined(parentType) || !isTableOwning(parentType)) {
                 break;

package/orm/server/transaction.d.ts

@@ -1,15 +1,19 @@
+/** 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);
+    get isDone(): boolean;
+    constructor(pgTransaction: PgTransaction, parent?: Transaction);
+    static create(session: Database | PgTransaction, config?: TransactionConfig, parent?: Transaction): Promise<Transaction>;
     [Symbol.asyncDispose](): Promise<void>;
     withManualCommit(): void;
     /**
@@ -19,14 +23,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,40 @@
+/** 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) {
+    get isDone() {
+        return this.#done;
+    }
+    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 +91,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-extension.test.js

@@ -0,0 +1,63 @@
+import { sql } from 'drizzle-orm';
+import { describe, expect, it, vi } from 'vitest';
+import { APPLICATION_INITIALIZER } from '../../application/application.js';
+import { runInInjectionContext } from '../../injector/inject.js';
+import { bootstrapOrm, provideOrm } from '../../orm/server/bootstrap.js';
+import { Database } from '../../orm/server/database.js';
+import { DATABASE_EXTENSION, registerDatabaseExtension, runDatabaseExtensions } from '../../orm/server/extension.js';
+import { DATABASE_MIGRATION } from '../../orm/server/migration.js';
+import { setupIntegrationTest } from '../../testing/index.js';
+describe('Database Extension Registration', () => {
+    it('should have DATABASE_EXTENSION token defined', () => {
+        expect(DATABASE_EXTENSION).toBeDefined();
+    });
+    it('should provide ORM bootstrap as application initializer', () => {
+        const provider = provideOrm();
+        expect(provider.provide).toBe(APPLICATION_INITIALIZER);
+        expect(provider.useValue).toBe(bootstrapOrm);
+        expect(provider.multi).toBe(true);
+    });
+    it('should register an extension', async () => {
+        const { injector } = await setupIntegrationTest();
+        registerDatabaseExtension('btree_gin', { injector });
+        const extensions = injector.resolveAll(DATABASE_EXTENSION);
+        expect(extensions).toHaveLength(1);
+        expect(extensions[0].name).toBe('btree_gin');
+    });
+    it('should run extensions', async () => {
+        const { injector } = await setupIntegrationTest();
+        const database = injector.resolve(Database);
+        const executeSpy = vi.spyOn(database, 'execute').mockResolvedValue({});
+        registerDatabaseExtension('btree_gin', { injector });
+        registerDatabaseExtension('uuid-ossp', { injector });
+        await runInInjectionContext(injector, async () => {
+            await runDatabaseExtensions();
+        });
+        expect(executeSpy).toHaveBeenCalledWith(sql.raw('CREATE EXTENSION IF NOT EXISTS "btree_gin"'));
+        expect(executeSpy).toHaveBeenCalledWith(sql.raw('CREATE EXTENSION IF NOT EXISTS "uuid-ossp"'));
+    });
+    it('should bootstrap ORM (extensions and migrations)', async () => {
+        const { injector } = await setupIntegrationTest();
+        const database = injector.resolve(Database);
+        const executeSpy = vi.spyOn(database, 'execute').mockResolvedValue({});
+        registerDatabaseExtension('btree_gin', { injector });
+        let migrated = false;
+        const migration = {
+            name: 'test-migration',
+            migrate: async () => {
+                migrated = true;
+            },
+        };
+        injector.register(DATABASE_MIGRATION, { useValue: migration }, { multi: true });
+        await runInInjectionContext(injector, async () => {
+            await bootstrapOrm();
+        });
+        // Check extension call
+        expect(executeSpy).toHaveBeenCalledWith(sql.raw('CREATE EXTENSION IF NOT EXISTS "btree_gin"'));
+        // Check migration ran
+        expect(migrated).toBe(true);
+        // Check locking
+        expect(executeSpy).toHaveBeenCalledWith(sql `SELECT pg_advisory_lock(${123456789})`);
+        expect(executeSpy).toHaveBeenCalledWith(sql `SELECT pg_advisory_unlock(${123456789})`);
+    });
+});

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

@@ -0,0 +1,83 @@
+import { APPLICATION_INITIALIZER } from '../../application/application.js';
+import { runInInjectionContext } from '../../injector/inject.js';
+import { bootstrapOrm, provideOrm } from '../../orm/server/bootstrap.js';
+import { DATABASE_MIGRATION } 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 ORM bootstrap as application initializer', () => {
+        const provider = provideOrm();
+        expect(provider.provide).toBe(APPLICATION_INITIALIZER);
+        expect(provider.useValue).toBe(bootstrapOrm);
+        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 bootstrapOrm();
+        });
+        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(bootstrapOrm()).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/tests/repository-compound-primary-key.test.d.ts

@@ -0,0 +1,2 @@
+/** biome-ignore-all lint/nursery/noExcessiveClassesPerFile: <explanation> */
+export {};