uql-orm 0.80.0 → 0.81.0

package/dist/dialect/vectorSqlDialect.d.ts

@@ -30,6 +30,8 @@ export declare abstract class VectorSqlDialect extends AbstractDialect {
     readonly vectorMetrics: ReadonlyMap<VectorDistance, VectorMetric>;
     /** Whether this engine has a vector index: the one a metric's `index` names. */
     hasVectorIndex(): boolean;
+    /** The distance a vector index built for `metric`, as {@link vectorMetrics} names it for an index, measures. */
+    indexedDistance(metric: string | undefined): VectorDistance | undefined;
     /** Quotes an identifier; supplied by the SQL dialect built on top of this layer. */
     abstract escapeId(val: string | undefined, forbidQualified?: boolean, addDot?: boolean): string;
     /** What a distance expression reads, for a `$sort` and a `$near` alike. */

package/dist/dialect/vectorSqlDialect.js

@@ -45,6 +45,10 @@ export class VectorSqlDialect extends AbstractDialect {
     hasVectorIndex() {
         return [...this.vectorMetrics.values()].some((metric) => metric.index);
     }
+    /** The distance a vector index built for `metric`, as {@link vectorMetrics} names it for an index, measures. */
+    indexedDistance(metric) {
+        return [...this.vectorMetrics].find(([, { index }]) => index === metric)?.[0];
+    }
     /** What a distance expression reads, for a `$sort` and a `$near` alike. */
     resolveVectorDistance(meta, key, search) {
         const field = meta.fields[key];

package/dist/migrate/builder/expressions.d.ts

@@ -63,3 +63,5 @@ export declare const expr: {
  * the result needs wrapping, which MySQL demands on its large types whatever the value.
  */
 export declare function formatDefaultValue(value: unknown, dialect: AbstractSqlDialect, columnType?: string): string;
+/** Whether a stored default is the declared one, as the engine reprints it: `'a'::character varying` is `'a'`. */
+export declare function sameDefault(desired: unknown, current: unknown, dialect: AbstractSqlDialect): boolean;

package/dist/migrate/builder/expressions.js

@@ -83,6 +83,30 @@ export function formatDefaultValue(value, dialect, columnType) {
     const { wrapTypes } = DIALECT_DEFAULTS[dialect.dialectName];
     return columnType !== undefined && wrapTypes?.test(columnType) ? `(${sql})` : sql;
 }
+/** Whether a stored default is the declared one, as the engine reprints it: `'a'::character varying` is `'a'`. */
+export function sameDefault(desired, current, dialect) {
+    if (current === desired)
+        return true;
+    // Both spellings of "no default" are the same fact, and engines disagree on which they report:
+    // MariaDB says `null` where MySQL says nothing at all. Reading them as different values asked to
+    // `MODIFY` every nullable column, on every sync, forever.
+    if (current == null || desired == null)
+        return current == null && desired == null;
+    const normalize = (value) => {
+        // Render first: the desired side may be a symbolic expression, the current side is always the
+        // engine's own text, and `{"kind":"now"}` matches no spelling of `CURRENT_TIMESTAMP`.
+        const val = SqlExpression.isExpression(value) ? formatDefaultValue(value, dialect) : value;
+        if (typeof val === 'string') {
+            let s = val.replace(/::[a-z_]+(\s+[a-z_]+)*(\[\])?$/i, '');
+            s = s.replace(/^'(.*)'$/, '$1');
+            if (s.toLowerCase() === 'null')
+                return 'null';
+            return s;
+        }
+        return typeof val === 'object' ? JSON.stringify(val) : String(val);
+    };
+    return normalize(current) === normalize(desired);
+}
 /**
  * Quoting is the dialect's `escape`, so a backslash in a default is escaped the way the engine reads
  * it - MySQL takes `'a\b'` as a backspace where Postgres takes it literally. Only the cases `escape`

package/dist/migrate/cli.js

@@ -247,7 +247,7 @@ export async function runDriftCheck(migrator, config) {
         // `unknown` and type drift compares equal, silently reporting a mismatched column as in sync.
         const report = detectDrift(expectedAST, actualAST, {
             dialect: config.pool?.dialect,
-            indexFacets: migrator.schemaIntrospector.indexFacets,
+            defaultsEqual: generator.defaultsEqual,
             excludeTables: [config.tableName ?? DEFAULT_MIGRATIONS_TABLE],
         });
         printDriftReport(report);

package/dist/migrate/codegen/entityCodeGenerator.js

@@ -252,8 +252,8 @@ export class EntityCodeGenerator {
         }
         const member = (param, column) => memberSource(param, this.options.propertyNameTransformer(column.name));
         const own = lowerFirst(this.options.classNameTransformer(rel.from.table.name));
-        const key = rel.to.table.primaryKey;
-        if (rel.from.columns.length === 1 && key.length === 1 && rel.to.columns[0].name === key[0].name) {
+        const key = rel.to.table.primaryKey?.columns ?? [];
+        if (rel.from.columns.length === 1 && key.length === 1 && rel.to.columns[0].name === key[0]) {
             return `(${own}) => ${member(own, rel.from.columns[0])}`;
         }
         const target = lowerFirst(relatedClassName);

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

@@ -1,8 +1,9 @@
 import type { IndexNode } from '../../schema/types.js';
 /**
  * Whether `@Field({ index })` can carry the whole index. It says only "this column is indexed under
- * this name", so anything else the index declares - an expression, a predicate, uniqueness, an access
- * method, stored columns, a stored order - has to be written out as an `@Index` instead.
+ * this name", and `unique` beside it that the index is unique, so anything else the index declares - an
+ * expression, a predicate, an access method, stored columns, a stored order - has to be written out as
+ * an `@Index` instead.
  */
 export declare function isPlainFieldIndex(index: IndexNode): boolean;
 /**

package/dist/migrate/codegen/indexDecoratorSource.js

@@ -1,24 +1,5 @@
 import { isVectorIndexType } from '../../type/index.js';
 import { memberSource, rawTag } from './sourceLiteral.js';
-/**
- * A vector index carries its metric in the operator class pgvector names after it
- * (`vector_cosine_ops`), which is the only place introspection can recover it from. `@Index` requires
- * a `distance` beside a vector `type`, so emitting the type without one would not compile.
- */
-const DISTANCE_BY_OPS_SUFFIX = new Map([
-    ['cosine', 'cosine'],
-    ['l2', 'l2'],
-    ['ip', 'inner'],
-    ['l1', 'l1'],
-]);
-function vectorDistance(index) {
-    if (index.distance) {
-        return index.distance;
-    }
-    const opsClass = index.entries.map((entry) => entry.opsClass).find(Boolean);
-    const suffix = opsClass?.match(/_(\w+)_ops$/)?.[1];
-    return suffix === undefined ? undefined : DISTANCE_BY_OPS_SUFFIX.get(suffix);
-}
 /**
  * The per-entry modifiers worth writing into an entity, which is not everything introspection reports.
  * Postgres states an entry in full - a plain column comes back `order: 'asc', nulls: 'last'` - and
@@ -37,8 +18,9 @@ function significantModifiers(entry) {
 }
 /**
  * Whether `@Field({ index })` can carry the whole index. It says only "this column is indexed under
- * this name", so anything else the index declares - an expression, a predicate, uniqueness, an access
- * method, stored columns, a stored order - has to be written out as an `@Index` instead.
+ * this name", and `unique` beside it that the index is unique, so anything else the index declares - an
+ * expression, a predicate, an access method, stored columns, a stored order - has to be written out as
+ * an `@Index` instead.
  */
 export function isPlainFieldIndex(index) {
     const entries = index.entries;
@@ -46,7 +28,6 @@ export function isPlainFieldIndex(index) {
     return (entries.length === 1 &&
         entry !== undefined &&
         !entry.expression &&
-        !index.unique &&
         index.where === undefined &&
         // Postgres names an access method on every index, so the default one still counts as plain.
         (index.type === undefined || index.type === 'btree') &&
@@ -60,8 +41,9 @@ export function isPlainFieldIndex(index) {
  */
 export function buildIndexDecoratorSource(index, propertyName, param) {
     const entries = index.entries.map((entry) => indexEntrySource(entry, propertyName, param)).join(', ');
+    // `@Index` requires a `distance` beside a vector `type`, as the introspector reads it back.
     const isVector = isVectorIndexType(index.type);
-    const distance = isVector ? vectorDistance(index) : undefined;
+    const distance = isVector ? index.distance : undefined;
     const options = [];
     if (index.name)
         options.push(`name: '${index.name}'`);

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

@@ -2,15 +2,15 @@ import type { ColumnSchema } from '../../type/index.js';
 import { TableDdl } from './tableDdl.js';
 /**
  * SQL Server keeps a column's `DEFAULT`, `CHECK` and `UNIQUE` as constraints under names it picks, and
- * refuses to drop or retype the column past one, so they go first - looked up by column, as no two
- * databases name them alike. Renames are `sp_rename`, T-SQL having no `RENAME` clause.
+ * refuses to drop or retype the column past one or past an index over it, so they go first - looked up
+ * by column, as no two databases name them alike. Renames are `sp_rename`, T-SQL having no `RENAME` clause.
  */
 export declare class MsSqlTableDdl extends TableDdl {
     /** T-SQL has no `IF NOT EXISTS` on a table, so the create is guarded by a lookup in the same statement. */
     createTable(target: string, ifNotExists: boolean): string;
     /** T-SQL rejects the optional `COLUMN` keyword after `ADD`. */
     addColumn(table: string, definition: string): string;
-    /** Its constraints go with the column, as they do on every other engine. */
+    /** Its constraints and indexes go with the column, as they do on every other engine. */
     dropColumn(table: string, column: string): string[];
     /**
      * `ALTER COLUMN` takes the type and nullability alone, so the default is dropped and added back as a
@@ -21,5 +21,5 @@ export declare class MsSqlTableDdl extends TableDdl {
     renameTable(oldName: string, newName: string): string;
     storedGeneratedColumn(_type: string, expression: string): string;
     /** One statement, so a split on `;` cannot part the lookup from the `EXEC` it feeds. */
-    private dropConstraints;
+    private dropPinning;
 }

package/dist/migrate/ddl/mssqlTableDdl.js

@@ -1,19 +1,23 @@
 import { escapeSingleQuotes } from '../../util/sqlLiteral.js';
 import { sizedType, TableDdl } from './tableDdl.js';
-/** The constraints of each kind on column `c`, the `sys.columns` row {@link MsSqlTableDdl} reads. */
-const CONSTRAINTS_ON = {
-    default: /*sql*/ `SELECT d.name FROM sys.default_constraints d
+/** What pins column `c`, the `sys.columns` row {@link MsSqlTableDdl} reads: each constraint, then each index, by kind. */
+const PINNED_BY = {
+    default: /*sql*/ `SELECT d.name, 0 AS is_index FROM sys.default_constraints d
     WHERE d.parent_object_id = c.object_id AND d.parent_column_id = c.column_id`,
-    check: /*sql*/ `SELECT k.name FROM sys.check_constraints k
+    check: /*sql*/ `SELECT k.name, 0 AS is_index FROM sys.check_constraints k
     WHERE k.parent_object_id = c.object_id AND k.parent_column_id = c.column_id`,
-    unique: /*sql*/ `SELECT u.name FROM sys.key_constraints u
+    unique: /*sql*/ `SELECT u.name, 0 AS is_index FROM sys.key_constraints u
     JOIN sys.index_columns ic ON ic.object_id = u.parent_object_id AND ic.index_id = u.unique_index_id
     WHERE u.parent_object_id = c.object_id AND u.type = 'UQ' AND ic.column_id = c.column_id`,
+    index: /*sql*/ `SELECT DISTINCT i.name, 1 AS is_index FROM sys.indexes i
+    JOIN sys.index_columns ic ON ic.object_id = i.object_id AND ic.index_id = i.index_id
+    WHERE i.object_id = c.object_id AND ic.column_id = c.column_id
+      AND i.is_primary_key = 0 AND i.is_unique_constraint = 0`,
 };
 /**
  * SQL Server keeps a column's `DEFAULT`, `CHECK` and `UNIQUE` as constraints under names it picks, and
- * refuses to drop or retype the column past one, so they go first - looked up by column, as no two
- * databases name them alike. Renames are `sp_rename`, T-SQL having no `RENAME` clause.
+ * refuses to drop or retype the column past one or past an index over it, so they go first - looked up
+ * by column, as no two databases name them alike. Renames are `sp_rename`, T-SQL having no `RENAME` clause.
  */
 export class MsSqlTableDdl extends TableDdl {
     /** T-SQL has no `IF NOT EXISTS` on a table, so the create is guarded by a lookup in the same statement. */
@@ -25,9 +29,9 @@ export class MsSqlTableDdl extends TableDdl {
     addColumn(table, definition) {
         return /*sql*/ `ALTER TABLE ${this.dialect.escapeId(table)} ADD ${definition};`;
     }
-    /** Its constraints go with the column, as they do on every other engine. */
+    /** Its constraints and indexes go with the column, as they do on every other engine. */
     dropColumn(table, column) {
-        return [this.dropConstraints(table, column, Object.values(CONSTRAINTS_ON)), ...super.dropColumn(table, column)];
+        return [this.dropPinning(table, column, Object.values(PINNED_BY)), ...super.dropColumn(table, column)];
     }
     /**
      * `ALTER COLUMN` takes the type and nullability alone, so the default is dropped and added back as a
@@ -37,7 +41,7 @@ export class MsSqlTableDdl extends TableDdl {
         const target = this.dialect.escapeId(table);
         const name = this.dialect.escapeId(column.name);
         const statements = [
-            this.dropConstraints(table, column.name, [CONSTRAINTS_ON.default]),
+            this.dropPinning(table, column.name, [PINNED_BY.default]),
             /*sql*/ `ALTER TABLE ${target} ALTER COLUMN ${name} ${sizedType(column)} ${column.nullable ? 'NULL' : 'NOT NULL'};`,
         ];
         if (column.defaultValue !== undefined) {
@@ -56,10 +60,12 @@ export class MsSqlTableDdl extends TableDdl {
         return /*sql*/ `AS (${expression}) PERSISTED`;
     }
     /** One statement, so a split on `;` cannot part the lookup from the `EXEC` it feeds. */
-    dropConstraints(table, column, kinds) {
-        const target = this.dialect.escapeId(table);
-        return (`DECLARE @drop nvarchar(max) = (SELECT STRING_AGG(N'ALTER TABLE ${escapeSingleQuotes(target)} DROP CONSTRAINT ' ` +
-            `+ QUOTENAME(pinned.name), N'; ') FROM sys.columns c CROSS APPLY (${kinds.join(' UNION ALL ')}) pinned ` +
+    dropPinning(table, column, kinds) {
+        const target = escapeSingleQuotes(this.dialect.escapeId(table));
+        return (`DECLARE @drop nvarchar(max) = (SELECT STRING_AGG(CASE pinned.is_index ` +
+            `WHEN 1 THEN N'DROP INDEX ' + QUOTENAME(pinned.name) + N' ON ${target}' ` +
+            `ELSE N'ALTER TABLE ${target} DROP CONSTRAINT ' + QUOTENAME(pinned.name) END, N'; ') ` +
+            `FROM sys.columns c CROSS APPLY (${kinds.join(' UNION ALL ')}) pinned ` +
             `WHERE c.object_id = OBJECT_ID(${this.dialect.escape(target)}) AND c.name = ${this.dialect.escape(column)}) ` +
             'EXEC (@drop);');
     }

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

@@ -48,8 +48,8 @@ export declare class MariaIndexDdl extends MysqlLikeIndexDdl {
     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.
+     * (`euclidean`, not `l2`), stated even for the default distance, cosine, since MariaDB's own is
+     * euclidean; and an unsupported one throws rather than silently building on euclidean.
      */
     protected indexTuning(index: IndexSchema): string;
 }

package/dist/migrate/ddl/mysqlIndexDdl.js

@@ -1,5 +1,5 @@
 import { jsonTypeMode } from '../../dialect/jsonSql.js';
-import { unsupportedVectorMetric, VECTOR_INDEX_TYPES } from '../../type/vector.js';
+import { indexDistance, isVectorIndexType, 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
@@ -84,15 +84,16 @@ export class MariaIndexDdl extends MysqlLikeIndexDdl {
     ]);
     /**
      * `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.
+     * (`euclidean`, not `l2`), stated even for the default distance, cosine, since MariaDB's own is
+     * euclidean; and an unsupported one throws rather than silently building on euclidean.
      */
     indexTuning(index) {
         let tuning = super.indexTuning(index) + (index.m === undefined ? '' : ` M=${index.m}`);
-        if (index.distance) {
-            const metric = this.dialect.vectorMetrics.get(index.distance)?.index;
+        if (isVectorIndexType(index.type)) {
+            const distance = indexDistance(index);
+            const metric = this.dialect.vectorMetrics.get(distance)?.index;
             if (!metric) {
-                throw unsupportedVectorMetric(this.dialect.dialectName, index.distance, index.name);
+                throw unsupportedVectorMetric(this.dialect.dialectName, distance, index.name);
             }
             tuning += ` DISTANCE=${metric}`;
         }

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

@@ -10,7 +10,8 @@ export declare class PgIndexDdl extends IndexDdl {
     protected indexAccessMethod(index: IndexSchema): string;
     /**
      * 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.
+     * lacks rather than build with the default; any other entry takes the class it declares. Stated even
+     * for the default distance: pgvector's own default class is L2, which a cosine search never uses.
      */
     protected indexColumnOpsClass(entry: IndexColumnSchema, index: IndexSchema): string;
     protected indexInclude(index: IndexSchema): string;

package/dist/migrate/ddl/pgIndexDdl.js

@@ -1,4 +1,4 @@
-import { unsupportedVectorMetric } from '../../type/vector.js';
+import { indexDistance, unsupportedVectorMetric } from '../../type/vector.js';
 import { IndexDdl } from './indexDdl.js';
 /** `CREATE INDEX ... USING hnsw ("embedding" vector_cosine_ops) WITH (m = ...)`, pgvector's form. */
 export class PgIndexDdl extends IndexDdl {
@@ -33,20 +33,22 @@ export class PgIndexDdl extends IndexDdl {
     }
     /**
      * 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.
+     * lacks rather than build with the default; any other entry takes the class it declares. Stated even
+     * for the default distance: pgvector's own default class is L2, which a cosine search never uses.
      */
     indexColumnOpsClass(entry, index) {
-        if (!this.isVectorIndex(index) || !index.distance) {
+        if (!this.isVectorIndex(index)) {
             return entry.opsClass ? ` ${entry.opsClass}` : '';
         }
-        const metric = this.dialect.vectorMetrics.get(index.distance)?.index;
+        const distance = indexDistance(index);
+        const metric = this.dialect.vectorMetrics.get(distance)?.index;
         if (!metric) {
-            throw unsupportedVectorMetric(this.dialect.dialectName, index.distance, index.name);
+            throw unsupportedVectorMetric(this.dialect.dialectName, distance, index.name);
         }
         const vectorType = this.dialect.supportedVectorType(index.vectorType ?? 'vector');
         const opsClass = `${vectorType}_${metric}_ops`;
         // IVFFlat has neither a sparsevec nor an L1 operator class; HNSW has all of them (pgvector 0.8.2).
-        if (index.type === 'ivfflat' && (vectorType === 'sparsevec' || index.distance === 'l1')) {
+        if (index.type === 'ivfflat' && (vectorType === 'sparsevec' || distance === 'l1')) {
             throw new TypeError(`ivfflat has no ${opsClass} operator class (index "${index.name}"); use hnsw`);
         }
         return ` ${opsClass}`;

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

@@ -18,9 +18,10 @@ export declare class TableDdl {
     dropColumn(table: string, column: string): string[];
     /**
      * What changes `column` to what it now declares. `definition` is the whole column, which MySQL's
-     * `MODIFY COLUMN` restates; Postgres takes each change as a clause of its own.
+     * `MODIFY COLUMN` restates; Postgres takes each change as a clause of its own, so given what the
+     * column was (`from`), only the clauses that changed.
      */
-    alterColumn(table: string, column: ColumnSchema, definition: string): string[];
+    alterColumn(table: string, column: ColumnSchema, definition: string, from?: ColumnSchema): string[];
     renameColumn(table: string, oldName: string, newName: string): string;
     renameTable(oldName: string, newName: string): string;
     /** A stored generated column's type, with the clause computing it. */

package/dist/migrate/ddl/tableDdl.js

@@ -1,4 +1,4 @@
-import { formatDefaultValue } from '../builder/expressions.js';
+import { formatDefaultValue, sameDefault } from '../builder/expressions.js';
 /**
  * A column's type with the size it was read back with, unless its spelling already carries one:
  * introspection reports `VARCHAR` and `255` apart, where a type from an entity is already whole.
@@ -34,9 +34,10 @@ export class TableDdl {
     }
     /**
      * What changes `column` to what it now declares. `definition` is the whole column, which MySQL's
-     * `MODIFY COLUMN` restates; Postgres takes each change as a clause of its own.
+     * `MODIFY COLUMN` restates; Postgres takes each change as a clause of its own, so given what the
+     * column was (`from`), only the clauses that changed.
      */
-    alterColumn(table, column, definition) {
+    alterColumn(table, column, definition, from) {
         if (this.dialect.alterColumnSyntax === 'none') {
             throw new TypeError(`${this.dialect}: Cannot alter column "${column.name}" - you must recreate the table. ` +
                 `This database does not support ALTER COLUMN.`);
@@ -47,10 +48,11 @@ export class TableDdl {
         }
         const alter = `ALTER TABLE ${target} ALTER COLUMN ${this.dialect.escapeId(column.name)}`;
         return [
-            `${alter} TYPE ${column.type};`,
-            `${alter} ${column.nullable ? 'DROP NOT NULL' : 'SET NOT NULL'};`,
-            column.defaultValue === undefined ? `${alter} DROP DEFAULT;` : `${alter} SET${this.defaultClause(column)};`,
-        ];
+            (!from || from.type !== column.type) && `${alter} TYPE ${column.type};`,
+            (!from || from.nullable !== column.nullable) && `${alter} ${column.nullable ? 'DROP NOT NULL' : 'SET NOT NULL'};`,
+            (!from || !sameDefault(column.defaultValue, from.defaultValue, this.dialect)) &&
+                (column.defaultValue === undefined ? `${alter} DROP DEFAULT;` : `${alter} SET${this.defaultClause(column)};`),
+        ].filter((statement) => statement !== false);
     }
     renameColumn(table, oldName, newName) {
         const [target, from, to] = [table, oldName, newName].map((name) => this.dialect.escapeId(name));

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

@@ -5,7 +5,6 @@
  * actual database schema.
  */
 import type { AbstractDialect } from '../../dialect/abstractDialect.js';
-import type { IndexFacet } from '../../schema/indexDifferences.js';
 import type { SchemaAST } from '../../schema/schemaAST.js';
 import type { DriftReport } from '../../schema/types.js';
 /**
@@ -18,15 +17,15 @@ export interface DriftDetectorOptions {
     checkNullable?: boolean;
     /** Include index differences */
     checkIndexes?: boolean;
-    /** `indexFacets` of the introspector that produced the actual schema; anything else goes uncompared. */
-    indexFacets?: ReadonlySet<IndexFacet>;
     /** Include foreign key differences */
     checkForeignKeys?: boolean;
     /**
-     * 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.
+     * Include default value differences. Off unless {@link defaultsEqual} is given: without it defaults
+     * compare as written, and an engine reports one as it stored it (`now()`, `'active'::text`).
      */
     checkDefaults?: boolean;
+    /** How the engine's generator compares a default, so drift reports the ones a migration would change. */
+    defaultsEqual?: (expected: unknown, actual: unknown) => 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

package/dist/migrate/drift/driftDetector.js

@@ -5,15 +5,15 @@
  * actual database schema.
  */
 import { canonicalToSql, engineType } from '../../schema/canonicalType.js';
-import { diffSchemas, referentialActions } from '../../schema/schemaASTDiffer.js';
+import { defaultsEqualAsWritten, diffSchemas, referentialActions } from '../../schema/schemaASTDiffer.js';
 function resolveOptions(options) {
     return {
         checkTypes: options.checkTypes ?? true,
         checkNullable: options.checkNullable ?? true,
         checkIndexes: options.checkIndexes ?? true,
-        indexFacets: options.indexFacets ?? new Set(),
         checkForeignKeys: options.checkForeignKeys ?? true,
-        checkDefaults: options.checkDefaults ?? false,
+        checkDefaults: options.checkDefaults ?? options.defaultsEqual !== undefined,
+        defaultsEqual: options.defaultsEqual ?? defaultsEqualAsWritten,
         excludeTables: options.excludeTables ?? [],
         dialect: options.dialect,
     };
@@ -27,9 +27,9 @@ export function detectDrift(expectedAST, actualAST, options = {}) {
     const { dialect } = opts;
     const diff = diffSchemas(expectedAST, actualAST, {
         compareIndexes: opts.checkIndexes,
-        indexFacets: opts.indexFacets,
         compareRelationships: opts.checkForeignKeys,
         excludeTables: opts.excludeTables,
+        defaultsEqual: opts.defaultsEqual,
         // Without a dialect there is no engine to compare through, and `formatType` below then reports no
         // type drift at all.
         ...(dialect && { normalizeType: engineType(dialect) }),
@@ -59,10 +59,14 @@ function detectPrimaryKeyDrifts(diff) {
         type: 'constraint_mismatch',
         severity: 'critical',
         table: pkDiff.table,
-        details: `Primary key of "${pkDiff.table}" is (${pkDiff.actual.join(', ') || 'none'}) in the database but (${pkDiff.expected.join(', ') || 'none'}) in the entity`,
+        details: `Primary key of "${pkDiff.table}" is (${keyColumns(pkDiff.actual)}) in the database but (${keyColumns(pkDiff.expected)}) in the entity`,
         suggestion: 'Generate a migration to change the primary key',
     }));
 }
+/** A key's columns as a drift names them, `none` where there is no key. */
+function keyColumns(key) {
+    return key?.columns.join(', ') || 'none';
+}
 /**
  * Detect table-level drifts (missing/unexpected tables).
  */
@@ -121,7 +125,7 @@ function detectColumnDrifts(diff, opts) {
     return drifts;
 }
 /**
- * Add drifts for column alterations (type/nullable mismatches).
+ * Add drifts for column alterations: type, nullability and default.
  */
 function addAlterColumnDrifts(colDiff, drifts, opts) {
     // An auto-increment key is created through the dialect's `serialPrimaryKey`, whose spelling the
@@ -159,21 +163,17 @@ function addAlterColumnDrifts(colDiff, drifts, opts) {
             suggestion: 'Align nullable setting in entity or database',
         });
     }
-    if (opts.checkDefaults) {
-        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',
-            });
-        }
+    if (opts.checkDefaults && !opts.defaultsEqual(colDiff.expected.defaultValue, colDiff.actual.defaultValue)) {
+        drifts.push({
+            type: 'constraint_mismatch',
+            severity: 'info',
+            table: colDiff.table,
+            column: colDiff.column,
+            expected: String(colDiff.expected.defaultValue ?? 'NULL'),
+            actual: String(colDiff.actual.defaultValue ?? 'NULL'),
+            details: `Default mismatch for "${colDiff.column}"`,
+            suggestion: 'Align the default in the entity or the database',
+        });
     }
 }
 /**

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

@@ -14,7 +14,7 @@ export declare function tableDefinitionToNode(def: TableDefinition, render: (sql
  */
 export declare function fullColumnDefinitionToNode(col: FullColumnDefinition, tableName: string): ColumnNode;
 /**
- * The index a column-level `index` declares, or nothing.
+ * The index a column-level `index` or `unique` declares, or nothing: a unique column is a unique index.
  *
  * Shared with `TableBuilder.build`, which lifts these into the table it is creating: written twice,
  * `addColumn` had no lift at all and silently emitted a column with no index.

package/dist/migrate/generator/definitionToNode.js

@@ -1,3 +1,4 @@
+import { createTableNode, keyOfColumns } from '../../schema/schemaAST.js';
 import { renderIndexColumn } from '../../util/ddlExpression.util.js';
 import { derivedForeignKeyName, derivedIndexName } from '../../util/sql.util.js';
 /** A table the builder names but has not seen, which the generator reads only the name of. */
@@ -10,29 +11,17 @@ function unresolvedTable(name) {
  * `render`. Free functions and not generator methods: the dialect reaches them only through `render`.
  */
 export function tableDefinitionToNode(def, render) {
-    const columns = new Map();
-    const pkNodes = [];
-    const table = {
-        name: def.name,
-        columns,
-        primaryKey: [], // placeholder
-        indexes: [],
-        incomingRelations: [],
-        outgoingRelations: [],
-        comment: def.comment,
-    };
+    const table = { ...createTableNode(def.name), comment: def.comment };
+    const { columns } = table;
     for (const colDef of def.columns) {
         const node = fullColumnDefinitionToNode(colDef, def.name);
         node.table = table;
         columns.set(node.name, node);
-        if (node.isPrimaryKey) {
-            pkNodes.push(node);
-        }
     }
-    const finalPrimaryKey = def.primaryKey
-        ? def.primaryKey.map((name) => columns.get(name)).filter((c) => c !== undefined)
-        : pkNodes;
-    table.primaryKey = finalPrimaryKey;
+    // A declared key keeps only the columns the table has, in its own order.
+    table.primaryKey = def.primaryKey
+        ? { columns: def.primaryKey.filter((name) => columns.has(name)) }
+        : keyOfColumns(columns.values());
     for (const idxDef of def.indexes) {
         table.indexes.push({ ...renderIndexDefinition(idxDef, render), table });
     }
@@ -64,13 +53,13 @@ export function fullColumnDefinitionToNode(col, tableName) {
     return { ...column, table: unresolvedTable(tableName), referencedBy: [] };
 }
 /**
- * The index a column-level `index` declares, or nothing.
+ * The index a column-level `index` or `unique` declares, or nothing: a unique column is a unique index.
  *
  * Shared with `TableBuilder.build`, which lifts these into the table it is creating: written twice,
  * `addColumn` had no lift at all and silently emitted a column with no index.
  */
 export function columnIndex(tableName, col) {
-    if (!col.index) {
+    if (!col.index && !col.isUnique) {
         return undefined;
     }
     return {

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

@@ -31,8 +31,8 @@ export declare class MongoSchemaGenerator extends MongoDialect implements Schema
         ifNotExists?: boolean;
     }): string[];
     generateDropTable(tableName: string): string;
+    /** A collection's indexes: each dropped, then each created, an alter as both. */
     generateAlterTable(diff: SchemaDiff): string[];
-    generateAlterTableDown(diff: SchemaDiff): string[];
     /** MongoDB has no triggers, and a write to an entity declaring one is refused, so there is none to reconcile. */
     generateTriggers(): string[];
     generateTriggersDown(): string[];