uql-orm 0.55.0 → 0.57.0

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

@@ -1,5 +1,5 @@
 import type { AbstractSqlDialect } from '../../dialect/abstractSqlDialect.js';
-import type { IndexType } from '../../schema/types.js';
+import { type IndexType } from '../../schema/types.js';
 import { type IndexColumnSchema, type IndexFeature, type IndexJsonArray, type IndexSchema } from '../../type/index.js';
 /**
  * `CREATE INDEX` for SQL dialects: the statement and the fragments each engine spells differently.
@@ -20,6 +20,15 @@ export declare class IndexDdl<D extends AbstractSqlDialect = AbstractSqlDialect>
      * emitted: each of them is a hard error at the server, not a slower plan.
      */
     protected readonly indexFeatures: ReadonlySet<IndexFeature>;
+    /**
+     * Index types this dialect's `CREATE INDEX` takes. SQLite's grammar has no `USING` clause, so every
+     * type builds the plain index it has there, which is what lets an entity written for Postgres
+     * migrate unchanged. An engine that would reject a type narrows this, and the type is refused.
+     */
+    protected readonly indexTypes: ReadonlySet<IndexType>;
+    /** What to declare instead of a type this dialect lacks, appended to its refusal. */
+    protected readonly indexTypeHints: ReadonlyMap<IndexType, string>;
+    private assertIndexType;
     private assertIndexFeatures;
     /**
      * Index types this dialect spells as a keyword of their own (`FULLTEXT INDEX`, `VECTOR INDEX`)
@@ -51,7 +60,7 @@ export declare class IndexDdl<D extends AbstractSqlDialect = AbstractSqlDialect>
     protected indexInclude(_index: IndexSchema): string;
     /** ` USING <method>`, which SQLite's grammar has no place for at all. */
     protected indexAccessMethod(_index: IndexSchema): string;
-    /** pgvector's ` WITH (m = ..., ef_construction = ..., lists = ...)`. */
+    /** What trails the columns: pgvector's ` WITH (m = ...)`, MySQL's ` USING btree`, MariaDB's ` M=8`. */
     protected indexTuning(_index: IndexSchema): string;
     /**
      * The partial-index predicate. Engines without one reject the index in {@link assertIndexFeatures}

package/dist/migrate/ddl/indexDdl.js

@@ -1,4 +1,5 @@
 import { jsonTypeMode } from '../../dialect/jsonSql.js';
+import { INDEX_TYPES } from '../../schema/types.js';
 import { INDEX_FEATURE_LABELS, } from '../../type/index.js';
 import { getKeys } from '../../util/index.js';
 /**
@@ -29,6 +30,7 @@ export class IndexDdl {
         this.dialect = dialect;
     }
     getCreateIndexStatement(tableName, index, opts = {}) {
+        this.assertIndexType(index);
         this.assertIndexFeatures(index);
         const unique = index.unique ? 'UNIQUE ' : '';
         const ifNotExists = (opts.ifNotExists ?? this.dialect.features.indexIfNotExists) ? 'IF NOT EXISTS ' : '';
@@ -47,6 +49,20 @@ export class IndexDdl {
         'partial',
         'jsonPath',
     ]);
+    /**
+     * Index types this dialect's `CREATE INDEX` takes. SQLite's grammar has no `USING` clause, so every
+     * type builds the plain index it has there, which is what lets an entity written for Postgres
+     * migrate unchanged. An engine that would reject a type narrows this, and the type is refused.
+     */
+    indexTypes = new Set(INDEX_TYPES);
+    /** What to declare instead of a type this dialect lacks, appended to its refusal. */
+    indexTypeHints = new Map();
+    assertIndexType(index) {
+        if (index.type && !this.indexTypes.has(index.type)) {
+            throw new TypeError(`${this.dialect.dialectName} has no ${index.type} index (index "${index.name}")` +
+                (this.indexTypeHints.get(index.type) ?? ''));
+        }
+    }
     assertIndexFeatures(index) {
         for (const feature of getKeys(INDEX_FEATURE_PROBES)) {
             if (INDEX_FEATURE_PROBES[feature](index) && !this.indexFeatures.has(feature)) {
@@ -111,7 +127,7 @@ export class IndexDdl {
     indexAccessMethod(_index) {
         return '';
     }
-    /** pgvector's ` WITH (m = ..., ef_construction = ..., lists = ...)`. */
+    /** What trails the columns: pgvector's ` WITH (m = ...)`, MySQL's ` USING btree`, MariaDB's ` M=8`. */
     indexTuning(_index) {
         return '';
     }

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

@@ -0,0 +1,10 @@
+import { IndexDdl } from './indexDdl.js';
+/**
+ * SQL Server's `CREATE INDEX` is the portable form minus what 2025 rejects: an expression (Msg 16216),
+ * the subquery a JSON path compiles to (Msg 1046), and any type but the plain rowstore B-tree, since
+ * the index built in its place fails on a `VECTOR` or `nvarchar(max)` column (Msg 1978).
+ */
+export declare class MsSqlIndexDdl extends IndexDdl {
+    protected readonly indexFeatures: Set<"expression" | "include" | "jsonArray" | "jsonPath" | "nullsOrder" | "opsClass" | "partial" | "prefixLength">;
+    protected readonly indexTypes: Set<"brin" | "btree" | "fulltext" | "gin" | "gist" | "hash" | "hnsw" | "ivfflat" | "vector" | "vectorSearch">;
+}

package/dist/migrate/ddl/mssqlIndexDdl.js

@@ -0,0 +1,10 @@
+import { IndexDdl } from './indexDdl.js';
+/**
+ * SQL Server's `CREATE INDEX` is the portable form minus what 2025 rejects: an expression (Msg 16216),
+ * the subquery a JSON path compiles to (Msg 1046), and any type but the plain rowstore B-tree, since
+ * the index built in its place fails on a `VECTOR` or `nvarchar(max)` column (Msg 1978).
+ */
+export class MsSqlIndexDdl extends IndexDdl {
+    indexFeatures = new Set(['partial']);
+    indexTypes = new Set(['btree']);
+}

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

@@ -1,19 +1,13 @@
 import type { IndexType } from '../../schema/types.js';
 import type { IndexJsonArray, IndexSchema } from '../../type/index.js';
 import { IndexDdl } from './indexDdl.js';
-/** `CREATE INDEX ... USING btree`, plus the types this family spells as a keyword instead. */
+/** `CREATE INDEX ... (cols) USING btree`, plus the types this family spells as a keyword instead. */
 export declare class MysqlLikeIndexDdl extends IndexDdl {
     protected readonly indexFeatures: Set<"expression" | "include" | "jsonArray" | "jsonPath" | "nullsOrder" | "opsClass" | "partial" | "prefixLength">;
+    protected readonly indexTypes: ReadonlySet<IndexType>;
     protected readonly indexTypeKeywords: ReadonlyMap<IndexType, string>;
-    /**
-     * ` USING btree|hash`, for the types this family does *not* spell as a keyword of its own. A vector
-     * type that is neither is one this engine has no index for at all, refused here rather than
-     * compiled into a ` USING hnsw` the server can only answer with a syntax error: which of them a
-     * dialect *does* have is `indexTypeKeywords`, so declaring one there is all it takes to serve it.
-     */
-    protected indexAccessMethod(index: IndexSchema): string;
-    /** What to do instead, appended to the refusal above. */
-    protected readonly vectorIndexHint: string;
+    /** ` USING btree|hash` trails the columns: between the table and them, it is a syntax error here. */
+    protected indexTuning(index: IndexSchema): string;
 }
 export declare class MySqlIndexDdl extends MysqlLikeIndexDdl {
     /** The multi-valued index is the only JSON index MySQL has - see `IndexFeature` for why. */
@@ -25,12 +19,10 @@ export declare class MySqlIndexDdl extends MysqlLikeIndexDdl {
      */
     protected jsonArrayIndexExpr(escapedColumn: string, json: IndexJsonArray): string;
     /**
-     * MySQL has no vector index of any kind, so one is refused rather than compiled to DDL the server
-     * rejects: `USING hnsw` is a syntax error, and MariaDB's `VECTOR INDEX` is not MySQL syntax either.
-     * Verified against 26.7, which does have `VECTOR` columns and `STRING_TO_VECTOR`, but no distance
-     * function outside HeatWave - hence nothing to index for.
+     * MySQL 26.7 has `VECTOR` columns and `STRING_TO_VECTOR`, but no distance function outside
+     * HeatWave, hence no vector index to build: `USING hnsw` is a syntax error, `VECTOR INDEX` MariaDB's.
      */
-    protected readonly vectorIndexHint = ". Vector search on MySQL needs HeatWave";
+    protected readonly indexTypeHints: Map<"brin" | "btree" | "fulltext" | "gin" | "gist" | "hash" | "hnsw" | "ivfflat" | "vector" | "vectorSearch", string>;
 }
 export declare class MariaIndexDdl extends MysqlLikeIndexDdl {
     /**
@@ -41,12 +33,13 @@ export declare class MariaIndexDdl extends MysqlLikeIndexDdl {
     protected readonly indexFeatures: Set<"expression" | "include" | "jsonArray" | "jsonPath" | "nullsOrder" | "opsClass" | "partial" | "prefixLength">;
     /** The family's, plus a vector index of its own: `CREATE VECTOR INDEX ... ON t (col)`, 11.7+. */
     protected readonly indexTypeKeywords: ReadonlyMap<IndexType, string>;
+    protected readonly indexTypes: Set<"brin" | "btree" | "fulltext" | "gin" | "gist" | "hash" | "hnsw" | "ivfflat" | "vector" | "vectorSearch">;
+    /** pgvector's names are not access methods it has; `vector` is its own keyword above. */
+    protected readonly indexTypeHints: Map<"brin" | "btree" | "fulltext" | "gin" | "gist" | "hash" | "hnsw" | "ivfflat" | "vector" | "vectorSearch", string>;
     /**
      * `M=n DISTANCE=metric`, trailing its `CREATE VECTOR INDEX`. The metric names are MariaDB's own
      * (`euclidean`, not `l2`), and an unsupported one throws rather than being dropped, which would
      * silently build the index on euclidean - its default - instead of what the entity asked for.
      */
     protected indexTuning(index: IndexSchema): string;
-    /** `vector` is its own keyword above; pgvector's names are not access methods it has. */
-    protected readonly vectorIndexHint = "; declare type: 'vector' instead";
 }

package/dist/migrate/ddl/mysqlIndexDdl.js

@@ -1,34 +1,21 @@
 import { jsonPath } from '../../dialect/jsonSql.js';
 import { MARIA_VECTOR_METRICS } from '../../maria/mariaVectorMetrics.js';
-import { isVectorIndexType, unsupportedVectorMetric } from '../../type/vector.js';
+import { unsupportedVectorMetric, VECTOR_INDEX_TYPES } from '../../type/vector.js';
 import { IndexDdl } from './indexDdl.js';
 /**
  * A full-text index is its own keyword here (`CREATE FULLTEXT INDEX ... (cols)`); `USING fulltext` is
  * a syntax error, so it is the keyword that changes rather than the access method.
  */
 const MYSQL_LIKE_INDEX_KEYWORDS = new Map([['fulltext', 'FULLTEXT INDEX']]);
-/** `CREATE INDEX ... USING btree`, plus the types this family spells as a keyword instead. */
+/** `CREATE INDEX ... (cols) USING btree`, plus the types this family spells as a keyword instead. */
 export class MysqlLikeIndexDdl extends IndexDdl {
     indexFeatures = new Set(['expression', 'prefixLength']);
+    indexTypes = new Set(['btree', 'hash', 'fulltext']);
     indexTypeKeywords = MYSQL_LIKE_INDEX_KEYWORDS;
-    /**
-     * ` USING btree|hash`, for the types this family does *not* spell as a keyword of its own. A vector
-     * type that is neither is one this engine has no index for at all, refused here rather than
-     * compiled into a ` USING hnsw` the server can only answer with a syntax error: which of them a
-     * dialect *does* have is `indexTypeKeywords`, so declaring one there is all it takes to serve it.
-     */
-    indexAccessMethod(index) {
-        const type = index.type;
-        if (!type || this.indexTypeKeywords.has(type)) {
-            return '';
-        }
-        if (isVectorIndexType(type)) {
-            throw new TypeError(`${this.dialect.dialectName} has no ${type} index (index "${index.name}")${this.vectorIndexHint}`);
-        }
-        return ` USING ${type}`;
+    /** ` USING btree|hash` trails the columns: between the table and them, it is a syntax error here. */
+    indexTuning(index) {
+        return index.type && !this.indexTypeKeywords.has(index.type) ? ` USING ${index.type}` : '';
     }
-    /** What to do instead, appended to the refusal above. */
-    vectorIndexHint = '';
 }
 export class MySqlIndexDdl extends MysqlLikeIndexDdl {
     /** The multi-valued index is the only JSON index MySQL has - see `IndexFeature` for why. */
@@ -43,12 +30,10 @@ export class MySqlIndexDdl extends MysqlLikeIndexDdl {
         return `CAST(${source} AS ${arrayCastType(json)} ARRAY)`;
     }
     /**
-     * MySQL has no vector index of any kind, so one is refused rather than compiled to DDL the server
-     * rejects: `USING hnsw` is a syntax error, and MariaDB's `VECTOR INDEX` is not MySQL syntax either.
-     * Verified against 26.7, which does have `VECTOR` columns and `STRING_TO_VECTOR`, but no distance
-     * function outside HeatWave - hence nothing to index for.
+     * MySQL 26.7 has `VECTOR` columns and `STRING_TO_VECTOR`, but no distance function outside
+     * HeatWave, hence no vector index to build: `USING hnsw` is a syntax error, `VECTOR INDEX` MariaDB's.
      */
-    vectorIndexHint = '. Vector search on MySQL needs HeatWave';
+    indexTypeHints = new Map(VECTOR_INDEX_TYPES.map((type) => [type, '. Vector search on MySQL needs HeatWave']));
 }
 export class MariaIndexDdl extends MysqlLikeIndexDdl {
     /**
@@ -62,13 +47,19 @@ export class MariaIndexDdl extends MysqlLikeIndexDdl {
         ...MYSQL_LIKE_INDEX_KEYWORDS,
         ['vector', 'VECTOR INDEX'],
     ]);
+    indexTypes = new Set(['btree', 'hash', 'fulltext', 'vector']);
+    /** pgvector's names are not access methods it has; `vector` is its own keyword above. */
+    indexTypeHints = new Map([
+        ['hnsw', "; declare type: 'vector' instead"],
+        ['ivfflat', "; declare type: 'vector' instead"],
+    ]);
     /**
      * `M=n DISTANCE=metric`, trailing its `CREATE VECTOR INDEX`. The metric names are MariaDB's own
      * (`euclidean`, not `l2`), and an unsupported one throws rather than being dropped, which would
      * silently build the index on euclidean - its default - instead of what the entity asked for.
      */
     indexTuning(index) {
-        let tuning = index.m === undefined ? '' : ` M=${index.m}`;
+        let tuning = super.indexTuning(index) + (index.m === undefined ? '' : ` M=${index.m}`);
         if (index.distance) {
             const metric = MARIA_VECTOR_METRICS.get(index.distance);
             if (!metric) {
@@ -78,8 +69,6 @@ export class MariaIndexDdl extends MysqlLikeIndexDdl {
         }
         return tuning;
     }
-    /** `vector` is its own keyword above; pgvector's names are not access methods it has. */
-    vectorIndexHint = "; declare type: 'vector' instead";
 }
 /**
  * MySQL's `CAST(... AS <type> ARRAY)` targets, the closed list its multi-valued index takes: no

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

@@ -1,9 +1,16 @@
-import type { PgLikeSqlDialect } from '../../dialect/pgLikeSqlDialect.js';
 import type { IndexColumnSchema, IndexSchema } from '../../type/index.js';
 import { IndexDdl } from './indexDdl.js';
 /** `CREATE INDEX ... USING hnsw ("embedding" vector_cosine_ops) WITH (m = ...)`, pgvector's form. */
-export declare class PgIndexDdl extends IndexDdl<PgLikeSqlDialect> {
+export declare class PgIndexDdl extends IndexDdl {
+    /** Postgres 18's `pg_am`, with pgvector's two. */
+    protected readonly indexTypes: Set<"brin" | "btree" | "fulltext" | "gin" | "gist" | "hash" | "hnsw" | "ivfflat" | "vector" | "vectorSearch">;
+    protected readonly indexTypeHints: ReadonlyMap<"brin" | "btree" | "fulltext" | "gin" | "gist" | "hash" | "hnsw" | "ivfflat" | "vector" | "vectorSearch", string>;
     protected readonly indexFeatures: Set<"expression" | "include" | "jsonArray" | "jsonPath" | "nullsOrder" | "opsClass" | "partial" | "prefixLength">;
+    /** The metrics its vector index takes, each naming the operator class it is built with. */
+    protected readonly vectorMetrics: ReadonlyMap<import("../../type/vector.js").VectorDistance, {
+        readonly op: string;
+        readonly opsSuffix: string;
+    }>;
     /** pgvector's own index types; CockroachDB's native one widens this. */
     protected isVectorIndex(index: IndexSchema): boolean;
     protected indexAccessMethod(index: IndexSchema): string;
@@ -28,9 +35,17 @@ export declare class PgIndexDdl extends IndexDdl<PgLikeSqlDialect> {
  */
 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. */
+    protected readonly indexTypes: Set<"brin" | "btree" | "fulltext" | "gin" | "gist" | "hash" | "hnsw" | "ivfflat" | "vector" | "vectorSearch">;
+    protected readonly indexTypeHints: Map<"brin" | "btree" | "fulltext" | "gin" | "gist" | "hash" | "hnsw" | "ivfflat" | "vector" | "vectorSearch", string>;
+    protected readonly vectorMetrics: ReadonlyMap<import("../../type/vector.js").VectorDistance, {
+        readonly op: string;
+        readonly opsSuffix: string;
+    }>;
     private isNativeVectorIndex;
     protected isVectorIndex(index: IndexSchema): boolean;
     protected indexKeyword(index: IndexSchema): string;
     protected indexAccessMethod(index: IndexSchema): string;
-    protected indexTuning(index: IndexSchema): string;
+    /** None of pgvector's knobs: `WITH (m = 16)` answers "invalid storage parameter", `hnsw` included. */
+    protected indexTuning(): string;
 }

package/dist/migrate/ddl/pgIndexDdl.js

@@ -1,7 +1,23 @@
+import { COCKROACH_VECTOR_METRICS, PG_VECTOR_METRICS } from '../../dialect/pgVectorMetrics.js';
 import { unsupportedVectorMetric } from '../../type/vector.js';
 import { IndexDdl } from './indexDdl.js';
+/** `$text` computes its `TO_TSVECTOR` per row, which no index over the raw columns serves. */
+const PG_INDEX_TYPE_HINTS = new Map([
+    ['fulltext', '. $text needs none there; name the columns it searches with $fields.'],
+]);
 /** `CREATE INDEX ... USING hnsw ("embedding" vector_cosine_ops) WITH (m = ...)`, pgvector's form. */
 export class PgIndexDdl extends IndexDdl {
+    /** Postgres 18's `pg_am`, with pgvector's two. */
+    indexTypes = new Set([
+        'btree',
+        'hash',
+        'gin',
+        'gist',
+        'brin',
+        'hnsw',
+        'ivfflat',
+    ]);
+    indexTypeHints = PG_INDEX_TYPE_HINTS;
     indexFeatures = new Set([
         'expression',
         'partial',
@@ -10,6 +26,8 @@ export class PgIndexDdl extends IndexDdl {
         'include',
         'jsonPath',
     ]);
+    /** The metrics its vector index takes, each naming the operator class it is built with. */
+    vectorMetrics = PG_VECTOR_METRICS;
     /** pgvector's own index types; CockroachDB's native one widens this. */
     isVectorIndex(index) {
         return index.type === 'hnsw' || index.type === 'ivfflat';
@@ -28,7 +46,7 @@ export class PgIndexDdl extends IndexDdl {
         if (!this.isVectorIndex(index) || !index.distance) {
             return entry.opsClass ? ` ${entry.opsClass}` : '';
         }
-        const metric = this.dialect.vectorMetrics.get(index.distance);
+        const metric = this.vectorMetrics.get(index.distance);
         if (!metric) {
             throw unsupportedVectorMetric(this.dialect.dialectName, index.distance, index.name);
         }
@@ -69,6 +87,13 @@ export class PgIndexDdl extends IndexDdl {
  */
 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. */
+    indexTypes = new Set(['btree', 'gin', 'gist', 'hnsw', 'vector']);
+    indexTypeHints = new Map([
+        ...PG_INDEX_TYPE_HINTS,
+        ['ivfflat', "; declare type: 'vector' instead"],
+    ]);
+    vectorMetrics = COCKROACH_VECTOR_METRICS;
     isNativeVectorIndex(index) {
         return index.type === 'vector';
     }
@@ -81,7 +106,8 @@ export class CockroachIndexDdl extends PgIndexDdl {
     indexAccessMethod(index) {
         return this.isNativeVectorIndex(index) ? '' : super.indexAccessMethod(index);
     }
-    indexTuning(index) {
-        return this.isNativeVectorIndex(index) ? '' : super.indexTuning(index);
+    /** None of pgvector's knobs: `WITH (m = 16)` answers "invalid storage parameter", `hnsw` included. */
+    indexTuning() {
+        return '';
     }
 }

package/dist/migrate/drift/driftDetector.js

@@ -5,7 +5,7 @@
  * actual database schema.
  */
 import { canonicalToSql, engineType } from '../../schema/canonicalType.js';
-import { diffSchemas } from '../../schema/schemaASTDiffer.js';
+import { diffSchemas, referentialActions } from '../../schema/schemaASTDiffer.js';
 function resolveOptions(options) {
     return {
         checkTypes: options.checkTypes ?? true,
@@ -114,7 +114,7 @@ function detectColumnDrifts(diff, opts) {
                 suggestion: 'Add to entity or create migration to drop',
             });
         }
-        else if (colDiff.type === 'alter') {
+        else {
             addAlterColumnDrifts(colDiff, drifts, opts);
         }
     }
@@ -124,10 +124,6 @@ function detectColumnDrifts(diff, opts) {
  * Add drifts for column alterations (type/nullable mismatches).
  */
 function addAlterColumnDrifts(colDiff, drifts, opts) {
-    // Every check below compares the two sides, so there is nothing to report without both.
-    if (!colDiff.expected || !colDiff.actual) {
-        return;
-    }
     // An auto-increment key is created through the dialect's `serialPrimaryKey`, whose spelling the
     // entity never states - `BIGINT UNSIGNED AUTO_INCREMENT` on the MySQL family, where the column then
     // reads back as `BIGINT UNSIGNED` against an entity that can only say `BIGINT`. Comparing the two
@@ -206,7 +202,7 @@ function detectIndexDrifts(diff) {
                 suggestion: 'Add @Field({ index }) or create migration to drop',
             });
         }
-        else if (idxDiff.type === 'alter') {
+        else {
             // No `expected`/`actual` here: the CLI prints those by interpolation, where an `IndexNode`
             // renders as `[object Object]`. What differs is already spelled out in `description`.
             drifts.push({
@@ -247,9 +243,26 @@ function detectRelationshipDrifts(diff) {
                 suggestion: 'Add relation to entity or drop FK',
             });
         }
+        else {
+            drifts.push({
+                type: 'relationship_mismatch',
+                severity: 'warning',
+                table: relDiff.fromTable,
+                relationship: relDiff.name,
+                expected: formatActions(relDiff.expected),
+                actual: formatActions(relDiff.actual),
+                details: `FK "${relDiff.name}" has other referential actions in the database than in the entity`,
+                suggestion: 'Generate a migration, which drops and re-adds the constraint',
+            });
+        }
     }
     return drifts;
 }
+/** Both actions spelled out, so a side that left one unstated reads the same as one that stated the default. */
+function formatActions(rel) {
+    const { onDelete, onUpdate } = referentialActions(rel);
+    return `ON DELETE ${onDelete} ON UPDATE ${onUpdate}`;
+}
 /**
  * Calculate overall status based on drifts.
  */
@@ -275,7 +288,7 @@ function createSummary(drifts) {
  * Format type for display.
  */
 function formatType(type, dialect) {
-    if (!type || !dialect)
+    if (!dialect)
         return 'unknown';
     return canonicalToSql(type, dialect);
 }

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -147,7 +147,7 @@ export class MongoSchemaGenerator extends AbstractDialect {
         if (!currentTable) {
             return { tableName: collectionName, type: 'create' };
         }
-        const existingIndexes = new Set(currentTable.indexes?.map((i) => i.name) ?? []);
+        const existingIndexes = new Set(currentTable.indexes.map((i) => i.name));
         const indexesToAdd = this.fieldIndexes(meta, collectionName).filter((index) => !existingIndexes.has(index.name));
         if (indexesToAdd.length === 0) {
             return undefined;

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

@@ -29,7 +29,7 @@ export declare abstract class BaseSqlIntrospector {
      * Build SchemaAST from table schemas.
      */
     protected buildAST(tableSchemas: TableSchema[]): SchemaAST;
-    private buildTables;
+    private buildTable;
     private buildRelationships;
     private buildIndexes;
 }

package/dist/migrate/introspection/baseSqlIntrospector.js

@@ -43,90 +43,79 @@ export class BaseSqlIntrospector {
      */
     buildAST(tableSchemas) {
         const ast = new SchemaAST();
-        const tableNodes = new Map();
-        this.buildTables(ast, tableNodes, tableSchemas);
-        this.buildRelationships(ast, tableNodes, tableSchemas);
-        this.buildIndexes(ast, tableNodes, tableSchemas);
+        // Every table first, so a foreign key reaches a table introspected after the one it leaves from.
+        const tables = tableSchemas.map((schema) => ({ schema, table: this.buildTable(schema) }));
+        const tableNodes = new Map(tables.map(({ schema, table }) => [schema.name, table]));
+        for (const { table } of tables) {
+            ast.addTable(table);
+        }
+        for (const { schema, table } of tables) {
+            this.buildRelationships(ast, tableNodes, schema, table);
+            this.buildIndexes(ast, schema, table);
+        }
         return ast;
     }
-    buildTables(ast, tableNodes, tableSchemas) {
-        for (const schema of tableSchemas) {
-            const table = createTableNode(schema.name, this.schema);
-            const { columns } = table;
-            for (const col of schema.columns) {
-                // Spread, not field by field: a `ColumnSchema` is a `ColumnNode` minus the graph links, so
-                // everything but the type crosses unchanged and a field either shape gains cannot be dropped
-                // here. Listed by hand this had already lost `enum` and `generatedAs`.
-                const { type, length: _length, precision: _precision, scale: _scale, ...rest } = col;
-                const column = {
-                    ...rest,
-                    type: canonicalColumnType(type, col),
-                    table,
-                    referencedBy: [],
-                };
-                columns.set(col.name, column);
-            }
-            // From the ordered list the query returned, not from the per-column flags: `(a, b)` is a
-            // different key from `(b, a)`, and a flag says only that a column is *in* the key. Falls back
-            // to the flags for an introspector that reports no key of its own.
-            const keyColumns = schema.primaryKey ?? schema.columns.filter((col) => col.isPrimaryKey).map((col) => col.name);
-            table.primaryKey.push(...keyColumns.flatMap((name) => columns.get(name) ?? []));
-            table.primaryKeyName = schema.primaryKeyName;
-            tableNodes.set(schema.name, table);
-            ast.addTable(table);
+    buildTable(schema) {
+        const table = createTableNode(schema.name, this.schema);
+        const { columns } = table;
+        for (const col of schema.columns) {
+            // Spread, not field by field: a `ColumnSchema` is a `ColumnNode` minus the graph links, so
+            // everything but the type crosses unchanged and a field either shape gains cannot be dropped
+            // here. Listed by hand this had already lost `enum` and `generatedAs`.
+            const { type, length: _length, precision: _precision, scale: _scale, ...rest } = col;
+            const column = {
+                ...rest,
+                type: canonicalColumnType(type, col),
+                table,
+                referencedBy: [],
+            };
+            columns.set(col.name, column);
         }
+        // From the ordered list the query returned, not from the per-column flags: `(a, b)` is a
+        // different key from `(b, a)`, and a flag says only that a column is *in* the key. Falls back
+        // to the flags for an introspector that reports no key of its own.
+        const keyColumns = schema.primaryKey ?? schema.columns.filter((col) => col.isPrimaryKey).map((col) => col.name);
+        table.primaryKey.push(...keyColumns.flatMap((name) => columns.get(name) ?? []));
+        table.primaryKeyName = schema.primaryKeyName;
+        return table;
     }
-    buildRelationships(ast, tableNodes, tableSchemas) {
-        for (const schema of tableSchemas) {
-            if (!schema.foreignKeys)
+    buildRelationships(ast, tableNodes, schema, fromTable) {
+        for (const fk of schema.foreignKeys ?? []) {
+            const toTable = tableNodes.get(fk.references.table);
+            if (!toTable)
                 continue;
-            const fromTable = tableNodes.get(schema.name);
-            if (!fromTable)
-                continue;
-            for (const fk of schema.foreignKeys) {
-                const toTable = tableNodes.get(fk.references.table);
-                if (!toTable)
-                    continue;
-                const fromColumns = fk.columns.flatMap((name) => fromTable.columns.get(name) ?? []);
-                const toColumns = fk.references.columns.flatMap((name) => toTable.columns.get(name) ?? []);
-                if (fromColumns.length > 0 && toColumns.length > 0) {
-                    const rel = {
-                        name: fk.name ?? derivedForeignKeyName(schema.name, fk.columns),
-                        type: fromColumns[0].isUnique ? 'OneToOne' : 'ManyToOne',
-                        from: { table: fromTable, columns: fromColumns },
-                        to: { table: toTable, columns: toColumns },
-                        onDelete: fk.onDelete || 'NO ACTION',
-                        onUpdate: fk.onUpdate || 'NO ACTION',
-                    };
-                    ast.addRelationship(rel);
-                }
+            const fromColumns = fk.columns.flatMap((name) => fromTable.columns.get(name) ?? []);
+            const toColumns = fk.references.columns.flatMap((name) => toTable.columns.get(name) ?? []);
+            if (fromColumns.length > 0 && toColumns.length > 0) {
+                const rel = {
+                    name: fk.name ?? derivedForeignKeyName(schema.name, fk.columns),
+                    type: fromColumns[0].isUnique ? 'OneToOne' : 'ManyToOne',
+                    from: { table: fromTable, columns: fromColumns },
+                    to: { table: toTable, columns: toColumns },
+                    onDelete: fk.onDelete || 'NO ACTION',
+                    onUpdate: fk.onUpdate || 'NO ACTION',
+                };
+                ast.addRelationship(rel);
             }
         }
     }
-    buildIndexes(ast, tableNodes, tableSchemas) {
-        for (const schema of tableSchemas) {
-            if (!schema.indexes)
-                continue;
-            const table = tableNodes.get(schema.name);
-            if (!table)
-                continue;
-            for (const idx of schema.indexes) {
-                // An expression has no column to resolve. Dropping the entries that name a column this table
-                // does not have, and the index if that leaves none, is what the entity side does too.
-                const entries = idx.entries.filter((entry) => entry.expression || table.columns.has(entry.column));
-                if (entries.length > 0) {
-                    const index = {
-                        name: idx.name,
-                        table,
-                        entries,
-                        unique: idx.unique,
-                        type: idx.type,
-                        where: idx.where,
-                        include: idx.include,
-                        source: 'database',
-                    };
-                    ast.addIndex(index);
-                }
+    buildIndexes(ast, schema, table) {
+        for (const idx of schema.indexes ?? []) {
+            // An expression has no column to resolve. Dropping the entries that name a column this table
+            // does not have, and the index if that leaves none, is what the entity side does too.
+            const entries = idx.entries.filter((entry) => entry.expression || table.columns.has(entry.column));
+            if (entries.length > 0) {
+                const index = {
+                    name: idx.name,
+                    table,
+                    entries,
+                    unique: idx.unique,
+                    type: idx.type,
+                    where: idx.where,
+                    include: idx.include,
+                    source: 'database',
+                };
+                ast.addIndex(index);
             }
         }
     }

package/dist/migrate/introspection/mssqlIntrospector.js

@@ -27,7 +27,8 @@ export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     `;
     }
     parseTableExistsResult(results) {
-        return (this.toNumber(results[0]?.count) ?? 0) > 0;
+        // No row, or no count in it, reads as `NaN`, which is not above zero.
+        return Number(results[0]?.count) > 0;
     }
     /**
      * From `sys` rather than `INFORMATION_SCHEMA`, which has no identity flag and no per-column view of