uql-orm 0.65.1 → 0.67.0

package/dist/migrate/codegen/entityCodeGenerator.js

@@ -1,20 +1,16 @@
-/**
- * Entity Code Generator
- *
- * Generates TypeScript entity files from SchemaAST.
- * Supports:
- * - ES Module syntax
- * - TypeScript types
- * - Relations with proper decorators
- * - Indexes
- * - JSDoc comments for sync-added fields
- */
 import { canonicalToTypeScript } from '../../schema/canonicalType.js';
 import { DEFAULT_FOREIGN_KEY_ACTION, } from '../../schema/types.js';
 import { camelCase, lowerFirst, pascalCase, singularize } from '../../util/string.util.js';
 import { buildFieldOptionsSource, fieldNeedsRaw } from './fieldOptionsSource.js';
 import { buildIndexDecoratorSource, indexNeedsRaw, isPlainFieldIndex } from './indexDecoratorSource.js';
 import { memberSource } from './sourceLiteral.js';
+/** The decorator on the other side of a relation. */
+const INVERSE_RELATION = {
+    OneToOne: 'OneToOne',
+    OneToMany: 'ManyToOne',
+    ManyToOne: 'OneToMany',
+    ManyToMany: 'ManyToMany',
+};
 /**
  * Generates TypeScript entity code from SchemaAST.
  */
@@ -87,7 +83,7 @@ export class EntityCodeGenerator {
         // Check for relation decorators
         if (this.options.includeRelations) {
             for (const rel of [...table.incomingRelations, ...table.outgoingRelations]) {
-                uqlImports.add(this.getRelationDecoratorName(rel.type));
+                uqlImports.add(rel.type);
                 const relatedTable = rel.from.table === table ? rel.to.table : rel.from.table;
                 const relatedClassName = this.options.classNameTransformer(relatedTable.name);
                 if (!relatedImports.includes(relatedClassName)) {
@@ -175,7 +171,7 @@ export class EntityCodeGenerator {
      * Build Field decorator options.
      */
     buildFieldOptions(col, propertyName) {
-        const indexes = this.options.includeIndexes ? this.ast.getTableIndexes(col.table.name) : [];
+        const indexes = this.options.includeIndexes ? col.table.indexes : [];
         const fieldIndex = indexes.find((idx) => isPlainFieldIndex(idx) && idx.entries[0]?.column === col.name);
         return buildFieldOptionsSource(col, propertyName, fieldIndex?.name);
     }
@@ -184,7 +180,7 @@ export class EntityCodeGenerator {
      * carry on its own.
      */
     declaredIndexes(table) {
-        return this.ast.getTableIndexes(table.name).filter((index) => !isPlainFieldIndex(index));
+        return table.indexes.filter((index) => !isPlainFieldIndex(index));
     }
     /**
      * Build relation definitions.
@@ -222,15 +218,11 @@ export class EntityCodeGenerator {
         else {
             propertyName = this.options.propertyNameTransformer(this.options.singularize(rel.to.table.name));
         }
-        const decoratorName = this.getRelationDecoratorName(rel.type);
         // JSDoc
         if (this.options.addSyncComments) {
             lines.push('  /**');
             lines.push(`   * @sync-added ${new Date().toISOString().split('T')[0]}`);
             lines.push(`   * Relation to ${rel.to.table.name} via ${rel.from.columns.map((c) => c.name).join(', ')}`);
-            if (rel.confidence !== undefined && rel.confidence < 1.0) {
-                lines.push(`   * Inferred (${(rel.confidence * 100).toFixed(0)}% confidence)`);
-            }
             lines.push('   */');
         }
         // Decorator. `onDelete`/`onUpdate` only when introspection found a real referential action, so a
@@ -243,7 +235,7 @@ export class EntityCodeGenerator {
             options.push(`onDelete: '${rel.onDelete}'`);
         if (rel.onUpdate && rel.onUpdate !== DEFAULT_FOREIGN_KEY_ACTION)
             options.push(`onUpdate: '${rel.onUpdate}'`);
-        lines.push(`  @${decoratorName}({ ${options.join(', ')} })`);
+        lines.push(`  @${rel.type}({ ${options.join(', ')} })`);
         // Property
         lines.push(`  ${propertyName}?: ${relatedClassName};`);
         return lines.join('\n');
@@ -274,8 +266,6 @@ export class EntityCodeGenerator {
         const lines = [];
         const relatedClassName = this.options.classNameTransformer(rel.from.table.name);
         const propertyName = this.options.propertyNameTransformer(rel.from.table.name);
-        const inverseType = this.ast.getInverseRelationType(rel.type);
-        const decoratorName = this.getRelationDecoratorName(inverseType);
         // JSDoc
         if (this.options.addSyncComments) {
             lines.push('  /**');
@@ -286,31 +276,12 @@ export class EntityCodeGenerator {
         // The inverse side, mapped by the related class's property that points back at this one.
         const param = lowerFirst(relatedClassName);
         const inverse = memberSource(param, this.options.propertyNameTransformer(this.options.singularize(table.name)));
-        lines.push(`  @${decoratorName}({ entity: () => ${relatedClassName}, mappedBy: (${param}) => ${inverse} })`);
-        // Property
-        if (inverseType === 'OneToMany' || inverseType === 'ManyToMany') {
-            lines.push(`  ${propertyName}?: ${relatedClassName}[];`);
-        }
-        else {
-            lines.push(`  ${propertyName}?: ${relatedClassName};`);
-        }
+        const inverseType = INVERSE_RELATION[rel.type];
+        lines.push(`  @${inverseType}({ entity: () => ${relatedClassName}, mappedBy: (${param}) => ${inverse} })`);
+        const many = inverseType === 'OneToMany' || inverseType === 'ManyToMany';
+        lines.push(`  ${propertyName}?: ${relatedClassName}${many ? '[]' : ''};`);
         return lines.join('\n');
     }
-    /**
-     * Get decorator name for relation type.
-     */
-    getRelationDecoratorName(type) {
-        switch (type) {
-            case 'OneToOne':
-                return 'OneToOne';
-            case 'OneToMany':
-                return 'OneToMany';
-            case 'ManyToOne':
-                return 'ManyToOne';
-            case 'ManyToMany':
-                return 'ManyToMany';
-        }
-    }
     /**
      * Format type for description.
      */

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

@@ -1,12 +1,5 @@
 import type { ColumnNode } from '../../schema/types.js';
-/**
- * A column's `@Field({ ... })` options as source, or `''` when it needs none.
- *
- * Shared by the entity generator and the merger because they emit the same decorator. They each had
- * their own copy, and the copies had drifted: the merger's dropped `unique` and `defaultValue`, so
- * merging a column into an existing entity file quietly produced a weaker field than generating the
- * file from scratch.
- */
+/** A column's `@Field({ ... })` options as source, `''` where it needs none: shared by the generator and the merger. */
 export declare function buildFieldOptionsSource(col: ColumnNode, propertyName: string, indexName?: string): string;
 /** Whether the field's decorator needs `raw` imported, the way {@link indexNeedsRaw} does for an index. */
 export declare function fieldNeedsRaw(col: ColumnNode): boolean;

package/dist/migrate/codegen/fieldOptionsSource.js

@@ -1,14 +1,6 @@
 import { canonicalToColumnType } from '../../schema/canonicalType.js';
 import { quoted, rawTag } from './sourceLiteral.js';
-/**
- * What each field of a {@link ColumnNode} contributes to `@Field({ ... })`, in emit order, and `null`
- * where nothing does.
- *
- * The `satisfies` is the point: a field the node gains cannot reach here without someone answering
- * whether an entity generated from a database keeps it. Written as a hand-rolled `if` chain, this had
- * already dropped `comment` - introspection reads one on Postgres and MySQL, and regenerating an
- * entity threw it away.
- */
+/** What each field of a {@link ColumnNode} contributes to `@Field({ ... })`, in emit order; `satisfies` makes a new field answer. */
 const OPTION_SOURCE = {
     // Without this the entity maps to a column named after the property, which for anything the
     // transformer rewrote - every `user_id` - is a column the database does not have.
@@ -36,14 +28,7 @@ const OPTION_SOURCE = {
     references: null,
     referencedBy: null,
 };
-/**
- * A column's `@Field({ ... })` options as source, or `''` when it needs none.
- *
- * Shared by the entity generator and the merger because they emit the same decorator. They each had
- * their own copy, and the copies had drifted: the merger's dropped `unique` and `defaultValue`, so
- * merging a column into an existing entity file quietly produced a weaker field than generating the
- * file from scratch.
- */
+/** A column's `@Field({ ... })` options as source, `''` where it needs none: shared by the generator and the merger. */
 export function buildFieldOptionsSource(col, propertyName, indexName) {
     const context = { propertyName, indexName };
     const options = [
@@ -57,11 +42,7 @@ export function buildFieldOptionsSource(col, propertyName, indexName) {
 export function fieldNeedsRaw(col) {
     return col.generatedAs !== undefined;
 }
-/**
- * A default value as source. Strings stay single-quoted, expressions included: `defaultValue: 'now()'`
- * is what reaches the DDL. The generator used to branch on `CURRENT_TIMESTAMP`/`NEXTVAL`/`(` first, but
- * both branches emitted a quoted string and only the fallthrough escaped embedded quotes.
- */
+/** A default value as source, a string single-quoted and escaped, an expression included: `defaultValue: 'now()'`. */
 function defaultValueSource(value) {
     if (typeof value === 'string') {
         return quoted(value);

package/dist/migrate/ddl/indexDdl.d.ts

@@ -6,11 +6,8 @@ export declare function assertIndexType(index: IndexSchema, types: ReadonlySet<I
 /** Refuses an index asking for a feature `features` lacks. */
 export declare function assertIndexFeatures(index: IndexSchema, features: ReadonlySet<IndexFeature>, dialectName: string): void;
 /**
- * `CREATE INDEX` for SQL dialects: the statement and the fragments each engine spells differently.
- * The migrator's rather than the dialect's, since {@link SqlSchemaGenerator} is the only thing that
- * emits DDL - which is what keeps a `CAST(... ARRAY)` table out of every runtime consumer's entry.
- * The form here is the portable one, which SQLite (and so libSQL, Turso and D1) takes verbatim: no
- * access-method clause, no operator classes, no tuning parameters.
+ * `CREATE INDEX` in its portable form, which the SQLite family takes as is; the engines with more override
+ * the fragments. The migrator's own, so no runtime entry carries it.
  */
 export declare class IndexDdl<D extends AbstractSqlDialect = AbstractSqlDialect> {
     protected readonly dialect: D;

package/dist/migrate/ddl/indexDdl.js

@@ -32,11 +32,8 @@ export function assertIndexFeatures(index, features, dialectName) {
     }
 }
 /**
- * `CREATE INDEX` for SQL dialects: the statement and the fragments each engine spells differently.
- * The migrator's rather than the dialect's, since {@link SqlSchemaGenerator} is the only thing that
- * emits DDL - which is what keeps a `CAST(... ARRAY)` table out of every runtime consumer's entry.
- * The form here is the portable one, which SQLite (and so libSQL, Turso and D1) takes verbatim: no
- * access-method clause, no operator classes, no tuning parameters.
+ * `CREATE INDEX` in its portable form, which the SQLite family takes as is; the engines with more override
+ * the fragments. The migrator's own, so no runtime entry carries it.
  */
 export class IndexDdl {
     dialect;

package/dist/migrate/ddl/pgIndexDdl.d.ts

@@ -15,24 +15,14 @@ export declare class PgIndexDdl extends IndexDdl {
     protected isVectorIndex(index: IndexSchema): boolean;
     protected indexAccessMethod(index: IndexSchema): string;
     /**
-     * A vector index's operator class is named `{type}_{metric}_ops`: an index on a `halfvec` column
-     * needs `halfvec_cosine_ops`, and `vector_cosine_ops` there is rejected outright. An unsupported
-     * distance throws rather than being omitted, since a bare `USING hnsw ("embedding")` would build
-     * with the dialect's default metric instead of the one requested, with nothing signalling it.
-     * Everything else takes the operator class the entry declares, e.g. `jsonb_path_ops` for GIN.
+     * A vector index's operator class, `{type}_{metric}_ops` (`halfvec_cosine_ops`), refusing a metric it
+     * lacks rather than build with the default; any other entry takes the class it declares.
      */
     protected indexColumnOpsClass(entry: IndexColumnSchema, index: IndexSchema): string;
     protected indexInclude(index: IndexSchema): string;
     protected indexTuning(index: IndexSchema): string;
 }
-/**
- * CockroachDB's vector index is native and has its own syntax: `CREATE VECTOR INDEX ... ("col"
- * vector_cosine_ops)`, with no access-method keyword, and tuning knobs of its own names that UQL
- * does not map. `type: 'vector'` is its trigger, the same generic value MariaDB's index uses.
- *
- * `NULLS FIRST/LAST` answers "unimplemented: this syntax" and `jsonb_path_ops` "operator class is
- * not supported" (both verified on v26.2), so neither is offered here.
- */
+/** CockroachDB's native `CREATE VECTOR INDEX`, for `type: 'vector'`; it has neither `NULLS FIRST/LAST` nor `jsonb_path_ops`. */
 export declare class CockroachIndexDdl extends PgIndexDdl {
     protected readonly indexFeatures: Set<"expression" | "include" | "jsonArray" | "jsonPath" | "nullsOrder" | "opsClass" | "partial" | "prefixLength">;
     /** v26.3 answers `hash` and `brin` "unimplemented", `ivfflat` "unrecognized"; `hnsw` builds its vector index. */

package/dist/migrate/ddl/pgIndexDdl.js

@@ -36,11 +36,8 @@ export class PgIndexDdl extends IndexDdl {
         return index.type ? ` USING ${index.type}` : '';
     }
     /**
-     * A vector index's operator class is named `{type}_{metric}_ops`: an index on a `halfvec` column
-     * needs `halfvec_cosine_ops`, and `vector_cosine_ops` there is rejected outright. An unsupported
-     * distance throws rather than being omitted, since a bare `USING hnsw ("embedding")` would build
-     * with the dialect's default metric instead of the one requested, with nothing signalling it.
-     * Everything else takes the operator class the entry declares, e.g. `jsonb_path_ops` for GIN.
+     * A vector index's operator class, `{type}_{metric}_ops` (`halfvec_cosine_ops`), refusing a metric it
+     * lacks rather than build with the default; any other entry takes the class it declares.
      */
     indexColumnOpsClass(entry, index) {
         if (!this.isVectorIndex(index) || !index.distance) {
@@ -77,14 +74,7 @@ export class PgIndexDdl extends IndexDdl {
         return params.length > 0 ? ` WITH (${params.join(', ')})` : '';
     }
 }
-/**
- * CockroachDB's vector index is native and has its own syntax: `CREATE VECTOR INDEX ... ("col"
- * vector_cosine_ops)`, with no access-method keyword, and tuning knobs of its own names that UQL
- * does not map. `type: 'vector'` is its trigger, the same generic value MariaDB's index uses.
- *
- * `NULLS FIRST/LAST` answers "unimplemented: this syntax" and `jsonb_path_ops` "operator class is
- * not supported" (both verified on v26.2), so neither is offered here.
- */
+/** CockroachDB's native `CREATE VECTOR INDEX`, for `type: 'vector'`; it has neither `NULLS FIRST/LAST` nor `jsonb_path_ops`. */
 export class CockroachIndexDdl extends PgIndexDdl {
     indexFeatures = new Set(['expression', 'partial', 'include', 'jsonPath']);
     /** v26.3 answers `hash` and `brin` "unimplemented", `ivfflat` "unrecognized"; `hnsw` builds its vector index. */

package/dist/migrate/generator/definitionToNode.d.ts

@@ -9,15 +9,8 @@ import type { FullColumnDefinition, IndexDefinition, TableDefinition } from '../
  */
 export declare function tableDefinitionToNode(def: TableDefinition, render: (sql: QueryRaw) => string): TableNode;
 /**
- * A builder's column as the AST node the generators render from.
- *
- * The shared half is spread, not copied field by field: `ColumnDefinition` *is* a `ColumnNode` minus
- * the graph links, so spreading it and adding those back is a node by construction. Listed one by one,
- * the copy silently dropped whatever the node gained next - `enum` first, and the type had no way to
- * say so. The two builder-only keys are destructured off: `index` and `foreignKey` are lifted onto the
- * table by `columnIndex`/`columnForeignKey`, which is the path that renders them.
- *
- * No `references` node either: `SchemaAST.addRelationship` sets that one.
+ * A builder's column as the node the generators render, spread so a field the node gains carries over.
+ * `index` and `foreignKey` are lifted onto the table elsewhere; `addRelationship` sets `references`.
  */
 export declare function fullColumnDefinitionToNode(col: FullColumnDefinition, tableName: string): ColumnNode;
 /**

package/dist/migrate/generator/definitionToNode.js

@@ -1,13 +1,6 @@
 import { renderIndexColumn } from '../../util/ddlExpression.util.js';
 import { derivedForeignKeyName, derivedIndexName } from '../../util/sql.util.js';
-/**
- * A table the builder names but has not seen.
- *
- * A `RelationshipNode` points at a whole `TableNode` because the AST wires `incomingRelations` through
- * it; a builder creating one table has no node for the table its foreign key targets, and the
- * generator reads only the name. Stated once, so the three casts it replaces cannot be mistaken for a
- * node that was resolved and lost.
- */
+/** A table the builder names but has not seen, which the generator reads only the name of. */
 function unresolvedTable(name) {
     return { name };
 }
@@ -63,15 +56,8 @@ export function tableDefinitionToNode(def, render) {
     return table;
 }
 /**
- * A builder's column as the AST node the generators render from.
- *
- * The shared half is spread, not copied field by field: `ColumnDefinition` *is* a `ColumnNode` minus
- * the graph links, so spreading it and adding those back is a node by construction. Listed one by one,
- * the copy silently dropped whatever the node gained next - `enum` first, and the type had no way to
- * say so. The two builder-only keys are destructured off: `index` and `foreignKey` are lifted onto the
- * table by `columnIndex`/`columnForeignKey`, which is the path that renders them.
- *
- * No `references` node either: `SchemaAST.addRelationship` sets that one.
+ * A builder's column as the node the generators render, spread so a field the node gains carries over.
+ * `index` and `foreignKey` are lifted onto the table elsewhere; `addRelationship` sets `references`.
  */
 export function fullColumnDefinitionToNode(col, tableName) {
     const { index: _index, foreignKey: _foreignKey, ...column } = col;

package/dist/migrate/generator/indexNodeToSchema.d.ts

@@ -2,8 +2,7 @@ import type { IndexNode } from '../../schema/types.js';
 import type { IndexSchema } from '../../type/index.js';
 /**
  * An AST index as the generators and dialects want it. Spread rather than copied field by field:
- * rebuilding it by hand is how the partial-index `where` once vanished without a trace. The node-only
- * keys (`table`, `source`, `syncStatus`) are ignored downstream, and the vector type travels along
- * because pgvector's operator-class names are built from it.
+ * rebuilding it by hand is how the partial-index `where` once vanished without a trace. Its `table` is
+ * ignored downstream, and the vector type travels along because pgvector's operator-class names are built from it.
  */
 export declare function indexNodeToSchema(index: IndexNode): IndexSchema;

package/dist/migrate/generator/indexNodeToSchema.js

@@ -2,9 +2,8 @@ import { isVectorCategory } from '../../schema/canonicalType.js';
 import { indexColumns } from '../../schema/indexColumns.js';
 /**
  * An AST index as the generators and dialects want it. Spread rather than copied field by field:
- * rebuilding it by hand is how the partial-index `where` once vanished without a trace. The node-only
- * keys (`table`, `source`, `syncStatus`) are ignored downstream, and the vector type travels along
- * because pgvector's operator-class names are built from it.
+ * rebuilding it by hand is how the partial-index `where` once vanished without a trace. Its `table` is
+ * ignored downstream, and the vector type travels along because pgvector's operator-class names are built from it.
  */
 export function indexNodeToSchema(index) {
     return {

package/dist/migrate/generator/mongoCommand.d.ts

@@ -6,14 +6,7 @@ export type MongoIndexOptions = {
     readonly name: string;
     readonly partialFilterExpression?: Readonly<Record<string, unknown>>;
 };
-/**
- * `SchemaGenerator` yields one string per statement, so {@link MongoSchemaGenerator} emits its
- * commands as JSON and this is their schema.
- *
- * Declared next to the generator that writes them because the migrator used to restate the shape
- * inline from `JSON.parse`, with `cmd.name!` assertions and a bare `action: string` - where a command
- * it had no branch for was silently a no-op.
- */
+/** The commands {@link MongoSchemaGenerator} emits as JSON, one per statement. */
 export type MongoCommand = {
     readonly action: 'createCollection';
     readonly name: string;

package/dist/migrate/generator/mongoSchemaGenerator.d.ts

@@ -33,14 +33,7 @@ export declare class MongoSchemaGenerator extends MongoDialect implements Schema
     generateDropTable(tableName: string): string;
     generateAlterTable(diff: SchemaDiff): string[];
     generateAlterTableDown(diff: SchemaDiff): string[];
-    /**
-     * MongoDB's key spec is where its index options live: `-1` for a descending entry and `'text'` for a
-     * full-text index, which is what `$text` needs since a text index declares its own fields.
-     *
-     * @remarks The SQL-only options are refused by the checks the SQL dialects refuse each other's with - a
-     * silently weaker index is worse than a clear failure. `where` is the filter's JSON, as
-     * {@link compileIndexPredicate} writes it.
-     */
+    /** An index as MongoDB's key spec (`-1` descending, `'text'` full-text), refusing the SQL-only options. */
     generateCreateIndex(tableName: string, index: IndexSchema): string;
     generateDropIndex(tableName: string, indexName: string): string;
     /** A collection and its indexes, which is all a document store has: a column, a constraint or SQL throws. */

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -96,14 +96,7 @@ export class MongoSchemaGenerator extends MongoDialect {
     generateAlterTableDown(diff) {
         return (diff.indexesToAdd ?? []).map((index) => this.generateDropIndex(diff.tableName, index.name));
     }
-    /**
-     * MongoDB's key spec is where its index options live: `-1` for a descending entry and `'text'` for a
-     * full-text index, which is what `$text` needs since a text index declares its own fields.
-     *
-     * @remarks The SQL-only options are refused by the checks the SQL dialects refuse each other's with - a
-     * silently weaker index is worse than a clear failure. `where` is the filter's JSON, as
-     * {@link compileIndexPredicate} writes it.
-     */
+    /** An index as MongoDB's key spec (`-1` descending, `'text'` full-text), refusing the SQL-only options. */
     generateCreateIndex(tableName, index) {
         assertIndexType(index, MONGO_INDEX_TYPES, this.dialectName);
         assertIndexFeatures(index, MONGO_INDEX_FEATURES, this.dialectName);

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

@@ -1,4 +1,4 @@
-import type { ForeignKeyAction } from '../../schema/types.js';
+import { type ForeignKeyAction } from '../../schema/types.js';
 import type { ColumnSchema, ForeignKeySchema, IndexSchema, QuerierPool, RawRow, SchemaIntrospector, SqlQuerier, TableSchema } from '../../type/index.js';
 import { BaseSqlIntrospector } from './baseSqlIntrospector.js';
 /**
@@ -12,32 +12,14 @@ import { BaseSqlIntrospector } from './baseSqlIntrospector.js';
  * it is four avoidable ones.
  */
 export type TableRowReader = <T extends RawRow>(sql: string, params?: unknown[]) => Promise<T[]>;
-/**
- * Abstract base class for SQL schema introspectors.
- *
- * Uses the template-method pattern to consolidate shared logic while allowing
- * dialect-specific implementations for SQL queries and type normalization.
- *
- * Subclasses must implement:
- * - `getTableNamesQuery()` - SQL to list all table names
- * - `tableExistsQuery()` - SQL to check if a table exists
- * - `getColumnsQuery()` - SQL to get column metadata
- * - `getIndexesQuery()` - SQL to get index metadata
- * - `getForeignKeysQuery()` - SQL to get foreign key metadata
- * - `getPrimaryKeyQuery()` - SQL to get primary key columns
- * - `mapColumnRow()` - Map a column query result row to ColumnSchema
- * - `mapIndexRow()` - Map an index query result row to IndexSchema
- * - `mapForeignKeyRow()` - Map a foreign key query result row to ForeignKeySchema
- * - `mapTableNameRow()` - Extract table name from a row
- * - `mapPrimaryKeyRow()` - Extract column name from a PK row
- */
+/** A SQL introspector: an engine states its catalogue queries (`get*Query`) and how their rows map (`map*Result`). */
 export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector implements SchemaIntrospector {
     protected readonly pool: QuerierPool;
     constructor(pool: QuerierPool, schema?: string);
     /**
-     * The schema every catalogue query filters on, as SQL: the one that was asked for, or the engine's
-     * expression for the connection's default. A literal rather than a bind parameter because these
-     * queries are assembled as text and several use it more than once.
+     * The schema every catalogue query filters on, as SQL: the one that was asked for, as the engine's
+     * own literal, or its expression for the connection's default. A literal rather than a bind
+     * parameter because these queries are assembled as text and several use it more than once.
      */
     protected get schemaExpr(): string;
     /**
@@ -66,9 +48,7 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
     protected getIndexesParams(tableName: string): unknown[];
     protected getForeignKeysParams(tableName: string): unknown[];
     protected getPrimaryKeyParams(tableName: string): unknown[];
-    /**
-     * Normalize referential action string to standard type.
-     */
+    /** The {@link ForeignKeyAction} a catalogue names, whatever its case. */
     protected normalizeReferentialAction(action: string): ForeignKeyAction | undefined;
     /**
      * Convert bigint/null values to number safely.

package/dist/migrate/introspection/abstractSqlSchemaIntrospector.js

@@ -1,25 +1,7 @@
+import { FOREIGN_KEY_ACTIONS } from '../../schema/types.js';
 import { isSqlQuerier } from '../../type/index.js';
-import { escapeAnsiSqlLiteral } from '../../util/sqlLiteral.js';
 import { BaseSqlIntrospector } from './baseSqlIntrospector.js';
-/**
- * Abstract base class for SQL schema introspectors.
- *
- * Uses the template-method pattern to consolidate shared logic while allowing
- * dialect-specific implementations for SQL queries and type normalization.
- *
- * Subclasses must implement:
- * - `getTableNamesQuery()` - SQL to list all table names
- * - `tableExistsQuery()` - SQL to check if a table exists
- * - `getColumnsQuery()` - SQL to get column metadata
- * - `getIndexesQuery()` - SQL to get index metadata
- * - `getForeignKeysQuery()` - SQL to get foreign key metadata
- * - `getPrimaryKeyQuery()` - SQL to get primary key columns
- * - `mapColumnRow()` - Map a column query result row to ColumnSchema
- * - `mapIndexRow()` - Map an index query result row to IndexSchema
- * - `mapForeignKeyRow()` - Map a foreign key query result row to ForeignKeySchema
- * - `mapTableNameRow()` - Extract table name from a row
- * - `mapPrimaryKeyRow()` - Extract column name from a PK row
- */
+/** A SQL introspector: an engine states its catalogue queries (`get*Query`) and how their rows map (`map*Result`). */
 export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
     pool;
     constructor(pool, schema) {
@@ -27,12 +9,12 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
         this.pool = pool;
     }
     /**
-     * The schema every catalogue query filters on, as SQL: the one that was asked for, or the engine's
-     * expression for the connection's default. A literal rather than a bind parameter because these
-     * queries are assembled as text and several use it more than once.
+     * The schema every catalogue query filters on, as SQL: the one that was asked for, as the engine's
+     * own literal, or its expression for the connection's default. A literal rather than a bind
+     * parameter because these queries are assembled as text and several use it more than once.
      */
     get schemaExpr() {
-        return this.schema === undefined ? this.defaultSchemaExpr : escapeAnsiSqlLiteral(this.schema);
+        return this.schema === undefined ? this.defaultSchemaExpr : this.dialect.escape(this.schema);
     }
     /**
      * How this engine names the connection's current schema (Postgres) or database (MySQL). Empty on
@@ -118,24 +100,10 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
     getPrimaryKeyParams(tableName) {
         return [tableName];
     }
-    /**
-     * Normalize referential action string to standard type.
-     */
+    /** The {@link ForeignKeyAction} a catalogue names, whatever its case. */
     normalizeReferentialAction(action) {
-        switch (action.toUpperCase()) {
-            case 'CASCADE':
-                return 'CASCADE';
-            case 'SET NULL':
-                return 'SET NULL';
-            case 'RESTRICT':
-                return 'RESTRICT';
-            case 'NO ACTION':
-                return 'NO ACTION';
-            case 'SET DEFAULT':
-                return 'SET DEFAULT';
-            default:
-                return undefined;
-        }
+        const upper = action.toUpperCase();
+        return FOREIGN_KEY_ACTIONS.find((known) => known === upper);
     }
     /**
      * Convert bigint/null values to number safely.

package/dist/migrate/introspection/baseSqlIntrospector.js

@@ -113,7 +113,6 @@ export class BaseSqlIntrospector {
                     type: idx.type,
                     where: idx.where,
                     include: idx.include,
-                    source: 'database',
                 };
                 ast.addIndex(index);
             }

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

@@ -1,6 +1,6 @@
 import type { IndexFacet } from '../../schema/indexDifferences.js';
 import { SchemaAST } from '../../schema/schemaAST.js';
-import type { QuerierPool, SchemaIntrospector, TableSchema } from '../../type/index.js';
+import { type QuerierPool, type SchemaIntrospector, type TableSchema } from '../../type/index.js';
 /**
  * MongoDB schema introspector.
  * MongoDB doesn't have a fixed schema, so this primarily focuses on collections and indexes.
@@ -12,6 +12,8 @@ export declare class MongoSchemaIntrospector implements SchemaIntrospector {
     constructor(pool: QuerierPool);
     introspect(tables?: readonly string[]): Promise<SchemaAST>;
     getTableSchema(tableName: string): Promise<TableSchema | undefined>;
+    /** Collections only, the way a SQL engine lists its base tables: no view, nor the `system.views` behind one. */
     getTableNames(): Promise<string[]>;
     tableExists(tableName: string): Promise<boolean>;
+    private withDb;
 }