uql-orm 0.79.0 → 0.81.0

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

@@ -12,13 +12,16 @@ export declare function sizedType(column: Pick<ColumnSchema, 'type' | 'length' |
 export declare class TableDdl {
     protected readonly dialect: AbstractSqlDialect;
     constructor(dialect: AbstractSqlDialect);
+    /** A `CREATE TABLE` up to its column list, a no-op where `ifNotExists` and the table is already there. */
+    createTable(target: string, ifNotExists: boolean): string;
     addColumn(table: string, definition: string): string;
     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.
@@ -22,6 +22,10 @@ export class TableDdl {
     constructor(dialect) {
         this.dialect = dialect;
     }
+    /** A `CREATE TABLE` up to its column list, a no-op where `ifNotExists` and the table is already there. */
+    createTable(target, ifNotExists) {
+        return `CREATE TABLE ${ifNotExists ? 'IF NOT EXISTS ' : ''}${target}`;
+    }
     addColumn(table, definition) {
         return `ALTER TABLE ${this.dialect.escapeId(table)} ADD COLUMN ${definition};`;
     }
@@ -30,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.`);
@@ -43,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,12 @@ 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[];
+    generateTriggerDrops(): string[];
     private dropIndexCommand;
     /** An index as MongoDB's key spec (`-1` descending, `'text'` full-text), refusing the SQL-only options. */
     generateCreateIndex(tableName: string, index: IndexSchema): string;

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -8,6 +8,7 @@ import { declaredIndexes, declaredIndexName, renderIndexColumn } from '../../uti
 import { fulltextConfig, fulltextWeights } from '../../util/dialect.util.js';
 import { assertIndexFeatures, assertIndexType } from '../ddl/indexDdl.js';
 import { assertIndexPredicate, refusedIndexPredicate } from '../indexPredicate.js';
+import { sides } from '../schemaChange.js';
 import { renderIndexDefinition } from './definitionToNode.js';
 import { indexNodeToSchema } from './indexNodeToSchema.js';
 import { serializeMongoCommand } from './mongoCommand.js';
@@ -106,17 +107,22 @@ export class MongoSchemaGenerator extends MongoDialect {
     generateDropTable(tableName) {
         return serializeMongoCommand({ action: 'dropCollection', name: tableName });
     }
+    /** A collection's indexes: each dropped, then each created, an alter as both. */
     generateAlterTable(diff) {
         return [
-            ...(diff.indexesToDrop ?? []).map((index) => this.dropIndexCommand(diff.tableName, index)),
-            ...(diff.indexesToAdd ?? []).map((index) => this.generateCreateIndex(diff.tableName, index)),
+            ...sides(diff.indexes, 'from').map((index) => this.dropIndexCommand(diff.tableName, index)),
+            ...sides(diff.indexes, 'to').map((index) => this.generateCreateIndex(diff.tableName, index)),
         ];
     }
-    generateAlterTableDown(diff) {
-        return [
-            ...(diff.indexesToAdd ?? []).map((index) => this.dropIndexCommand(diff.tableName, index)),
-            ...(diff.indexesToDrop ?? []).map((index) => this.generateCreateIndex(diff.tableName, index)),
-        ];
+    /** MongoDB has no triggers, and a write to an entity declaring one is refused, so there is none to reconcile. */
+    generateTriggers() {
+        return [];
+    }
+    generateTriggersDown() {
+        return [];
+    }
+    generateTriggerDrops() {
+        return [];
     }
     dropIndexCommand(tableName, index) {
         return index.type === 'vectorSearch'
@@ -211,17 +217,13 @@ export class MongoSchemaGenerator extends MongoDialect {
         if (!currentTable) {
             return { tableName: collectionName, type: 'create' };
         }
-        // By name: MongoDB lists a text index's fields alphabetically, so a shape would not match its own.
-        const { toAdd, toDrop } = indexChanges(collectionName, this.indexesOf(meta, collectionName), currentTable.indexes, (index) => index.name);
-        if (!toAdd.length && !toDrop.length) {
-            return undefined;
-        }
-        return {
-            tableName: collectionName,
-            type: 'alter',
-            indexesToAdd: toAdd.length ? toAdd : undefined,
-            indexesToDrop: toDrop.length ? toDrop.map(indexNodeToSchema) : undefined,
-        };
+        const { toAdd, toDrop, toAlter } = indexChanges(collectionName, this.indexesOf(meta, collectionName), currentTable.indexes, currentTable.indexFacets);
+        const indexes = [
+            ...toAdd.map((to) => ({ to })),
+            ...toDrop.map((from) => ({ from: indexNodeToSchema(from) })),
+            ...toAlter.map(({ from, to }) => ({ from: indexNodeToSchema(from), to })),
+        ];
+        return indexes.length ? { tableName: collectionName, type: 'alter', indexes } : undefined;
     }
 }
 /** The first value `partialFilterExpression` refuses, `null`, or a migration cannot carry as JSON, such as a `Date`. */

package/dist/migrate/index.d.ts

@@ -1,4 +1,4 @@
-export type { ColumnSchema, DialectName, ForeignKeySchema, IndexSchema, Migration, MigrationDefinition, MigrationResult, MigrationStorage, MigratorOptions, MongoQuerier, SchemaDiff, SchemaGenerator, SchemaIntrospector, SqlDialectName, SqlQuerier, SqlQueryDialect, SyncOptions, TableSchema, } from '../type/index.js';
+export type { Change, ColumnSchema, DialectName, ForeignKeySchema, IndexSchema, Migration, MigrationDefinition, MigrationResult, MigrationStorage, MigratorOptions, MongoQuerier, PrimaryKeySchema, SchemaDiff, SchemaGenerator, SchemaIntrospector, SqlDialectName, SqlQuerier, SqlQueryDialect, SyncOptions, TableSchema, } from '../type/index.js';
 export { type Config, isSqlQuerier } from '../type/index.js';
 export { acquireQuerierForMigrations } from './acquireQuerierForMigrations.js';
 export { assertCliConfig } from './assertCliConfig.js';
@@ -10,6 +10,7 @@ export * from './drift/index.js';
 export * from './introspection/index.js';
 export { migrationBuilderFor } from './migrationTarget.js';
 export { type BuilderMigrationDefinition, defineBuilderMigration, defineMigration, Migrator } from './migrator.js';
+export { reverseDiff } from './schemaChange.js';
 export { SqlSchemaGenerator } from './schemaGenerator.js';
 export { DatabaseMigrationStorage } from './storage/databaseStorage.js';
 export { JsonMigrationStorage } from './storage/jsonStorage.js';

package/dist/migrate/index.js

@@ -16,6 +16,7 @@ export * from './introspection/index.js';
 export { migrationBuilderFor } from './migrationTarget.js';
 export { defineBuilderMigration, defineMigration, Migrator } from './migrator.js';
 // Schema generators
+export { reverseDiff } from './schemaChange.js';
 export { SqlSchemaGenerator } from './schemaGenerator.js';
 // Storage implementations
 export { DatabaseMigrationStorage } from './storage/databaseStorage.js';

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

@@ -1,5 +1,5 @@
 import { type ForeignKeyAction } from '../../schema/types.js';
-import type { ColumnSchema, ForeignKeySchema, IndexSchema, QuerierPool, RawRow, SchemaIntrospector, SqlQuerier, TableSchema } from '../../type/index.js';
+import type { ColumnSchema, InstalledTriggers, ForeignKeySchema, IndexSchema, PrimaryKeySchema, QuerierPool, RawRow, SchemaIntrospector, SqlQuerier, TableSchema } from '../../type/index.js';
 import { BaseSqlIntrospector } from './baseSqlIntrospector.js';
 /**
  * Reads the rows of one statement while introspecting a table.
@@ -38,6 +38,12 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
     protected readonly defaultSchemaExpr: string;
     getTableSchema(tableName: string): Promise<TableSchema | undefined>;
     getTableNames(): Promise<string[]>;
+    /**
+     * Every trigger uql installed in this schema, by table and then by name, with the statements recreating
+     * it: the whole schema in one read, since a table whose entity stopped declaring one still has one to
+     * drop. Ownership is matched here rather than with `LIKE`, whose `_` wildcard would take in a hand-written one.
+     */
+    ownedTriggers(table: string): Promise<InstalledTriggers>;
     tableExists(tableName: string): Promise<boolean>;
     /**
      * Introspection reads, so `withQuerier` rather than `transaction`: the pool owns the release either
@@ -48,10 +54,7 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
     protected getColumns(read: TableRowReader, tableName: string): Promise<ColumnSchema[]>;
     protected getIndexes(read: TableRowReader, tableName: string): Promise<IndexSchema[]>;
     protected getForeignKeys(read: TableRowReader, tableName: string): Promise<ForeignKeySchema[]>;
-    protected getPrimaryKey(read: TableRowReader, tableName: string): Promise<{
-        columns?: string[];
-        name?: string;
-    }>;
+    protected getPrimaryKey(read: TableRowReader, tableName: string): Promise<PrimaryKeySchema | undefined>;
     protected tableExistsParams(tableName: string): unknown[];
     protected getColumnsParams(tableName: string): unknown[];
     protected getIndexesParams(tableName: string): unknown[];
@@ -79,6 +82,13 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
     protected abstract getForeignKeysQuery(tableName: string): string;
     /** SQL query to get primary key columns. Parameter: tableName (for PRAGMA-style). */
     protected abstract getPrimaryKeyQuery(tableName: string): string;
+    /**
+     * SQL listing every trigger in the schema as a `table`, a `name`, the engine's reprint of it as a
+     * `definition`, and where the body lives apart, the `requires` recreated first: what is installed, not
+     * what uql wrote, which is exactly what a rollback puts back.
+     */
+    /** The triggers on the table its one parameter names: each one's `name`, `definition`, and what it `requires`. */
+    protected abstract triggersQuery(): string;
     /**
      * Extract table name from a row returned by getTableNamesQuery.
      *
@@ -101,7 +111,7 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
     protected mapPrimaryKeyResult(results: RawRow[]): string[] | undefined;
     /**
      * What the engine calls the key's constraint, where the query reported one. Only a `DROP` needs it,
-     * and only the reported name will do - see {@link TableSchema.primaryKeyName}.
+     * and only the reported name will do - see {@link PrimaryKeySchema.name}.
      */
     protected mapPrimaryKeyName(results: RawRow[]): string | undefined;
     /** Parse default value string to appropriate type. */

package/dist/migrate/introspection/abstractSqlSchemaIntrospector.js

@@ -1,5 +1,6 @@
 import { FOREIGN_KEY_ACTIONS } from '../../schema/types.js';
 import { isSqlQuerier } from '../../type/index.js';
+import { isOwnedName } from '../../util/sql.util.js';
 import { BaseSqlIntrospector } from './baseSqlIntrospector.js';
 /** A SQL introspector: an engine states its catalogue queries (`get*Query`) and how their rows map (`map*Result`). */
 export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
@@ -37,8 +38,7 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
             return {
                 name: tableName,
                 columns,
-                primaryKey: primaryKey.columns,
-                primaryKeyName: primaryKey.name,
+                primaryKey,
                 indexes,
                 foreignKeys,
             };
@@ -50,6 +50,19 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
             return results.map((row) => this.mapTableNameRow(row));
         });
     }
+    /**
+     * Every trigger uql installed in this schema, by table and then by name, with the statements recreating
+     * it: the whole schema in one read, since a table whose entity stopped declaring one still has one to
+     * drop. Ownership is matched here rather than with `LIKE`, whose `_` wildcard would take in a hand-written one.
+     */
+    async ownedTriggers(table) {
+        const rows = await this.withSqlQuerier((querier) => querier.all(this.triggersQuery(), [table]));
+        return new Map(rows.flatMap((row) => {
+            const name = String(row['name']);
+            const statements = [row['requires'], row['definition']].filter(Boolean).map((sql) => String(sql));
+            return isOwnedName(name) ? [[name, statements]] : [];
+        }));
+    }
     async tableExists(tableName) {
         return this.withSqlQuerier((querier) => this.tableExistsInternal(createTableRowReader(querier), tableName));
     }
@@ -83,7 +96,8 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
     }
     async getPrimaryKey(read, tableName) {
         const results = await read(this.getPrimaryKeyQuery(tableName), this.getPrimaryKeyParams(tableName));
-        return { columns: this.mapPrimaryKeyResult(results), name: this.mapPrimaryKeyName(results) };
+        const columns = this.mapPrimaryKeyResult(results);
+        return columns && { columns, name: this.mapPrimaryKeyName(results) };
     }
     tableExistsParams(tableName) {
         return [tableName];
@@ -145,7 +159,7 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
     }
     /**
      * What the engine calls the key's constraint, where the query reported one. Only a `DROP` needs it,
-     * and only the reported name will do - see {@link TableSchema.primaryKeyName}.
+     * and only the reported name will do - see {@link PrimaryKeySchema.name}.
      */
     mapPrimaryKeyName(results) {
         const name = results[0]?.['constraint_name'];

package/dist/migrate/introspection/baseSqlIntrospector.js

@@ -1,5 +1,5 @@
 import { canonicalColumnType } from '../../schema/canonicalType.js';
-import { createTableNode, SchemaAST } from '../../schema/schemaAST.js';
+import { createTableNode, keyOfColumns, SchemaAST } from '../../schema/schemaAST.js';
 import { escapeSqlId } from '../../util/index.js';
 import { derivedForeignKeyName } from '../../util/sql.util.js';
 /**
@@ -56,7 +56,7 @@ export class BaseSqlIntrospector {
         return ast;
     }
     buildTable(schema) {
-        const table = createTableNode(schema.name, this.schema);
+        const table = createTableNode(schema.name, this.schema, this.indexFacets);
         const { columns } = table;
         for (const col of schema.columns) {
             // Spread, not field by field: a `ColumnSchema` is a `ColumnNode` minus the graph links, so
@@ -71,12 +71,10 @@ export class BaseSqlIntrospector {
             };
             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;
+        // From the ordered key 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.
+        table.primaryKey = schema.primaryKey ?? keyOfColumns(schema.columns);
         return table;
     }
     buildRelationships(ast, tableNodes, schema, fromTable) {
@@ -105,16 +103,7 @@ export class BaseSqlIntrospector {
             // 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,
-                };
-                ast.addIndex(index);
+                ast.addIndex({ ...idx, table, entries });
             }
         }
     }

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, type SchemaIntrospector, type TableSchema } from '../../type/index.js';
+import { type InstalledTriggers, 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.
@@ -10,6 +10,8 @@ export declare class MongoSchemaIntrospector implements SchemaIntrospector {
     /** `listIndexes` reports keys, uniqueness and text weights; a `partialFilterExpression` is no SQL predicate. */
     readonly indexFacets: ReadonlySet<IndexFacet>;
     constructor(pool: QuerierPool);
+    /** MongoDB has no triggers, so none is ever installed. */
+    ownedTriggers(): Promise<InstalledTriggers>;
     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. */

package/dist/migrate/introspection/mongoIntrospector.js

@@ -14,13 +14,17 @@ export class MongoSchemaIntrospector {
     constructor(pool) {
         this.pool = pool;
     }
+    /** MongoDB has no triggers, so none is ever installed. */
+    async ownedTriggers() {
+        return new Map();
+    }
     async introspect(tables) {
         const tableNames = tables ?? (await this.getTableNames());
         const ast = new SchemaAST();
         for (const name of tableNames) {
             const schema = await this.getTableSchema(name);
             if (schema) {
-                ast.addTable(buildTable(schema));
+                ast.addTable(buildTable(schema, this.indexFacets));
             }
         }
         return ast;
@@ -103,8 +107,8 @@ async function hasCollection(db, name) {
     return collections.length > 0;
 }
 /** Mongo has no columns to read, so a table's are the fields its indexes name, one node per field. */
-function buildTable({ name, indexes = [] }) {
-    const table = createTableNode(name);
+function buildTable({ name, indexes = [] }, indexFacets) {
+    const table = createTableNode(name, undefined, indexFacets);
     for (const index of indexes) {
         for (const { column } of index.entries) {
             if (!table.columns.has(column)) {

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

@@ -10,6 +10,7 @@ import { AbstractSqlSchemaIntrospector, type JoinedForeignKeyRow, type TableRowR
  */
 export declare class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     protected readonly defaultSchemaExpr = "SCHEMA_NAME()";
+    protected triggersQuery(): string;
     protected getTableNamesQuery(): string;
     protected tableExistsQuery(): string;
     protected parseTableExistsResult([row]: {

package/dist/migrate/introspection/mssqlIntrospector.js

@@ -9,6 +9,15 @@ import { AbstractSqlSchemaIntrospector, } from './abstractSqlSchemaIntrospector.
  */
 export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     defaultSchemaExpr = 'SCHEMA_NAME()';
+    triggersQuery() {
+        return /*sql*/ `
+      SELECT t.name AS name, m.definition AS definition
+      FROM sys.triggers t
+      JOIN sys.sql_modules m ON m.object_id = t.object_id
+      WHERE t.parent_id <> 0 AND OBJECT_SCHEMA_NAME(t.parent_id) = ${this.schemaExpr}
+        AND OBJECT_NAME(t.parent_id) = ${this.dialect.placeholder(1)}
+    `;
+    }
     getTableNamesQuery() {
         return /*sql*/ `
       SELECT TABLE_NAME as table_name