uql-orm 0.22.0 → 0.24.0

package/dist/migrate/introspection/abstractSqlSchemaIntrospector.js

@@ -29,9 +29,8 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
     // Template Methods (shared control flow)
     // ============================================================================
     async getTableSchema(tableName) {
-        const querier = await this.getQuerier();
-        const read = createTableRowReader(querier);
-        try {
+        return this.withSqlQuerier(async (querier) => {
+            const read = createTableRowReader(querier);
             const exists = await this.tableExistsInternal(read, tableName);
             if (!exists) {
                 return undefined;
@@ -49,37 +48,28 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
                 indexes,
                 foreignKeys,
             };
-        }
-        finally {
-            await querier.release();
-        }
+        });
     }
     async getTableNames() {
-        const querier = await this.getQuerier();
-        try {
+        return this.withSqlQuerier(async (querier) => {
             const results = await querier.all(this.getTableNamesQuery());
             return results.map((row) => this.mapTableNameRow(row));
-        }
-        finally {
-            await querier.release();
-        }
+        });
     }
     async tableExists(tableName) {
-        const querier = await this.getQuerier();
-        try {
-            return this.tableExistsInternal(createTableRowReader(querier), tableName);
-        }
-        finally {
-            await querier.release();
-        }
+        return this.withSqlQuerier((querier) => this.tableExistsInternal(createTableRowReader(querier), tableName));
     }
-    async getQuerier() {
-        const querier = await this.pool.getQuerier();
-        if (!isSqlQuerier(querier)) {
-            await querier.release();
-            throw new Error(`${this.constructor.name} requires a SQL-based querier`);
-        }
-        return querier;
+    /**
+     * Introspection reads, so `withQuerier` rather than `transaction`: the pool owns the release either
+     * way, and wrapping catalogue queries in a transaction would hold one open for nothing.
+     */
+    withSqlQuerier(task) {
+        return this.pool.withQuerier((querier) => {
+            if (!isSqlQuerier(querier)) {
+                throw new Error(`${this.constructor.name} requires a SQL-based querier`);
+            }
+            return task(querier);
+        });
     }
     async tableExistsInternal(read, tableName) {
         const results = await read(this.tableExistsQuery(), this.tableExistsParams(tableName));

package/dist/migrate/introspection/mongoIntrospector.js

@@ -58,14 +58,15 @@ export class MongoSchemaIntrospector {
         return ast;
     }
     async getTableSchema(tableName) {
-        const querier = await this.pool.getQuerier();
-        try {
+        return this.pool.withQuerier(async (querier) => {
             const { db } = querier;
             const collections = await db.listCollections({ name: tableName }).toArray();
             if (collections.length === 0) {
                 return undefined;
             }
-            // MongoDB doesn't have a fixed schema, but we can look at the indexes
+            // MongoDB doesn't have a fixed schema, but we can look at the indexes. Annotated rather than
+            // inferred: the driver's `indexes()` is overloaded and resolves to `any` on some versions, which
+            // silently made every field below unchecked.
             const indexes = await db.collection(tableName).indexes();
             return {
                 name: tableName,
@@ -76,21 +77,14 @@ export class MongoSchemaIntrospector {
                     unique: !!idx.unique,
                 })),
             };
-        }
-        finally {
-            await querier.release();
-        }
+        });
     }
     async getTableNames() {
-        const querier = await this.pool.getQuerier();
-        try {
+        return this.pool.withQuerier(async (querier) => {
             const { db } = querier;
             const collections = await db.listCollections().toArray();
             return collections.map((c) => c.name);
-        }
-        finally {
-            await querier.release();
-        }
+        });
     }
     async tableExists(tableName) {
         const names = await this.getTableNames();

package/dist/migrate/migrator.js

@@ -5,7 +5,7 @@ import { getEntities, getMeta } from '../entity/index.js';
 import { introspectSchema } from '../schema/index.js';
 import { isKnownMigratorDialect, isSqlQuerier } from '../type/index.js';
 import { LoggerWrapper } from '../util/index.js';
-import { acquireQuerierForMigrations } from './acquireQuerierForMigrations.js';
+import { withQuerierForMigrations, withSqlQuerierForMigrations } from './acquireQuerierForMigrations.js';
 import { buildSqlQuerierMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitSqlRunCalls, } from './codegen/migrationFile.js';
 import { runMongoCommand } from './generator/mongoCommand.js';
 import { MongoSchemaIntrospector, MysqlSchemaIntrospector, PostgresSchemaIntrospector, SqliteSchemaIntrospector, } from './introspection/index.js';
@@ -185,49 +185,42 @@ export class Migrator {
      */
     async runMigration(migration, direction) {
         const startTime = Date.now();
-        const querier = await acquireQuerierForMigrations(this.pool);
-        if (!isSqlQuerier(querier)) {
-            await querier.release();
-            throw new Error('Migrator requires a SQL-based querier');
-        }
-        try {
-            this.logger.logMigration(`${direction === 'up' ? 'Running' : 'Reverting'} migration: ${migration.name}`);
-            await querier.beginTransaction();
-            if (direction === 'up') {
-                await migration.up(querier);
-                // Log within the same transaction
-                await this.storage.logWithQuerier(querier, migration.name);
+        return withSqlQuerierForMigrations(this.pool, 'Migrator', async (querier) => {
+            try {
+                this.logger.logMigration(`${direction === 'up' ? 'Running' : 'Reverting'} migration: ${migration.name}`);
+                await querier.transaction(async () => {
+                    if (direction === 'up') {
+                        await migration.up(querier);
+                        // Log within the same transaction
+                        await this.storage.logWithQuerier(querier, migration.name);
+                    }
+                    else {
+                        await migration.down(querier);
+                        // Unlog within the same transaction
+                        await this.storage.unlogWithQuerier(querier, migration.name);
+                    }
+                });
+                const duration = Date.now() - startTime;
+                this.logger.logMigration(`Migration ${migration.name} ${direction === 'up' ? 'applied' : 'reverted'} in ${duration}ms`);
+                return {
+                    name: migration.name,
+                    direction,
+                    duration,
+                    success: true,
+                };
             }
-            else {
-                await migration.down(querier);
-                // Unlog within the same transaction
-                await this.storage.unlogWithQuerier(querier, migration.name);
+            catch (error) {
+                const duration = Date.now() - startTime;
+                this.logger.logError(`Migration ${migration.name} failed: ${error.message}`, error);
+                return {
+                    name: migration.name,
+                    direction,
+                    duration,
+                    success: false,
+                    error: error,
+                };
             }
-            await querier.commitTransaction();
-            const duration = Date.now() - startTime;
-            this.logger.logMigration(`Migration ${migration.name} ${direction === 'up' ? 'applied' : 'reverted'} in ${duration}ms`);
-            return {
-                name: migration.name,
-                direction,
-                duration,
-                success: true,
-            };
-        }
-        catch (error) {
-            await querier.rollbackTransaction();
-            const duration = Date.now() - startTime;
-            this.logger.logError(`Migration ${migration.name} failed: ${error.message}`, error);
-            return {
-                name: migration.name,
-                direction,
-                duration,
-                success: false,
-                error: error,
-            };
-        }
-        finally {
-            await querier.release();
-        }
+        });
     }
     /**
      * Generate a new migration file
@@ -334,13 +327,7 @@ export class Migrator {
      */
     async syncForce() {
         await this.ensureSchemaGenerator();
-        const querier = await acquireQuerierForMigrations(this.pool);
-        if (!isSqlQuerier(querier)) {
-            await querier.release();
-            throw new Error('Migrator requires a SQL-based querier');
-        }
-        try {
-            await querier.beginTransaction();
+        await withSqlQuerierForMigrations(this.pool, 'Migrator', (querier) => querier.transaction(async () => {
             // Drop all tables first (in reverse order for foreign keys)
             for (const entity of [...this.entities].reverse()) {
                 const tableName = this.generator.resolveTableName(entity, getMeta(entity));
@@ -356,16 +343,8 @@ export class Migrator {
                     await querier.run(createSql);
                 }
             }
-            await querier.commitTransaction();
-            this.logger.logSchema('Schema sync (force) completed');
-        }
-        catch (error) {
-            await querier.rollbackTransaction();
-            throw error;
-        }
-        finally {
-            await querier.release();
-        }
+        }));
+        this.logger.logSchema('Schema sync (force) completed');
     }
     /**
      * Safely synchronizes the schema by only adding missing tables and columns.
@@ -442,26 +421,12 @@ export class Migrator {
         return filteredDiff;
     }
     async executeSyncStatements(statements, options) {
-        const querier = await acquireQuerierForMigrations(this.pool);
-        try {
-            if (this.dialectName === 'mongodb') {
-                await this.executeMongoSyncStatements(statements, options, querier);
-            }
-            else {
-                await this.executeSqlSyncStatements(statements, options, querier);
-            }
-            if (options.logging)
-                this.logger.logSchema('Schema synchronization completed');
-        }
-        catch (error) {
-            if (this.dialectName !== 'mongodb' && isSqlQuerier(querier)) {
-                await querier.rollbackTransaction();
-            }
-            throw error;
-        }
-        finally {
-            await querier.release();
-        }
+        // Mongo creates collections and indexes outside any transaction, so only the SQL path opens one.
+        await withQuerierForMigrations(this.pool, (querier) => this.dialectName === 'mongodb'
+            ? this.executeMongoSyncStatements(statements, options, querier)
+            : querier.transaction(() => this.executeSqlSyncStatements(statements, options, querier)));
+        if (options.logging)
+            this.logger.logSchema('Schema synchronization completed');
     }
     async executeMongoSyncStatements(statements, options, querier) {
         for (const statement of statements) {
@@ -474,13 +439,11 @@ export class Migrator {
         if (!isSqlQuerier(querier)) {
             throw new Error('Migrator requires a SQL-based querier for this dialect');
         }
-        await querier.beginTransaction();
         for (const sql of statements) {
             if (options.logging)
                 this.logger.logSchema(`Executing: ${sql}`);
             await querier.run(sql);
         }
-        await querier.commitTransaction();
     }
     /**
      * Get migration status

package/dist/migrate/storage/databaseStorage.d.ts

@@ -3,6 +3,8 @@ import type { MigrationStorage, QuerierPool, SqlQuerier } from '../../type/index
  * Stores migration state in a database table.
  * Uses the querier's dialect for escaping and placeholders.
  */
+/** Where executed migrations are recorded when the config does not name a table. */
+export declare const DEFAULT_MIGRATIONS_TABLE = "uql_migrations";
 export declare class DatabaseMigrationStorage implements MigrationStorage {
     private readonly pool;
     private readonly tableName;

package/dist/migrate/storage/databaseStorage.js

@@ -1,33 +1,26 @@
-import { isSqlQuerier } from '../../type/index.js';
-import { acquireQuerierForMigrations } from '../acquireQuerierForMigrations.js';
+import { withSqlQuerierForMigrations } from '../acquireQuerierForMigrations.js';
 /**
  * Stores migration state in a database table.
  * Uses the querier's dialect for escaping and placeholders.
  */
+/** Where executed migrations are recorded when the config does not name a table. */
+export const DEFAULT_MIGRATIONS_TABLE = 'uql_migrations';
 export class DatabaseMigrationStorage {
     pool;
     tableName;
     storageInitialized = false;
     constructor(pool, options = {}) {
         this.pool = pool;
-        this.tableName = options.tableName ?? 'uql_migrations';
+        this.tableName = options.tableName ?? DEFAULT_MIGRATIONS_TABLE;
     }
     async ensureStorage() {
         if (this.storageInitialized) {
             return;
         }
-        const querier = await acquireQuerierForMigrations(this.pool);
-        if (!isSqlQuerier(querier)) {
-            await querier.release();
-            throw new Error('DatabaseMigrationStorage requires a SQL-based querier');
-        }
-        try {
+        await withSqlQuerierForMigrations(this.pool, 'DatabaseMigrationStorage', async (querier) => {
             await this.createTableIfNotExists(querier);
             this.storageInitialized = true;
-        }
-        finally {
-            await querier.release();
-        }
+        });
     }
     async createTableIfNotExists(querier) {
         const { dialect } = querier;
@@ -41,20 +34,12 @@ export class DatabaseMigrationStorage {
     }
     async executed() {
         await this.ensureStorage();
-        const querier = await acquireQuerierForMigrations(this.pool);
-        if (!isSqlQuerier(querier)) {
-            await querier.release();
-            throw new Error('DatabaseMigrationStorage requires a SQL-based querier');
-        }
-        try {
+        return withSqlQuerierForMigrations(this.pool, 'DatabaseMigrationStorage', async (querier) => {
             const { dialect } = querier;
             const sql = /*sql*/ `SELECT ${dialect.escapeId('name')} FROM ${dialect.escapeId(this.tableName)} ORDER BY ${dialect.escapeId('name')} ASC`;
             const results = await querier.all(sql);
             return results.map((r) => r.name);
-        }
-        finally {
-            await querier.release();
-        }
+        });
     }
     /**
      * Log a migration as executed - uses provided querier (within transaction)