uql-orm 0.80.0 → 0.82.0

package/dist/migrate/schemaChange.js

@@ -0,0 +1,37 @@
+/** Each change's end on `side`, where it has one: what a drop half removes (`from`), or an add half creates (`to`). */
+export function sides(changes, side) {
+    return (changes ?? []).flatMap((change) => {
+        const end = change[side];
+        return end === undefined ? [] : [end];
+    });
+}
+/** What the changes add: each `to` with no `from`. */
+export function added(changes = []) {
+    return changes.flatMap(({ from, to }) => (from === undefined && to !== undefined ? [to] : []));
+}
+/** What the changes drop: each `from` with no `to`. */
+export function dropped(changes = []) {
+    return changes.flatMap(({ from, to }) => (to === undefined && from !== undefined ? [from] : []));
+}
+/** The changes that alter an object in place, which only a column can. */
+export function alterations(changes = []) {
+    return changes.flatMap(({ from, to }) => (from === undefined || to === undefined ? [] : [{ from, to }]));
+}
+/** `items`, or nothing where it has none, so an empty change list is left off a diff. */
+export function nonEmpty(items) {
+    return items.length ? items : undefined;
+}
+/** `change` undone: an add becomes a drop, a drop an add, and an alter runs the other way. */
+export function swap({ from, to }) {
+    return { from: to, to: from };
+}
+/** `diff` undone: every change swapped, which is what a migration's `down` runs. */
+export function reverseDiff(diff) {
+    return {
+        ...diff,
+        primaryKey: diff.primaryKey && swap(diff.primaryKey),
+        columns: diff.columns?.map(swap),
+        indexes: diff.indexes?.map(swap),
+        foreignKeys: diff.foreignKeys?.map(swap),
+    };
+}

package/dist/migrate/schemaGenerator.d.ts

@@ -68,18 +68,19 @@ export declare class SqlSchemaGenerator implements SchemaGenerator {
      */
     private orderedTables;
     generateDropTable(tableName: string, options?: DropSchemaOptions): string;
+    /**
+     * The statements taking a table through `diff`, in the one order both directions need: whatever holds
+     * something down goes before it and comes back after it. A foreign key holds its columns and the key it
+     * points at, so it goes first and comes back last; the key holds its columns; and some engines drop an
+     * index along with its column, which would leave nothing to name. An alter is its drop, then its add.
+     */
     generateAlterTable(diff: SchemaDiff): string[];
     /** `ADD CONSTRAINT` for each of `foreignKeys`. */
     private addForeignKeyStatements;
-    /** `DROP CONSTRAINT` for each of `constraintNames`, the mirror of {@link addForeignKeyStatements}. */
-    private dropForeignKeyStatements;
-    /** The `ALTER COLUMN` restating each of `columns`. */
-    private alterColumnStatements;
     /** An index added to a table that may already have rows: its `CREATE`, then what the engine needs after. */
     private addIndexStatements;
-    /** `DROP INDEX` for each of `indexes`, the mirror of {@link addIndexStatements}. */
-    private dropIndexStatements;
-    generateAlterTableDown(diff: SchemaDiff): string[];
+    /** A column added to a table that exists, and its comment where the engine keeps one apart. */
+    private addColumnStatements;
     generateCreateIndex(tableName: string, index: IndexSchema, options?: {
         ifNotExists?: boolean;
     }): string;
@@ -96,8 +97,8 @@ export declare class SqlSchemaGenerator implements SchemaGenerator {
     /**
      * The one place a column definition is spelled, so the `ColumnSchema` and `ColumnNode` paths cannot
      * drift. A key column states `NOT NULL` rather than leave it to the key: SQLite lets a key column hold
-     * NULL otherwise, and SQL Server adds no key over a nullable column. `UNIQUE` is left to the key. An
-     * enum's `CHECK` comes last, the only place MariaDB takes it.
+     * NULL otherwise, and SQL Server adds no key over a nullable column. Never `UNIQUE`: a unique column is
+     * a unique index, which the table creates beside it. An enum's `CHECK` comes last, the only place MariaDB takes it.
      */
     private renderColumn;
     /**
@@ -124,10 +125,8 @@ export declare class SqlSchemaGenerator implements SchemaGenerator {
     protected diffOptions(): DiffOptions;
     /** Spread, not copied field by field, so a field the node gains cannot go missing here. */
     private columnNodeToSchema;
-    /**
-     * Compare two default values for equality
-     */
-    protected isDefaultValueEqual(current: unknown, desired: unknown): boolean;
+    /** Whether a column's stored default is the one the entity declares, as this engine reprints it. */
+    readonly defaultsEqual: (desired: unknown, current: unknown) => boolean;
     generateCreateTableFromNode(table: TableNode, options?: {
         ifNotExists?: boolean;
     }): string[];
@@ -186,4 +185,4 @@ export declare class SqlSchemaGenerator implements SchemaGenerator {
  * The entities as an AST, named by `generator`'s resolvers rather than a naming strategy, which would
  * also rename an explicit `@Entity({ name })` and so compare each table under another name.
  */
-export declare function buildEntityAST(generator: Pick<SchemaGenerator, 'resolveTableAlias' | 'resolveSchema' | 'resolveColumnName' | 'compileDdl' | 'compileIndexPredicate'>, entities: readonly Type<object>[], options?: Pick<BuildSchemaASTOptions, 'defaultForeignKeyAction' | 'textScoreIndexes'>): SchemaAST;
+export declare function buildEntityAST(generator: Pick<SchemaGenerator, 'resolveTableAlias' | 'resolveSchema' | 'resolveColumnName' | 'compileDdl' | 'compileIndexPredicate'>, entities: readonly Type<object>[], options?: Pick<BuildSchemaASTOptions, 'defaultForeignKeyAction' | 'textScoreIndexes' | 'vectorIndexRequiresNotNull'>): SchemaAST;

package/dist/migrate/schemaGenerator.js

@@ -5,13 +5,15 @@ import { buildSchemaAST } from '../schema/schemaASTBuilder.js';
 import { diffRelationshipNodes, diffTable } from '../schema/schemaASTDiffer.js';
 import { isAutoIncrement, qualifyName } from '../util/index.js';
 import { derivedCheckName, derivedForeignKeyName, derivedPrimaryKeyName, isOwnedName } from '../util/sql.util.js';
-import { formatDefaultValue, SqlExpression } from './builder/expressions.js';
+import { UqlUsageError } from '../util/uqlError.js';
+import { sameDefault } from './builder/expressions.js';
 import { splitSqlStatements } from './builder/splitSqlStatements.js';
 import { indexDdlFor, tableDdlFor } from './ddl/index.js';
 import { sizedType } from './ddl/tableDdl.js';
 import { columnForeignKey, columnIndex, fullColumnDefinitionToNode, renderIndexDefinition, tableDefinitionToNode, } from './generator/definitionToNode.js';
 import { indexNodeToSchema } from './generator/indexNodeToSchema.js';
 import { assertIndexPredicate } from './indexPredicate.js';
+import { added, alterations, dropped, nonEmpty, sides } from './schemaChange.js';
 import { dropTrigger, renderTrigger, stampTriggers } from './triggerSql.js';
 /**
  * Unified SQL schema generator.
@@ -78,6 +80,7 @@ export class SqlSchemaGenerator {
         return buildEntityAST(this, entities, {
             defaultForeignKeyAction: this.defaultForeignKeyAction,
             textScoreIndexes: this.dialect.features.textScoreIndexes,
+            vectorIndexRequiresNotNull: this.features.vectorIndexRequiresNotNull,
         });
     }
     /**
@@ -173,97 +176,45 @@ export class SqlSchemaGenerator {
         const cascade = options.cascade && this.features.dropTableCascade ? ' CASCADE' : '';
         return `DROP TABLE ${ifExists}${this.escapeId(tableName)}${cascade};`;
     }
+    /**
+     * The statements taking a table through `diff`, in the one order both directions need: whatever holds
+     * something down goes before it and comes back after it. A foreign key holds its columns and the key it
+     * points at, so it goes first and comes back last; the key holds its columns; and some engines drop an
+     * index along with its column, which would leave nothing to name. An alter is its drop, then its add.
+     */
     generateAlterTable(diff) {
-        const statements = [];
-        // Before the columns, because a key column being added cannot be part of the old key, and after
-        // it is dropped the table is free to take the new one below.
-        if (diff.primaryKey?.from.length) {
-            statements.push(this.generateDropPrimaryKeySql(diff.tableName, diff.primaryKey.fromName));
-        }
-        // Before the columns: a constraint holds its columns down, so one the entity dropped cannot go
-        // while a foreign key still names it. An alter is a drop and an add, and this is its drop half.
-        statements.push(...this.dropForeignKeyStatements(diff.tableName, [
-            ...(diff.foreignKeysToDrop ?? []),
-            ...(diff.foreignKeysToAlter ?? []).map((it) => constraintNameOf(diff.tableName, it.from)),
-        ]));
-        // Before the adds, which may reuse a dropped index's name, and before the columns: some engines
-        // drop an index along with its column, which would leave nothing here to name.
-        statements.push(...this.dropIndexStatements(diff.tableName, diff.indexesToDrop, diff.schema));
-        for (const column of diff.columnsToAdd ?? []) {
-            this.assertColumnAddable(diff.tableName, column);
-            statements.push(this.tableDdl.addColumn(diff.tableName, this.generateColumnDefinitionFromSchema(column)));
-            statements.push(...this.generateColumnCommentStatement(diff.tableName, column, diff.schema));
-        }
-        statements.push(...this.alterColumnStatements(diff.tableName, (diff.columnsToAlter ?? []).map((it) => it.to)));
-        for (const columnName of diff.columnsToDrop ?? []) {
-            statements.push(...this.tableDdl.dropColumn(diff.tableName, columnName));
-        }
-        statements.push(...this.addIndexStatements(diff.tableName, diff.indexesToAdd));
-        // Last, so every column it names exists by now.
-        if (diff.primaryKey?.to.length) {
-            statements.push(this.generateAddPrimaryKeySql(diff.tableName, diff.primaryKey.to));
-        }
-        // After the columns, for the same reason the key is: a constraint cannot name one that is not
-        // there yet. The add half of an alter rides along, its drop having gone out above.
-        statements.push(...this.addForeignKeyStatements(diff.tableName, [
-            ...(diff.foreignKeysToAdd ?? []),
-            ...(diff.foreignKeysToAlter ?? []).map((it) => it.to),
-        ]));
-        return statements;
+        const { tableName, schema, primaryKey } = diff;
+        const { columns } = diff;
+        return [
+            ...sides(diff.foreignKeys, 'from').map((foreignKey) => this.generateDropForeignKeySql(tableName, constraintNameOf(tableName, foreignKey))),
+            ...(primaryKey?.from ? [this.generateDropPrimaryKeySql(tableName, primaryKey.from.name)] : []),
+            ...sides(diff.indexes, 'from').map((index) => this.generateDropIndex(tableName, index.name, schema)),
+            ...added(columns).flatMap((column) => this.addColumnStatements(tableName, column, schema)),
+            ...alterations(columns).flatMap(({ from, to }) => this.tableDdl.alterColumn(tableName, to, this.generateColumnDefinitionFromSchema(to), from)),
+            ...dropped(columns).flatMap((column) => this.tableDdl.dropColumn(tableName, column.name)),
+            ...this.addIndexStatements(tableName, sides(diff.indexes, 'to')),
+            ...(primaryKey?.to ? [this.generateAddPrimaryKeySql(tableName, primaryKey.to.columns, primaryKey.to.name)] : []),
+            ...this.addForeignKeyStatements(tableName, sides(diff.foreignKeys, 'to')),
+        ];
     }
     /** `ADD CONSTRAINT` for each of `foreignKeys`. */
     addForeignKeyStatements(tableName, foreignKeys) {
         return foreignKeys.map((foreignKey) => this.generateAddForeignKeySql(tableName, foreignKey));
     }
-    /** `DROP CONSTRAINT` for each of `constraintNames`, the mirror of {@link addForeignKeyStatements}. */
-    dropForeignKeyStatements(tableName, constraintNames) {
-        return constraintNames.map((name) => this.generateDropForeignKeySql(tableName, name));
-    }
-    /** The `ALTER COLUMN` restating each of `columns`. */
-    alterColumnStatements(tableName, columns) {
-        return columns.flatMap((column) => this.generateAlterColumnStatements(tableName, column, this.generateColumnDefinitionFromSchema(column)));
-    }
     /** An index added to a table that may already have rows: its `CREATE`, then what the engine needs after. */
-    addIndexStatements(tableName, indexes = []) {
+    addIndexStatements(tableName, indexes) {
         return indexes.flatMap((index) => [
             this.generateCreateIndex(tableName, index),
             ...this.indexDdl.settleStatements(tableName, index),
         ]);
     }
-    /** `DROP INDEX` for each of `indexes`, the mirror of {@link addIndexStatements}. */
-    dropIndexStatements(tableName, indexes = [], schema) {
-        return indexes.map((index) => this.generateDropIndex(tableName, index.name, schema));
-    }
-    generateAlterTableDown(diff) {
-        const statements = [];
-        // Constraints first, mirroring the up direction: the up added them last, so the down drops them
-        // first, and a column it is about to drop is then free of anything naming it.
-        statements.push(...this.dropForeignKeyStatements(diff.tableName, [
-            ...(diff.foreignKeysToAdd ?? []).map((it) => constraintNameOf(diff.tableName, it)),
-            ...(diff.foreignKeysToAlter ?? []).map((it) => constraintNameOf(diff.tableName, it.to)),
-        ]));
-        // The key next, for the same reason: a column the up added cannot be dropped below while the new
-        // key still names it. Restored under the name the database gave it, which is what the table had
-        // before, rather than a derived one that was never on it.
-        if (diff.primaryKey?.to.length) {
-            statements.push(this.generateDropPrimaryKeySql(diff.tableName, derivedPrimaryKeyName(diff.tableName, diff.primaryKey.to)));
-        }
-        for (const column of diff.columnsToAdd ?? []) {
-            statements.push(...this.tableDdl.dropColumn(diff.tableName, column.name));
-        }
-        statements.push(...this.alterColumnStatements(diff.tableName, (diff.columnsToAlter ?? []).map((it) => it.from)));
-        statements.push(...this.dropIndexStatements(diff.tableName, diff.indexesToAdd, diff.schema));
-        statements.push(...this.addIndexStatements(diff.tableName, diff.indexesToDrop));
-        if (diff.primaryKey?.from.length) {
-            statements.push(this.generateAddPrimaryKeySql(diff.tableName, diff.primaryKey.from, diff.primaryKey.fromName));
-        }
-        // The constraint the up replaced, back under the name the database had for it. A foreign key the
-        // up *dropped* is not restored: only its name survived the diff, never what it pointed at.
-        statements.push(...this.addForeignKeyStatements(diff.tableName, (diff.foreignKeysToAlter ?? []).map((it) => it.from)));
-        if (diff.columnsToDrop?.length || diff.foreignKeysToDrop?.length) {
-            statements.push(`-- TODO: Manual reversal needed for dropped columns/foreign keys`);
-        }
-        return statements;
+    /** A column added to a table that exists, and its comment where the engine keeps one apart. */
+    addColumnStatements(tableName, column, schema) {
+        this.assertColumnAddable(tableName, column);
+        return [
+            this.tableDdl.addColumn(tableName, this.generateColumnDefinitionFromSchema(column)),
+            ...this.generateColumnCommentStatement(tableName, column, schema),
+        ];
     }
     generateCreateIndex(tableName, index, options = {}) {
         return this.indexDdl.getCreateIndexStatement(tableName, index, options);
@@ -288,8 +239,8 @@ export class SqlSchemaGenerator {
     /**
      * The one place a column definition is spelled, so the `ColumnSchema` and `ColumnNode` paths cannot
      * drift. A key column states `NOT NULL` rather than leave it to the key: SQLite lets a key column hold
-     * NULL otherwise, and SQL Server adds no key over a nullable column. `UNIQUE` is left to the key. An
-     * enum's `CHECK` comes last, the only place MariaDB takes it.
+     * NULL otherwise, and SQL Server adds no key over a nullable column. Never `UNIQUE`: a unique column is
+     * a unique index, which the table creates beside it. An enum's `CHECK` comes last, the only place MariaDB takes it.
      */
     renderColumn(column) {
         const type = column.generatedAs
@@ -299,9 +250,6 @@ export class SqlSchemaGenerator {
         if (!column.nullable) {
             def += ' NOT NULL';
         }
-        if (column.isUnique && !column.isPrimaryKey) {
-            def += ' UNIQUE';
-        }
         def += this.tableDdl.defaultClause(column);
         if (column.comment) {
             def += this.generateColumnComment(column.comment);
@@ -367,72 +315,61 @@ export class SqlSchemaGenerator {
         if (!desired) {
             return undefined;
         }
-        // Indexes are matched here rather than by the differ, which pairs them by name so that a changed
-        // one reads as one index that altered. A migration needs the opposite: an index already in the
-        // table, under whatever name, must not be created again, and one whose shape differs is dropped
-        // and created anew - no engine alters an index's columns or uniqueness.
         const tableDiff = diffTable(desired, currentTable, { ...this.diffOptions(), compareIndexes: false });
-        const indexes = indexChanges(currentTable.name, desired.indexes, currentTable.indexes);
-        const indexesToAdd = indexes.toAdd.map(indexNodeToSchema);
-        const indexesToDrop = indexes.toDrop.map(indexNodeToSchema);
-        const columnDiffs = tableDiff?.columnDiffs ?? [];
-        const columnsToAdd = columnDiffs.flatMap((it) => (it.type === 'add' ? [this.columnNodeToSchema(it.expected)] : []));
-        const columnsToDrop = columnDiffs.flatMap((it) => (it.type === 'drop' ? [it.column] : []));
-        // Without its values: an alter restates the whole column, and MySQL answers a restated `CHECK` by
-        // adding a *second* constraint rather than replacing the first, so the column would accumulate one
-        // per alter. An enum's values reach the database with the column and are never restated - which is
-        // also why changing them is a hand-written migration. See architecture/roadmap.md.
-        const columnsToAlter = columnDiffs.flatMap((it) => it.type === 'alter'
-            ? [
-                {
-                    from: this.columnNodeToSchema(it.actual),
-                    to: { ...this.columnNodeToSchema(it.expected), enum: undefined },
-                },
-            ]
-            : []);
-        const primaryKey = tableDiff?.primaryKeyDiff && {
-            from: tableDiff.primaryKeyDiff.actual,
-            to: tableDiff.primaryKeyDiff.expected,
-            fromName: tableDiff.primaryKeyDiff.actualName,
+        const indexes = indexChanges(currentTable.name, desired.indexes, currentTable.indexes, currentTable.indexFacets);
+        // An alter's `to` without its values: an alter restates the whole column, and MySQL answers a
+        // restated `CHECK` by adding a *second* constraint rather than replacing the first, so the column
+        // would accumulate one per alter. An enum's values reach the database with the column and are never
+        // restated - which is also why changing them is a hand-written migration. See architecture/roadmap.md.
+        const columns = (tableDiff?.columnDiffs ?? []).map((it) => {
+            if (it.type === 'add') {
+                return { to: this.columnNodeToSchema(it.expected) };
+            }
+            if (it.type === 'drop') {
+                return { from: this.columnNodeToSchema(it.actual) };
+            }
+            return {
+                from: this.columnNodeToSchema(it.actual),
+                to: { ...this.columnNodeToSchema(it.expected), enum: undefined },
+            };
+        });
+        const keyDiff = tableDiff?.primaryKeyDiff;
+        // The key added named as this generator names it, so the rollback can drop it by that name.
+        const primaryKey = keyDiff && {
+            from: keyDiff.actual,
+            to: keyDiff.expected && {
+                columns: keyDiff.expected.columns,
+                name: derivedPrimaryKeyName(tableName, keyDiff.expected.columns),
+            },
         };
         // This table's own foreign keys. None where the engine cannot alter one (SQLite, short of rebuilding
         // the table), since a difference nothing can apply would throw on every sync; `drift:check` names it.
         const relationDiffs = this.features.foreignKeyAlter
             ? diffRelationshipNodes(desired.outgoingRelations, currentTable.outgoingRelations, this.diffOptions())
             : [];
-        const foreignKeysToAdd = relationDiffs.flatMap((it) => (it.type === 'create' ? [foreignKeyOf(it.expected)] : []));
-        const foreignKeysToDrop = relationDiffs.flatMap((it) => (it.type === 'drop' ? [it.name] : []));
-        const foreignKeysToAlter = relationDiffs.flatMap((it) => it.type === 'alter' ? [{ from: foreignKeyOf(it.actual), to: foreignKeyOf(it.expected) }] : []);
-        if (!columnsToAdd.length &&
-            !columnsToAlter.length &&
-            !columnsToDrop.length &&
-            !indexesToAdd.length &&
-            !indexesToDrop.length &&
-            !foreignKeysToAdd.length &&
-            !foreignKeysToDrop.length &&
-            !foreignKeysToAlter.length &&
-            !primaryKey) {
-            return undefined;
-        }
-        return {
+        const foreignKeys = relationDiffs.map(({ actual, expected }) => ({
+            from: actual && foreignKeyOf(actual),
+            to: expected && foreignKeyOf(expected),
+        }));
+        const alter = {
             tableName,
             schema,
             type: 'alter',
             primaryKey,
-            columnsToAdd: columnsToAdd.length ? columnsToAdd : undefined,
-            columnsToAlter: columnsToAlter.length ? columnsToAlter : undefined,
-            columnsToDrop: columnsToDrop.length ? columnsToDrop : undefined,
-            indexesToAdd: indexesToAdd.length ? indexesToAdd : undefined,
-            indexesToDrop: indexesToDrop.length ? indexesToDrop : undefined,
-            foreignKeysToAdd: foreignKeysToAdd.length ? foreignKeysToAdd : undefined,
-            foreignKeysToDrop: foreignKeysToDrop.length ? foreignKeysToDrop : undefined,
-            foreignKeysToAlter: foreignKeysToAlter.length ? foreignKeysToAlter : undefined,
+            columns: nonEmpty(columns),
+            indexes: nonEmpty([
+                ...indexes.toAdd.map((to) => ({ to: indexNodeToSchema(to) })),
+                ...indexes.toDrop.map((from) => ({ from: indexNodeToSchema(from) })),
+                ...indexes.toAlter.map(({ from, to }) => ({ from: indexNodeToSchema(from), to: indexNodeToSchema(to) })),
+            ]),
+            foreignKeys: nonEmpty(foreignKeys),
         };
+        return alter.primaryKey || alter.columns || alter.indexes || alter.foreignKeys ? alter : undefined;
     }
     diffOptions() {
         return {
             normalizeType: engineType(this.dialect),
-            defaultsEqual: (expected, actual) => this.isDefaultValueEqual(actual, expected),
+            defaultsEqual: this.defaultsEqual,
         };
     }
     /** Spread, not copied field by field, so a field the node gains cannot go missing here. */
@@ -440,58 +377,28 @@ export class SqlSchemaGenerator {
         const { table: _table, referencedBy: _referencedBy, references: _references, ...column } = col;
         return { ...column, type: this.columnSqlType(col) };
     }
-    /**
-     * Compare two default values for equality
-     */
-    isDefaultValueEqual(current, desired) {
-        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, this.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);
-    }
+    /** Whether a column's stored default is the one the entity declares, as this engine reprints it. */
+    defaultsEqual = (desired, current) => sameDefault(desired, current, this.dialect);
     generateCreateTableFromNode(table, options = {}) {
         const columns = [];
         const constraints = [];
-        // MariaDB rejects a `VECTOR INDEX` whose column is nullable ("All parts of a VECTOR index must
-        // be NOT NULL"), so being indexed decides it rather than the entity's own nullability.
-        const indexedVectorColumns = new Set(this.features.vectorIndexRequiresNotNull
-            ? table.indexes.filter((index) => index.type === 'vector').flatMap((idx) => idx.entries.map((e) => e.column))
-            : []);
         for (const col of table.columns.values()) {
-            const colDef = this.generateColumnFromNode(indexedVectorColumns.has(col.name) ? { ...col, nullable: false } : col);
-            columns.push(colDef);
+            columns.push(this.generateColumnFromNode(col));
         }
         // Every key, of any width, as one named constraint beside the checks and foreign keys - so a
         // later `DROP` has something to name. The exception is a dialect whose serial type states the key
         // itself (SQLite's `INTEGER PRIMARY KEY AUTOINCREMENT`, which cannot be split): there the column
         // has already declared it, and saying it again is a second primary key.
+        const key = table.primaryKey;
         const declaredByColumn = this.dialect.features.serialDeclaresPrimaryKey &&
-            table.primaryKey.length === 1 &&
-            table.primaryKey[0].isAutoIncrement;
-        if (table.primaryKey.length && !declaredByColumn) {
-            const pkColumns = table.primaryKey.map((c) => c.name);
-            const pkName = table.primaryKeyName ?? derivedPrimaryKeyName(table.name, pkColumns);
-            const pkCols = pkColumns.map((c) => this.escapeId(c)).join(', ');
-            constraints.push(`CONSTRAINT ${this.escapeId(pkName)} PRIMARY KEY (${pkCols})`);
-        }
-        (table.checks ?? []).forEach((check, i) => {
+            key?.columns.length === 1 &&
+            table.columns.get(key.columns[0])?.isAutoIncrement;
+        if (key && !declaredByColumn) {
+            const name = key.name ?? derivedPrimaryKeyName(table.name, key.columns);
+            const columns = key.columns.map((column) => this.escapeId(column)).join(', ');
+            constraints.push(`CONSTRAINT ${this.escapeId(name)} PRIMARY KEY (${columns})`);
+        }
+        table.checks.forEach((check, i) => {
             const name = check.name ?? derivedCheckName(table.name, i + 1);
             constraints.push(`CONSTRAINT ${this.escapeId(name)} CHECK (${check.expression})`);
         });
@@ -630,7 +537,7 @@ export class SqlSchemaGenerator {
     }
     generateAddForeignKeySql(tableName, foreignKey) {
         if (!this.features.foreignKeyAlter) {
-            throw new TypeError(`Dialect ${this.dialect} does not support adding foreign keys to existing tables`);
+            throw new UqlUsageError(`Dialect ${this.dialect} does not support adding foreign keys to existing tables`);
         }
         const constraint = this.foreignKeyConstraint(tableName, foreignKey, this.escapeId(foreignKey.references.table));
         return `ALTER TABLE ${this.escapeId(tableName)} ADD ${constraint};`;
@@ -660,7 +567,7 @@ export class SqlSchemaGenerator {
             return `ALTER TABLE ${table} DROP PRIMARY KEY;`;
         }
         if (!constraintName) {
-            throw new TypeError(`Cannot drop the primary key of "${tableName}": ${this.dialect} names the constraint, and ` +
+            throw new UqlUsageError(`Cannot drop the primary key of "${tableName}": ${this.dialect} names the constraint, and ` +
                 'introspection did not report a name for it.');
         }
         return `ALTER TABLE ${table} DROP CONSTRAINT ${this.escapeId(constraintName)};`;
@@ -673,7 +580,7 @@ export class SqlSchemaGenerator {
         if (!column.generatedAs || this.features.generatedColumnAdd) {
             return;
         }
-        throw new TypeError(`${this.dialect}: Cannot add the computed column "${column.name}" to the existing table ` +
+        throw new UqlUsageError(`${this.dialect}: Cannot add the computed column "${column.name}" to the existing table ` +
             `"${tableName}" - this database only accepts one in a CREATE TABLE. Drop \`stored\` to have the ` +
             'expression spliced into each statement instead, or recreate the table in a written migration.');
     }
@@ -681,7 +588,7 @@ export class SqlSchemaGenerator {
         if (this.features.primaryKeyAlter) {
             return;
         }
-        throw new TypeError(`${this.dialect}: Cannot change the primary key of "${tableName}" - this database has no ALTER ` +
+        throw new UqlUsageError(`${this.dialect}: Cannot change the primary key of "${tableName}" - this database has no ALTER ` +
             'for it. Recreate the table in a written migration.');
     }
 }

package/dist/migrate/triggerSql.d.ts

@@ -21,4 +21,4 @@ export declare function dropTrigger<E>(dialect: AbstractSqlDialect, meta: Entity
  * column. Generated rather than authored, so unlike an authored body it renders on every engine from
  * one declaration - and not at all on the MySQL family, whose columns stamp themselves.
  */
-export declare function stampTriggers<E>(dialect: AbstractSqlDialect, meta: EntityMeta<E>): EntityTriggerMeta<E>[];
+export declare function stampTriggers<E extends object>(dialect: AbstractSqlDialect, meta: EntityMeta<E>): EntityTriggerMeta<E>[];