uql-orm 0.22.0 → 0.23.0

package/dist/entity/metadata/definition.js

@@ -1,52 +1,45 @@
 import { getKeys, hasKeys, lowerFirst, normalizeIndexColumn, upperFirst } from '../../util/index.js';
-import { LoggerWrapper } from '../../util/logger.js';
+import { ownRegistrations } from '../decorator/bag.js';
 // Held on `globalThis` via the global symbol registry so a single metadata map survives multiple
-// evaluations of this module (HMR, duplicated/federated bundles, ESM+CJS dual-loading).
+// evaluations of this module (HMR, duplicated/federated bundles, ESM+CJS dual-loading). Version-suffixed
+// because v1 changed the `FieldOptions` shape: a tree holding both majors gets two maps rather than one
+// map with entries the other major cannot read.
 const holder = globalThis;
-const metaKey = Symbol.for('uql-orm/entity/metadata');
+const metaKey = Symbol.for('uql-orm/entity/metadata/v1');
 const metas = holder[metaKey] ?? new Map();
 holder[metaKey] = metas;
-const registrationLogger = new LoggerWrapper(true);
-/**
- * Append a composite index entry with normalized `unique` (default false) and columns. Normalizing
- * here is what lets the dialects render one shape instead of re-parsing the authored sugar.
- */
-export function appendEntityIndex(meta, index) {
-    if (!meta.indexes)
-        meta.indexes = [];
-    meta.indexes.push({ ...index, unique: index.unique ?? false, columns: index.columns.map(normalizeIndexColumn) });
-}
 export function defineField(entity, key, opts = {}) {
     const meta = ensureMeta(entity);
-    if (opts.type) {
-        opts = { ...opts, typeInferred: false };
-    }
-    else {
-        opts = { ...opts, type: inferType(entity, key), typeInferred: true };
+    if (!opts.type && !opts.references && !opts.virtual) {
+        throw new TypeError(`'${entity.name}.${key}' needs a 'type'. Declare it - '@Field({ type: String })' - or point the field ` +
+            "at another entity with 'references', which resolves the column type from its primary key.");
     }
     const fieldKey = key;
-    meta.fields[fieldKey] = { ...meta.fields[fieldKey], ...{ name: key, ...opts } };
+    // Flagged when the author gave `references` but no `type`, so schema generation knows to resolve the
+    // column from the referenced primary key (picking up its `columnType`, length and chained keys)
+    // instead of treating whatever ends up in `type` as deliberate.
+    const resolved = opts.type ? opts : { ...opts, typeFromReference: true };
+    meta.fields[fieldKey] = { ...meta.fields[fieldKey], ...{ name: key, ...resolved } };
     return meta;
 }
 export function defineId(entity, key, opts) {
     const meta = ensureMeta(entity);
     const id = getIdKey(meta);
     if (id) {
-        registrationLogger.logInfo(`Overriding ID property for '${entity.name}' from '${id}' to '${key}'`);
+        // A subclass narrowing the inherited primary key: drop the old one so exactly one stays marked.
         delete meta.fields[id];
     }
     return defineField(entity, key, { ...opts, isId: true });
 }
+// `RelationOptions` is parameterized by the *target* entity, which is independent of the owner `E`, so it
+// is left at its default here rather than tied to the class being registered.
 export function defineRelation(entity, key, opts) {
-    const resolved = opts.entity
-        ? opts
-        : (() => {
-            const inferredType = inferEntityType(entity, key);
-            return { ...opts, entity: () => inferredType };
-        })();
+    if (!opts.entity) {
+        throw new TypeError(`'${entity.name}.${key}' needs an 'entity' getter, e.g. '@ManyToOne({ entity: () => Company })'.`);
+    }
     const meta = ensureMeta(entity);
     const relKey = key;
-    meta.relations[relKey] = { ...meta.relations[relKey], ...resolved };
+    meta.relations[relKey] = { ...meta.relations[relKey], ...opts };
     return meta;
 }
 export function defineHook(entity, methodName, event) {
@@ -58,9 +51,15 @@ export function defineHook(entity, methodName, event) {
     meta.hooks[event].push({ methodName });
     return meta;
 }
+/**
+ * Declares a composite index. `unique` and the authored column sugar are normalized here, which is what
+ * lets the dialects render one shape instead of re-parsing it.
+ */
 export function defineIndex(entity, index) {
     const meta = ensureMeta(entity);
-    appendEntityIndex(meta, index);
+    if (!meta.indexes)
+        meta.indexes = [];
+    meta.indexes.push({ ...index, unique: index.unique ?? false, columns: index.columns.map(normalizeIndexColumn) });
     return meta;
 }
 export function defineFilter(entity, name, opts) {
@@ -76,9 +75,12 @@ export function defineFilter(entity, name, opts) {
     meta.filters[name] = opts;
     return meta;
 }
-function applyBulkFields(entity, fields) {
-    for (const key of Object.keys(fields)) {
-        const spec = fields[key];
+/**
+ * Feeds fields, relations and hooks into the `define*` primitives, so the decorators and the imperative
+ * API converge on one registration path before anything is finalized.
+ */
+export function applyMembers(entity, specs) {
+    for (const [key, spec] of Object.entries(specs?.fields ?? {})) {
         if (!spec)
             continue;
         if (spec.isId) {
@@ -88,64 +90,43 @@ function applyBulkFields(entity, fields) {
             defineField(entity, key, spec);
         }
     }
-}
-function applyBulkRelations(entity, relations) {
-    for (const key of Object.keys(relations)) {
-        const spec = relations[key];
+    for (const [key, spec] of Object.entries(specs?.relations ?? {})) {
         if (spec)
             defineRelation(entity, key, spec);
     }
-}
-function applyBulkIndexes(entity, indexes) {
-    const meta = ensureMeta(entity);
-    for (const idx of indexes) {
-        appendEntityIndex(meta, idx);
-    }
-}
-function applyBulkHooks(entity, hooks) {
-    for (const event of Object.keys(hooks)) {
-        const methodNames = hooks[event];
-        if (!methodNames?.length)
-            continue;
-        for (const methodName of methodNames) {
+    for (const [event, methodNames] of Object.entries(specs?.hooks ?? {})) {
+        for (const methodName of methodNames ?? []) {
             defineHook(entity, methodName, event);
         }
     }
 }
-function applyBulkFilters(entity, filters) {
-    for (const name of Object.keys(filters)) {
-        const spec = filters[name];
+export function defineEntity(entity, opts = {}) {
+    const meta = ensureMeta(entity);
+    // Covers `defineEntity(Decorated)` called on a class whose members carry decorators. `@Entity()`
+    // drains `context.metadata` itself, because TypeScript only attaches `Symbol.metadata` to the class
+    // after class decorators return; draining empties the bag, so whichever runs second is a no-op.
+    applyMembers(entity, ownRegistrations(entity));
+    applyMembers(entity, opts);
+    for (const index of opts.indexes ?? []) {
+        defineIndex(entity, index);
+    }
+    for (const [name, spec] of Object.entries(opts.filters ?? {})) {
         if (spec)
             defineFilter(entity, name, spec);
     }
-}
-/**
- * Applies `fields`, `relations`, `indexes`, and `hooks` from {@link EntityOptions} before
- * entity finalization. Used by `defineEntity` for decorator-free registration.
- */
-function applyBulkEntityOptions(entity, opts) {
-    if (opts.fields)
-        applyBulkFields(entity, opts.fields);
-    if (opts.relations)
-        applyBulkRelations(entity, opts.relations);
-    if (opts.indexes?.length)
-        applyBulkIndexes(entity, opts.indexes);
-    if (opts.hooks)
-        applyBulkHooks(entity, opts.hooks);
-    if (opts.filters)
-        applyBulkFilters(entity, opts.filters);
-}
-export function defineEntity(entity, opts = {}) {
-    const meta = ensureMeta(entity);
-    applyBulkEntityOptions(entity, opts);
     if (!hasKeys(meta.fields)) {
         throw TypeError(`'${entity.name}' must have fields`);
     }
     meta.name = opts.name ?? entity.name;
     let proto = Object.getPrototypeOf(entity.prototype);
     while (proto.constructor !== Object) {
-        const parentMeta = ensureMeta(proto.constructor);
-        extendMeta(meta, parentMeta);
+        const parent = proto.constructor;
+        // An `abstract class BaseEntity` carrying `@Field`s but no `@Entity()` has nobody to drain its
+        // registrations, so do it here. Walking the *class* prototype chain rather than reading through the
+        // metadata object's is what makes this work on every transformer: tsc and esbuild chain metadata
+        // across `extends`, SWC does not.
+        applyMembers(parent, ownRegistrations(parent));
+        extendMeta(meta, ensureMeta(parent));
         proto = Object.getPrototypeOf(proto);
     }
     // Derive soft-delete from the (inheritance-merged) fields, so own and inherited markers are handled
@@ -241,7 +222,7 @@ function fillRelations(meta) {
                     name: fkKey,
                     type: relatedIdField?.type ?? Number,
                     references: relOpts.entity,
-                    typeInferred: true,
+                    typeFromReference: true,
                 };
             }
         }
@@ -342,29 +323,3 @@ function extendMeta(target, source) {
         }
     }
 }
-/** Reads the `design:type` emitted by `emitDecoratorMetadata`, if the optional polyfill is loaded. */
-function inferType(entity, key) {
-    const { getMetadata } = Reflect;
-    if (!getMetadata) {
-        throw new TypeError(`'${entity.name}.${key}' has no explicit type and 'design:type' metadata is unavailable. Either declare the type - '@Field({ type: String })' or '@Relation({ entity: () => Other })' - or install 'reflect-metadata' and add 'import "reflect-metadata"' once at your app entry point.`);
-    }
-    return getMetadata('design:type', entity.prototype, key);
-}
-// biome-ignore lint/suspicious/noExplicitAny: reflected type is unknown at compile time
-function inferEntityType(entity, key) {
-    const inferredType = inferType(entity, key);
-    const isValidType = isValidEntityType(inferredType);
-    if (!isValidType) {
-        throw TypeError(`'${entity.name}.${key}' type was auto-inferred with invalid type '${inferredType?.name}'`);
-    }
-    return inferredType;
-}
-export function isValidEntityType(type) {
-    return (typeof type === 'function' &&
-        type !== Boolean &&
-        type !== String &&
-        type !== Number &&
-        type !== BigInt &&
-        type !== Date &&
-        type !== Symbol);
-}

package/dist/http/contract.js

@@ -1,5 +1,4 @@
-// import from the specific util modules (not the barrel) to keep entity
-// metadata and reflect-metadata out of the browser bundle
+// the specific util modules, not the barrel, so the browser bundle does not pull in entity metadata
 import { getKeys } from '../util/object.util.js';
 import { kebabCase } from '../util/string.util.js';
 /**

package/dist/http/handler.js

@@ -1,6 +1,6 @@
 import { withContext } from '../context/context.js';
 import { getEntities, getMeta } from '../entity/index.js';
-import { getQuerier } from '../options.js';
+import { getQuerierPool } from '../options.js';
 import { entityPath, matchRoute, } from './contract.js';
 import { parseQueryParams } from './query.js';
 export function createRequestHandler(opts = {}) {
@@ -135,31 +135,10 @@ export function createRequestHandler(opts = {}) {
 function ok(body) {
     return { status: 200, body };
 }
-async function withQuerier(fn) {
-    const querier = await getQuerier();
-    try {
-        return await fn(querier);
-    }
-    finally {
-        await querier.release();
-    }
-}
-async function withTransaction(fn) {
-    const querier = await getQuerier();
-    try {
-        await querier.beginTransaction();
-        const resp = await fn(querier);
-        await querier.commitTransaction();
-        return resp;
-    }
-    catch (err) {
-        await querier.rollbackTransaction().catch(() => { });
-        throw err;
-    }
-    finally {
-        await querier.release();
-    }
-}
+/** Read paths: the pool acquires and releases; nothing here owns a connection. */
+const withQuerier = (fn) => getQuerierPool().withQuerier(fn);
+/** Write paths: same, plus commit on success and rollback on failure. */
+const withTransaction = (fn) => getQuerierPool().transaction(fn);
 function buildIdQuery(meta, id, query) {
     const idKey = meta.id;
     const where = query.$where;

package/dist/http/query.js

@@ -1,4 +1,4 @@
-// specific util module (not the barrel) to keep reflect-metadata out of the browser bundle
+// the specific util module, not the barrel, so the browser bundle does not pull in entity metadata
 import { getKeys } from '../util/object.util.js';
 const JSON_QUERY_KEYS = [
     '$select',

package/dist/migrate/acquireQuerierForMigrations.d.ts

@@ -1,4 +1,4 @@
-import type { Querier, QuerierPool } from '../type/index.js';
+import { type Querier, type QuerierPool, type SqlQuerier } from '../type/index.js';
 /**
  * Querier used for schema migrations and the migration journal (`DatabaseMigrationStorage`).
  *
@@ -6,3 +6,15 @@ import type { Querier, QuerierPool } from '../type/index.js';
  * app traffic (e.g. LibSQL embedded replica: local `file:` + remote `syncUrl`).
  */
 export declare function acquireQuerierForMigrations(pool: QuerierPool): Promise<Querier>;
+/**
+ * Runs `task` on a migration querier and releases it, whatever happens.
+ *
+ * `pool.withQuerier` cannot serve here because migrations may run on a different connection than app
+ * traffic, but the ownership rule is the same one: whoever acquires, releases.
+ */
+export declare function withQuerierForMigrations<T>(pool: QuerierPool, task: (querier: Querier) => Promise<T>): Promise<T>;
+/**
+ * Same, for the paths that only work against SQL. `requiredBy` names the caller in the error, which is
+ * the only thing the five copies of this acquire-assert-release dance used to differ by.
+ */
+export declare function withSqlQuerierForMigrations<T>(pool: QuerierPool, requiredBy: string, task: (querier: SqlQuerier) => Promise<T>): Promise<T>;

package/dist/migrate/acquireQuerierForMigrations.js

@@ -1,3 +1,4 @@
+import { isSqlQuerier } from '../type/index.js';
 /**
  * Querier used for schema migrations and the migration journal (`DatabaseMigrationStorage`).
  *
@@ -7,3 +8,30 @@
 export async function acquireQuerierForMigrations(pool) {
     return (await pool.getMigrationQuerier?.()) ?? (await pool.getQuerier());
 }
+/**
+ * Runs `task` on a migration querier and releases it, whatever happens.
+ *
+ * `pool.withQuerier` cannot serve here because migrations may run on a different connection than app
+ * traffic, but the ownership rule is the same one: whoever acquires, releases.
+ */
+export async function withQuerierForMigrations(pool, task) {
+    const querier = await acquireQuerierForMigrations(pool);
+    try {
+        return await task(querier);
+    }
+    finally {
+        await querier.release();
+    }
+}
+/**
+ * Same, for the paths that only work against SQL. `requiredBy` names the caller in the error, which is
+ * the only thing the five copies of this acquire-assert-release dance used to differ by.
+ */
+export function withSqlQuerierForMigrations(pool, requiredBy, task) {
+    return withQuerierForMigrations(pool, (querier) => {
+        if (!isSqlQuerier(querier)) {
+            throw new TypeError(`${requiredBy} requires a SQL-based querier`);
+        }
+        return task(querier);
+    });
+}

package/dist/migrate/cli-config.js

@@ -1,11 +1,27 @@
 import { stat } from 'node:fs/promises';
 import { resolve } from 'node:path';
-/** `jiti` (1.8 MB) makes `uql.config.ts` loadable; imported here so only projects with one pay for it. */
+import { pathToFileURL } from 'node:url';
+/**
+ * Loads the config with a plain `import()`, leaving TypeScript to whatever runs the CLI.
+ *
+ * @remarks uql deliberately bundles no transpiler. The config imports the entity classes, so whoever
+ * loads it decides which decorator spec their decorators are invoked with, and only the runtime knows
+ * the project's `tsconfig.json`. Bun and `node --import tsx` both get it right; a bundled loader would
+ * be guessing, and `jiti` guessed wrong (it hardcodes the legacy transform, so standard decorators were
+ * called as `(prototype, key)` and every field was silently dropped).
+ *
+ * Node's own type stripping covers a config that is only types plus a plain object, which is why the
+ * error below distinguishes the two cases: decorators are not erasable syntax, so a config that reaches
+ * decorated entity classes needs a runtime that actually transforms them.
+ */
 async function importConfig(path) {
-    const { createJiti } = await import('jiti').catch(() => {
-        throw new Error("Loading a uql config file requires 'jiti'. Run `npm i -D jiti`, or pass the config inline instead of via a config file.");
-    });
-    return createJiti(process.cwd()).import(path, { default: true });
+    const mod = (await import(pathToFileURL(path).href).catch((cause) => {
+        throw new TypeError(`Could not import ${path}: ${cause?.message}\n` +
+            'If it reaches entity classes, their decorators need a runtime that transforms TypeScript, not ' +
+            'just one that strips its types. Run the CLI with `bun`, or with `node --import tsx` ' +
+            '(`npm i -D tsx`). A JavaScript config, or passing the config inline, needs neither.', { cause });
+    }));
+    return mod.default ?? mod;
 }
 export async function loadConfig(customPath) {
     if (customPath) {
@@ -14,14 +30,14 @@ export async function loadConfig(customPath) {
             .then(() => true)
             .catch(() => false);
         if (!exists) {
-            throw new Error(`Could not find uql configuration file at ${customPath}`);
+            throw new TypeError(`Could not find uql configuration file at ${customPath}`);
         }
         try {
             const config = await importConfig(fullPath);
             return config;
         }
         catch (error) {
-            throw new Error(`Could not load configuration file at ${customPath}: ${error.message}`);
+            throw new TypeError(`Could not load configuration file at ${customPath}: ${error.message}`);
         }
     }
     const configPaths = ['uql.config.ts', 'uql.config.js', 'uql.config.mjs', '.uqlrc.ts', '.uqlrc.js'];
@@ -35,5 +51,5 @@ export async function loadConfig(customPath) {
             return config;
         }
     }
-    throw new Error('Could not find uql configuration file. Create a uql.config.ts or uql.config.js file in your project root.');
+    throw new TypeError('Could not find uql configuration file. Create a uql.config.ts or uql.config.js file in your project root.');
 }

package/dist/migrate/cli.js

@@ -9,6 +9,7 @@ import { detectDrift } from './drift/driftDetector.js';
 import { Migrator } from './migrator.js';
 import { createSchemaGenerator } from './schemaGenerator.js';
 import { createSchemaGeneratorAsync } from './schemaGeneratorAsync.js';
+import { DEFAULT_MIGRATIONS_TABLE } from './storage/databaseStorage.js';
 /** Sync helper for SQL dialects only; returns `undefined` for MongoDB - use {@link createSchemaGeneratorAsync}. */
 export function getSchemaGenerator(dialect, defaultForeignKeyAction) {
     return createSchemaGenerator(dialect, defaultForeignKeyAction);
@@ -265,7 +266,10 @@ export async function runDriftCheck(migrator, config) {
         const actualAST = await migrator.schemaIntrospector.introspect();
         // Detect drift. The dialect renders canonical types as SQL - without it every type formats as
         // `unknown` and type drift compares equal, silently reporting a mismatched column as in sync.
-        const report = detectDrift(expectedAST, actualAST, { dialect: config.pool?.dialect });
+        const report = detectDrift(expectedAST, actualAST, {
+            dialect: config.pool?.dialect,
+            excludeTables: [config.tableName ?? DEFAULT_MIGRATIONS_TABLE],
+        });
         printDriftReport(report);
     }
 }

package/dist/migrate/codegen/entityCodeGenerator.js

@@ -83,7 +83,6 @@ export class EntityCodeGenerator {
         if (this.options.includeRelations) {
             for (const rel of [...table.incomingRelations, ...table.outgoingRelations]) {
                 uqlImports.add(this.getRelationDecoratorName(rel.type));
-                uqlImports.add('Relation');
                 const relatedTable = rel.from.table === table ? rel.to.table : rel.from.table;
                 const relatedClassName = this.options.classNameTransformer(relatedTable.name);
                 if (!relatedImports.includes(relatedClassName)) {
@@ -238,7 +237,7 @@ export class EntityCodeGenerator {
         // Decorator
         lines.push(`  @${decoratorName}({ entity: () => ${relatedClassName} })`);
         // Property
-        lines.push(`  ${propertyName}?: Relation<${relatedClassName}>;`);
+        lines.push(`  ${propertyName}?: ${relatedClassName};`);
         return lines.join('\n');
     }
     /**
@@ -262,10 +261,10 @@ export class EntityCodeGenerator {
         lines.push(`  @${decoratorName}({ entity: () => ${relatedClassName}, references: '${inverseProp}' })`);
         // Property
         if (inverseType === 'OneToMany' || inverseType === 'ManyToMany') {
-            lines.push(`  ${propertyName}?: Relation<${relatedClassName}[]>;`);
+            lines.push(`  ${propertyName}?: ${relatedClassName}[];`);
         }
         else {
-            lines.push(`  ${propertyName}?: Relation<${relatedClassName}>;`);
+            lines.push(`  ${propertyName}?: ${relatedClassName};`);
         }
         return lines.join('\n');
     }

package/dist/migrate/codegen/index.d.ts

@@ -5,4 +5,3 @@
  */
 export { createEntityCodeGenerator, EntityCodeGenerator, type EntityCodeGeneratorOptions, type GeneratedEntity, } from './entityCodeGenerator.js';
 export { buildSqlQuerierMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitSqlRunCall, emitSqlRunCalls, type SqlMigrationModuleOptions, } from './migrationFile.js';
-export { createRelationDetector, type RelationDetectorOptions, SmartRelationDetector, } from './smartRelationDetector.js';

package/dist/migrate/codegen/index.js

@@ -6,5 +6,3 @@
 // Entity code generator
 export { createEntityCodeGenerator, EntityCodeGenerator, } from './entityCodeGenerator.js';
 export { buildSqlQuerierMigrationModule, EMPTY_MANUAL_MIGRATION_DOWN_INNER, EMPTY_MANUAL_MIGRATION_UP_INNER, emitSqlRunCall, emitSqlRunCalls, } from './migrationFile.js';
-// Smart relation detector
-export { createRelationDetector, SmartRelationDetector, } from './smartRelationDetector.js';

package/dist/migrate/drift/driftDetector.d.ts

@@ -19,8 +19,17 @@ export interface DriftDetectorOptions {
     checkIndexes?: boolean;
     /** Include foreign key differences */
     checkForeignKeys?: boolean;
-    /** Include default value differences */
+    /**
+     * Include default value differences. Off by default: an engine reports a default as it stored it
+     * (`now()`, `CURRENT_TIMESTAMP`, `'active'::text`), which rarely matches the entity's literal.
+     */
     checkDefaults?: boolean;
+    /**
+     * Tables to leave out of the comparison. The migrations bookkeeping table belongs here - it exists in
+     * the database by design and has no entity, so reporting it as unexpected told every project to
+     * "create entity or drop table" for its own migration log.
+     */
+    excludeTables?: string[];
     /** Dialect instance for type formatting */
     dialect?: AbstractDialect;
 }

package/dist/migrate/drift/driftDetector.js

@@ -22,6 +22,7 @@ export class DriftDetector {
             checkIndexes: options.checkIndexes ?? true,
             checkForeignKeys: options.checkForeignKeys ?? true,
             checkDefaults: options.checkDefaults ?? false,
+            excludeTables: options.excludeTables ?? [],
             dialect: options.dialect,
         };
     }
@@ -30,7 +31,11 @@ export class DriftDetector {
      */
     detect() {
         const differ = new SchemaASTDiffer();
-        const diff = differ.diff(this.expectedAST, this.actualAST);
+        const diff = differ.diff(this.expectedAST, this.actualAST, {
+            compareIndexes: this.options.checkIndexes,
+            compareRelationships: this.options.checkForeignKeys,
+            excludeTables: this.options.excludeTables,
+        });
         const drifts = [
             ...this.detectTableDrifts(diff),
             ...this.detectColumnDrifts(diff),
@@ -137,13 +142,27 @@ export class DriftDetector {
                 });
             }
         }
+        if (this.options.checkDefaults && colDiff.expected && colDiff.actual) {
+            const expected = String(colDiff.expected.defaultValue ?? 'NULL');
+            const actual = String(colDiff.actual.defaultValue ?? 'NULL');
+            if (expected !== actual) {
+                drifts.push({
+                    type: 'constraint_mismatch',
+                    severity: 'info',
+                    table: colDiff.table,
+                    column: colDiff.column,
+                    expected,
+                    actual,
+                    details: `Default mismatch for "${colDiff.column}"`,
+                    suggestion: 'Align the default in the entity or the database',
+                });
+            }
+        }
     }
     /**
      * Detect index drifts.
      */
     detectIndexDrifts(diff) {
-        if (!this.options.checkIndexes)
-            return [];
         const drifts = [];
         for (const idxDiff of diff.indexDiffs) {
             if (idxDiff.type === 'create') {
@@ -173,8 +192,6 @@ export class DriftDetector {
      * Detect relationship/FK drifts.
      */
     detectRelationshipDrifts(diff) {
-        if (!this.options.checkForeignKeys)
-            return [];
         const drifts = [];
         for (const relDiff of diff.relationshipDiffs) {
             if (relDiff.type === 'create') {

package/dist/migrate/introspection/abstractSqlSchemaIntrospector.d.ts

@@ -40,7 +40,11 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
     getTableSchema(tableName: string): Promise<TableSchema | undefined>;
     getTableNames(): Promise<string[]>;
     tableExists(tableName: string): Promise<boolean>;
-    protected getQuerier(): Promise<SqlQuerier>;
+    /**
+     * 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.
+     */
+    protected withSqlQuerier<T>(task: (querier: SqlQuerier) => Promise<T>): Promise<T>;
     protected tableExistsInternal(read: TableRowReader, tableName: string): Promise<boolean>;
     protected getColumns(read: TableRowReader, tableName: string): Promise<ColumnSchema[]>;
     protected getIndexes(read: TableRowReader, tableName: string): Promise<IndexSchema[]>;

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