uql-orm 0.80.0 → 0.82.0

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/mongoCommand.js

@@ -1,3 +1,4 @@
+import { UqlUsageError } from '../../util/uqlError.js';
 export function serializeMongoCommand(command) {
     return JSON.stringify(command);
 }
@@ -9,7 +10,7 @@ function parseMongoCommand(statement) {
     return JSON.parse(statement);
 }
 function unsupportedMongoCommand(statement) {
-    return new TypeError(`unsupported MongoDB migration command: ${statement}`);
+    return new UqlUsageError(`unsupported MongoDB migration command: ${statement}`);
 }
 /** Execute one emitted command. */
 export function runMongoCommand(db, statement) {

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[];

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -6,8 +6,10 @@ import { QueryRaw, } from '../../type/index.js';
 import { indexDistance, unsupportedVectorMetric } from '../../type/vector.js';
 import { declaredIndexes, declaredIndexName, renderIndexColumn } from '../../util/ddlExpression.util.js';
 import { fulltextConfig, fulltextWeights } from '../../util/dialect.util.js';
+import { UqlUsageError } from '../../util/uqlError.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';
@@ -29,7 +31,7 @@ export class MongoSchemaGenerator extends MongoDialect {
     }
     /** A collection has no SQL to render a check, a computed column or an index expression into. */
     compileDdl() {
-        throw new TypeError('mongodb has no SQL to render a check, a computed column or an index expression into');
+        throw new UqlUsageError('mongodb has no SQL to render a check, a computed column or an index expression into');
     }
     /**
      * A document store has no cross-collection constraint, so unlike the SQL generator there is nothing to
@@ -83,7 +85,7 @@ export class MongoSchemaGenerator extends MongoDialect {
      */
     compileIndexPredicate(where, entity, indexName) {
         if (where instanceof QueryRaw) {
-            throw new TypeError(`mongodb does not support partial indexes from a SQL predicate (index "${indexName}")`);
+            throw new UqlUsageError(`mongodb does not support partial indexes from a SQL predicate (index "${indexName}")`);
         }
         assertIndexPredicate(where, this.dialectName, indexName);
         const filter = this.renderFilter(entity, where);
@@ -106,16 +108,11 @@ 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)),
-        ];
-    }
-    generateAlterTableDown(diff) {
-        return [
-            ...(diff.indexesToAdd ?? []).map((index) => this.dropIndexCommand(diff.tableName, index)),
-            ...(diff.indexesToDrop ?? []).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)),
         ];
     }
     /** MongoDB has no triggers, and a write to an entity declaring one is refused, so there is none to reconcile. */
@@ -164,7 +161,7 @@ export class MongoSchemaGenerator extends MongoDialect {
         assertIndexFeatures(index, new Set(), this.dialectName);
         const [vector, ...filters] = index.entries;
         if (!vector || index.dimensions === undefined) {
-            throw new TypeError(`an Atlas vector search index states its field's dimensions (index "${index.name}")`);
+            throw new UqlUsageError(`an Atlas vector search index states its field's dimensions (index "${index.name}")`);
         }
         const distance = indexDistance(index);
         const similarity = ATLAS_SIMILARITY[distance];
@@ -196,7 +193,7 @@ export class MongoSchemaGenerator extends MongoDialect {
             case 'createTable': {
                 const { name, columns, indexes } = operation.table;
                 if (columns.length) {
-                    throw new TypeError(`mongodb does not support columns in a migration (collection "${name}")`);
+                    throw new UqlUsageError(`mongodb does not support columns in a migration (collection "${name}")`);
                 }
                 return [
                     serializeMongoCommand({ action: 'createCollection', name }),
@@ -212,7 +209,7 @@ export class MongoSchemaGenerator extends MongoDialect {
             case 'dropIndex':
                 return [this.generateDropIndex(operation.tableName, operation.indexName)];
             default:
-                throw new TypeError(`mongodb does not support ${operation.type} in a migration`);
+                throw new UqlUsageError(`mongodb does not support ${operation.type} in a migration`);
         }
     }
     diffSchema(entity, currentTable) {
@@ -221,17 +218,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/indexPredicate.js

@@ -1,5 +1,6 @@
 import { QueryRaw } from '../type/queryRaw.js';
 import { isOperatorObject } from '../util/object.util.js';
+import { UqlUsageError } from '../util/uqlError.js';
 /**
  * The `$where` a partial index takes, on the engines where that is less than a query's: SQL Server's
  * `CREATE INDEX` `<filter_predicate>` (comparisons and `IN` on plain columns, joined by `AND`), and
@@ -30,7 +31,7 @@ export function assertIndexPredicate(where, dialectName, indexName) {
 }
 /** What refusing any part of a partial index's predicate reports. */
 export function refusedIndexPredicate(dialectName, part, indexName) {
-    return new TypeError(`${dialectName} does not support ${part} in a partial index predicate (index "${indexName}")`);
+    return new UqlUsageError(`${dialectName} does not support ${part} in a partial index predicate (index "${indexName}")`);
 }
 /** The first part of `where` outside `grammar`, depth-first; a `raw` clause is left alone. */
 function refusedOperator(where, grammar) {

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

@@ -1,5 +1,5 @@
 import { type ForeignKeyAction } from '../../schema/types.js';
-import type { ColumnSchema, InstalledTriggers, 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.
@@ -43,7 +43,7 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
      * 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(): Promise<Map<string, InstalledTriggers>>;
+    ownedTriggers(table: string): Promise<InstalledTriggers>;
     tableExists(tableName: string): Promise<boolean>;
     /**
      * Introspection reads, so `withQuerier` rather than `transaction`: the pool owns the release either
@@ -54,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[];
@@ -90,6 +87,7 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
      * `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.
@@ -113,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,6 +1,7 @@
 import { FOREIGN_KEY_ACTIONS } from '../../schema/types.js';
 import { isSqlQuerier } from '../../type/index.js';
 import { isOwnedName } from '../../util/sql.util.js';
+import { UqlUsageError } from '../../util/uqlError.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 {
@@ -38,8 +39,7 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
             return {
                 name: tableName,
                 columns,
-                primaryKey: primaryKey.columns,
-                primaryKeyName: primaryKey.name,
+                primaryKey,
                 indexes,
                 foreignKeys,
             };
@@ -56,20 +56,13 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
      * 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() {
-        return this.withSqlQuerier(async (querier) => {
-            const byTable = new Map();
-            for (const row of await querier.all(this.triggersQuery())) {
-                const name = String(row['name']);
-                if (!isOwnedName(name)) {
-                    continue;
-                }
-                const table = String(row['table']);
-                const statements = [row['requires'], row['definition']].filter(Boolean).map((sql) => String(sql));
-                byTable.set(table, (byTable.get(table) ?? new Map()).set(name, statements));
-            }
-            return byTable;
-        });
+    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));
@@ -81,7 +74,7 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
     withSqlQuerier(task) {
         return this.pool.withQuerier((querier) => {
             if (!isSqlQuerier(querier)) {
-                throw new TypeError(`${this.constructor.name} requires a SQL-based querier`);
+                throw new UqlUsageError(`${this.constructor.name} requires a SQL-based querier`);
             }
             return task(querier);
         });
@@ -104,7 +97,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];
@@ -166,7 +160,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

@@ -11,7 +11,7 @@ export declare class MongoSchemaIntrospector implements SchemaIntrospector {
     readonly indexFacets: ReadonlySet<IndexFacet>;
     constructor(pool: QuerierPool);
     /** MongoDB has no triggers, so none is ever installed. */
-    ownedTriggers(): Promise<Map<string, InstalledTriggers>>;
+    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

@@ -1,6 +1,7 @@
 import { textConfigOf } from '../../mongo/textLanguage.js';
 import { createTableNode, SchemaAST } from '../../schema/schemaAST.js';
 import { isMongoQuerier, } from '../../type/index.js';
+import { UqlUsageError } from '../../util/uqlError.js';
 /** What a server without Atlas Search answers a search index command with. */
 const SEARCH_NOT_ENABLED = 31082;
 /**
@@ -24,7 +25,7 @@ export class MongoSchemaIntrospector {
         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;
@@ -80,7 +81,7 @@ export class MongoSchemaIntrospector {
     withDb(task) {
         return this.pool.withQuerier((querier) => {
             if (!isMongoQuerier(querier)) {
-                throw new TypeError('MongoSchemaIntrospector requires a MongoDB querier');
+                throw new UqlUsageError('MongoSchemaIntrospector requires a MongoDB querier');
             }
             return task(querier.db);
         });
@@ -107,8 +108,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.js

@@ -11,10 +11,11 @@ export class MsSqlSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     defaultSchemaExpr = 'SCHEMA_NAME()';
     triggersQuery() {
         return /*sql*/ `
-      SELECT OBJECT_NAME(t.parent_id) AS [table], t.name AS name, m.definition AS definition
+      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() {

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

@@ -1,3 +1,4 @@
+import type { IndexFacet } from '../../schema/indexDifferences.js';
 import type { ColumnSchema, ForeignKeySchema, IndexSchema } from '../../type/index.js';
 import { AbstractSqlSchemaIntrospector, type JoinedForeignKeyRow, type TableRowReader } from './abstractSqlSchemaIntrospector.js';
 /**
@@ -17,11 +18,7 @@ export declare class MysqlSchemaIntrospector extends AbstractSqlSchemaIntrospect
     protected getForeignKeysQuery(_tableName: string): string;
     protected getPrimaryKeyQuery(_tableName: string): string;
     protected mapColumnsResult(_read: TableRowReader, _tableName: string, results: MysqlColumnRow[]): Promise<ColumnSchema[]>;
-    protected mapIndexesResult(_read: TableRowReader, _tableName: string, results: {
-        index_name: string;
-        columns: string;
-        is_unique: number;
-    }[]): Promise<IndexSchema[]>;
+    protected mapIndexesResult(_read: TableRowReader, _tableName: string, results: MysqlIndexRow[]): Promise<IndexSchema[]>;
     protected mapForeignKeysResult(_read: TableRowReader, _tableName: string, results: JoinedForeignKeyRow[]): Promise<ForeignKeySchema[]>;
     /**
      * MariaDB prints a string default as the literal it is (`'it''s'`). MySQL prints one bare, save an
@@ -52,6 +49,19 @@ type MysqlColumnRow = {
  * JSON, got LONGTEXT", flagged as data loss) on a table uql created itself.
  */
 export declare class MariadbSchemaIntrospector extends MysqlSchemaIntrospector {
+    /** Whether an index is MariaDB's vector index, and the distance it was built for. */
+    readonly indexFacets: ReadonlySet<IndexFacet>;
+    /**
+     * A vector index's distance is kept only in the table's own definition, ``VECTOR KEY `ix` (`vec`)
+     * `DISTANCE`='cosine'``, and left out there for MariaDB's default, euclidean.
+     */
+    protected mapIndexesResult(read: TableRowReader, tableName: string, results: MysqlIndexRow[]): Promise<IndexSchema[]>;
     protected mapColumnsResult(read: TableRowReader, tableName: string, results: MysqlColumnRow[]): Promise<ColumnSchema[]>;
 }
+type MysqlIndexRow = {
+    index_name: string;
+    columns: string;
+    is_unique: number;
+    method: string;
+};
 export {};