uql-orm 0.42.0 → 0.43.0

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

@@ -16,6 +16,13 @@ export declare class MongoSchemaGenerator extends AbstractDialect implements Sch
     generateCreateSchema(entities: readonly Type<unknown>[], options?: CreateSchemaOptions): string[];
     generateDropSchema(entities: readonly Type<unknown>[]): string[];
     private selected;
+    /**
+     * The indexes `@Field({ index })` declares, as the collection would hold them.
+     *
+     * One owner because two paths need it: creating a collection, and working out which of its indexes
+     * are missing. Derived twice, they drifted the moment either changed how a name is settled.
+     */
+    private fieldIndexes;
     generateCreateTable<E>(entity: Type<E>, _options?: {
         ifNotExists?: boolean;
     }): string[];
@@ -32,7 +39,7 @@ export declare class MongoSchemaGenerator extends AbstractDialect implements Sch
      */
     generateCreateIndex(tableName: string, index: IndexSchema): string;
     generateDropIndex(tableName: string, indexName: string): string;
-    getSqlType(fieldOptions: FieldOptions, fieldType?: unknown): string;
+    getSqlType(fieldOptions: FieldOptions): string;
     generateCreateTableFromNode(table: TableNode, _options?: {
         ifNotExists?: boolean;
     }): string[];

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -32,22 +32,32 @@ export class MongoSchemaGenerator extends AbstractDialect {
         const wanted = new Set(only);
         return entities.filter((entity) => wanted.has(this.resolveTableName(getMeta(entity))));
     }
-    generateCreateTable(entity, _options) {
-        const meta = getMeta(entity);
-        const collectionName = this.resolveTableName(meta);
-        const indexes = [];
-        for (const key of getKeys(meta.fields)) {
+    /**
+     * The indexes `@Field({ index })` declares, as the collection would hold them.
+     *
+     * One owner because two paths need it: creating a collection, and working out which of its indexes
+     * are missing. Derived twice, they drifted the moment either changed how a name is settled.
+     */
+    fieldIndexes(meta, collectionName) {
+        return getKeys(meta.fields).flatMap((key) => {
             const field = meta.fields[key];
-            if (field?.index) {
-                const columnName = this.resolveColumnName(key, field);
-                const indexName = typeof field.index === 'string' ? field.index : derivedIndexName(collectionName, [columnName]);
-                indexes.push({
-                    name: indexName,
+            if (!field?.index) {
+                return [];
+            }
+            const columnName = this.resolveColumnName(key, field);
+            return [
+                {
+                    name: typeof field.index === 'string' ? field.index : derivedIndexName(collectionName, [columnName]),
                     entries: [{ column: columnName }],
                     unique: !!field.unique,
-                });
-            }
-        }
+                },
+            ];
+        });
+    }
+    generateCreateTable(entity, _options) {
+        const meta = getMeta(entity);
+        const collectionName = this.resolveTableName(meta);
+        const indexes = this.fieldIndexes(meta, collectionName);
         // One `createIndex` command each, mirroring the SQL generator's `[CREATE TABLE, ...CREATE INDEX]`,
         // so the key spec is built here and the migrator only executes it.
         return [
@@ -110,7 +120,7 @@ export class MongoSchemaGenerator extends AbstractDialect {
             name: indexName,
         });
     }
-    getSqlType(fieldOptions, fieldType) {
+    getSqlType(fieldOptions) {
         return '';
     }
     generateCreateTableFromNode(table, _options) {
@@ -137,22 +147,8 @@ export class MongoSchemaGenerator extends AbstractDialect {
         if (!currentTable) {
             return { tableName: collectionName, type: 'create' };
         }
-        const indexesToAdd = [];
         const existingIndexes = new Set(currentTable.indexes?.map((i) => i.name) ?? []);
-        for (const key of getKeys(meta.fields)) {
-            const field = meta.fields[key];
-            if (field?.index) {
-                const columnName = this.resolveColumnName(key, field);
-                const indexName = typeof field.index === 'string' ? field.index : derivedIndexName(collectionName, [columnName]);
-                if (!existingIndexes.has(indexName)) {
-                    indexesToAdd.push({
-                        name: indexName,
-                        entries: [{ column: columnName }],
-                        unique: !!field.unique,
-                    });
-                }
-            }
-        }
+        const indexesToAdd = this.fieldIndexes(meta, collectionName).filter((index) => !existingIndexes.has(index.name));
         if (indexesToAdd.length === 0) {
             return undefined;
         }

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

@@ -60,7 +60,10 @@ 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<string[] | undefined>;
+    protected getPrimaryKey(read: TableRowReader, tableName: string): Promise<{
+        columns?: string[];
+        name?: string;
+    }>;
     protected tableExistsParams(tableName: string): unknown[];
     protected getColumnsParams(tableName: string): unknown[];
     protected getIndexesParams(tableName: string): unknown[];
@@ -108,6 +111,11 @@ export declare abstract class AbstractSqlSchemaIntrospector extends BaseSqlIntro
      * overrides this.
      */
     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}.
+     */
+    protected mapPrimaryKeyName(results: RawRow[]): string | undefined;
     /** Parse default value string to appropriate type. */
     protected abstract parseDefaultValue(defaultValue: string | null): unknown;
 }

package/dist/migrate/introspection/abstractSqlSchemaIntrospector.js

@@ -55,7 +55,8 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
             return {
                 name: tableName,
                 columns,
-                primaryKey,
+                primaryKey: primaryKey.columns,
+                primaryKeyName: primaryKey.name,
                 indexes,
                 foreignKeys,
             };
@@ -100,7 +101,7 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
     }
     async getPrimaryKey(read, tableName) {
         const results = await read(this.getPrimaryKeyQuery(tableName), this.getPrimaryKeyParams(tableName));
-        return this.mapPrimaryKeyResult(results);
+        return { columns: this.mapPrimaryKeyResult(results), name: this.mapPrimaryKeyName(results) };
     }
     tableExistsParams(tableName) {
         return [tableName];
@@ -162,6 +163,14 @@ export class AbstractSqlSchemaIntrospector extends BaseSqlIntrospector {
         const columns = results.map((row) => String(row['column_name']));
         return columns.length ? columns : 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}.
+     */
+    mapPrimaryKeyName(results) {
+        const name = results[0]?.['constraint_name'];
+        return name === undefined || name === null ? undefined : String(name);
+    }
 }
 /** A {@link TableRowReader} over one querier: the same statement is only ever sent once. */
 function createTableRowReader(querier) {

package/dist/migrate/introspection/baseSqlIntrospector.js

@@ -64,10 +64,13 @@ export class BaseSqlIntrospector {
                     referencedBy: [],
                 };
                 columns.set(col.name, column);
-                if (col.isPrimaryKey) {
-                    table.primaryKey.push(column);
-                }
             }
+            // From the ordered list the query returned, not from the per-column flags: `(a, b)` is a
+            // different key from `(b, a)`, and a flag says only that a column is *in* the key. Falls back
+            // to the flags for an introspector that reports no key of its own.
+            const keyColumns = schema.primaryKey ?? schema.columns.filter((col) => col.isPrimaryKey).map((col) => col.name);
+            table.primaryKey.push(...keyColumns.flatMap((name) => columns.get(name) ?? []));
+            table.primaryKeyName = schema.primaryKeyName;
             tableNodes.set(schema.name, table);
             ast.addTable(table);
         }

package/dist/migrate/introspection/postgresIntrospector.js

@@ -160,7 +160,7 @@ export class PostgresSchemaIntrospector extends AbstractSqlSchemaIntrospector {
     }
     getPrimaryKeyQuery(_tableName) {
         return /*sql*/ `
-      SELECT kcu.column_name
+      SELECT kcu.column_name, tc.constraint_name
       FROM information_schema.table_constraints tc
       JOIN information_schema.key_column_usage kcu
         ON tc.constraint_name = kcu.constraint_name

package/dist/migrate/introspection/sqliteIntrospector.js

@@ -1,3 +1,4 @@
+import { derivedForeignKeyName } from '../../util/sql.util.js';
 import { AbstractSqlSchemaIntrospector } from './abstractSqlSchemaIntrospector.js';
 /**
  * SQLite schema introspector
@@ -104,11 +105,14 @@ export class SqliteSchemaIntrospector extends AbstractSqlSchemaIntrospector {
             existing.push(row);
             grouped.set(id, existing);
         }
-        return Array.from(grouped.entries()).map(([id, rows]) => {
+        return Array.from(grouped.entries()).map(([, rows]) => {
             const first = rows[0];
+            const columns = rows.map((r) => r.from);
             return {
-                name: `fk_${tableName}_${id}`,
-                columns: rows.map((r) => r.from),
+                // `PRAGMA foreign_key_list` reports no name, so one is derived the same way the entity side
+                // derives it. Seeded from the columns, not the PRAGMA's row id, which nothing else knows.
+                name: derivedForeignKeyName(tableName, columns),
+                columns,
                 referencedTable: first.table,
                 referencedColumns: rows.map((r) => r.to),
                 onDelete: this.normalizeReferentialAction(first.on_delete),

package/dist/migrate/migrator.js

@@ -436,6 +436,12 @@ export class Migrator {
                 this.logger.logSkippedMigration(`[AutoSync] Skipped altering ${filteredDiff.columnsToAlter.length} columns in table '${diff.tableName}': ${filteredDiff.columnsToAlter.map((c) => c.to.name).join(', ')} (safe mode active). Use a migration or { safe: false } to apply.`);
                 delete filteredDiff.columnsToAlter;
             }
+            if (filteredDiff.primaryKey) {
+                // Rewriting a key drops a constraint and rebuilds an index over the whole table, and fails
+                // outright where the new columns are null on rows that already exist. Firmly not additive.
+                this.logger.logSkippedMigration(`[AutoSync] Skipped changing the primary key of '${diff.tableName}' from (${filteredDiff.primaryKey.from.join(', ')}) to (${filteredDiff.primaryKey.to.join(', ')}) (safe mode active). Use a migration or { safe: false } to apply.`);
+                delete filteredDiff.primaryKey;
+            }
             delete filteredDiff.indexesToDrop;
             delete filteredDiff.foreignKeysToDrop;
         }

package/dist/migrate/schemaGenerator.d.ts

@@ -1,5 +1,6 @@
 import { type AbstractDialect, AbstractSqlDialect } from '../dialect/index.js';
 import type { SchemaAST } from '../schema/schemaAST.js';
+import { type DiffOptions } from '../schema/schemaASTDiffer.js';
 import type { CanonicalType, ColumnNode, ForeignKeyAction, IndexNode, TableNode } from '../schema/types.js';
 import type { ColumnSchema, CreateSchemaOptions, DialectFeatures, DropSchemaOptions, EntityMeta, FieldMeta, FieldOptions, IndexSchema, NamingStrategy, SchemaDiff, SchemaGenerator, SqlDdlGenerator, Type } from '../type/index.js';
 import type { FullColumnDefinition, TableDefinition, TableForeignKeyDefinition } from './builder/types.js';
@@ -25,11 +26,7 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
     /**
      * Primary key type for auto-increment integer IDs
      */
-    protected get serialPrimaryKeyType(): string;
-    /**
-     * Convert FieldOptions to CanonicalType using the unified type system.
-     */
-    protected getCanonicalType(field: FieldOptions, fieldType?: unknown): CanonicalType;
+    protected get serialType(): string;
     protected canonicalTypeToSql(type: CanonicalType): string;
     /**
      * Every `CREATE TABLE` for `entities`, then their foreign keys.
@@ -66,13 +63,15 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
      */
     generateDropIndex(tableName: string, indexName: string, schema?: string): string;
     /**
-     * Generate a column definition from a {@link ColumnSchema}, whose type is the engine's own spelling
-     * and may already carry its precision (or even `PRIMARY KEY`, for a serial).
+     * A column definition from a {@link ColumnSchema}, whose type is already the engine's own spelling
+     * and may carry its own size.
+     *
+     * Kept apart from {@link generateColumnFromNode} rather than folded into it: a `ColumnSchema` has no
+     * `enum`, because introspection reads one back as a `CHECK` constraint and not as a property of the
+     * column, so only the node knows enough to emit that clause. Both spell the definition through
+     * {@link renderColumn}, which is the part that must not be written twice.
      */
-    generateColumnDefinitionFromSchema(column: ColumnSchema, options?: {
-        includePrimaryKey?: boolean;
-        includeUnique?: boolean;
-    }): string;
+    generateColumnDefinitionFromSchema(column: ColumnSchema): string;
     /**
      * The one place a column definition is spelled. Both callers reach it - the `ColumnSchema` path above
      * and the `ColumnNode` path below - because the clause order and the "no NOT NULL on a primary key"
@@ -82,7 +81,7 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
     /** ` DEFAULT <sql>`, or nothing where the column declares none. Empty rather than `DEFAULT NULL`
      * so an absent default stays absent - `defaultValue: null` is the way to ask for one. */
     private defaultClause;
-    getSqlType(field: FieldMeta, fieldType?: unknown): string;
+    getSqlType(field: FieldMeta): string;
     /**
      * Generate ALTER COLUMN statements (database-specific)
      */
@@ -94,39 +93,30 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
     /**
      * Compare an entity with a database table node and return the differences.
      */
-    diffSchema<E>(entity: Type<E>, currentTable: TableNode | undefined): SchemaDiff | undefined;
     /**
-     * Indexes the entity declares that the table does not have, matched by name and built the same way
-     * `CREATE TABLE` builds them, so adding an `@Index` to an entity already in the database is picked
-     * up rather than waiting for the table to be created from scratch somewhere else.
+     * How this entity differs from the table the database reported, as the migrator's `SchemaDiff`.
      *
-     * Only ever additive. An index the entity does not name is left alone: it may well have been
-     * created deliberately outside the ORM, and dropping it is a decision for a reviewed migration.
-     *
-     * A vector index is one of these like any other: MariaDB's `CREATE VECTOR INDEX ... ON t (col)`
-     * adds one to a table that already exists, which the inline `CREATE TABLE` form it also has cannot.
-     */
-    private missingIndexes;
-    private columnNodeToSchema;
-    /**
-     * Convert field options to ColumnSchema. Both sides of a diff are the engine's SQL spelling: what it
-     * would create for this field, against what it reported for the existing column.
+     * The comparison itself is {@link diffTable}, the same one drift detection runs, so the two can no
+     * longer disagree about what has changed. Only two things are this side's own: the entity becomes a
+     * table node first, and types are compared as the *engine* would store them - see `normalizeType`.
      */
-    protected fieldToColumnSchema<E>(fieldKey: string, field: FieldOptions, meta: EntityMeta<E>): ColumnSchema;
+    diffSchema<E>(entity: Type<E>, currentTable: TableNode | undefined): SchemaDiff | undefined;
     /**
-     * Check if two columns differ enough to require alteration
+     * What the shared differ needs from a dialect: a type as this engine would actually store it.
+     *
+     * `boolean` is `TINYINT(1)` on MySQL and `INTEGER` on SQLite, so two canonical types that differ on
+     * paper can be one column in the database. Round-tripping through the engine's own spelling is what
+     * stops every such column reporting an alteration on every sync.
      */
-    protected columnsNeedAlteration(current: ColumnSchema, desired: ColumnSchema): boolean;
     /**
-     * Whether two column types are the same *as this engine stores them*.
+     * Indexes the entity declares that the table does not already have, in any shape.
      *
-     * Both sides are SQL spellings, parsed back to canonical so that `INT` and `INTEGER`, or `DATETIME`
-     * and `TIMESTAMP`, do not read as a change. Do not "simplify" this into comparing the entity's
-     * canonical type against the column's: several canonical types share one storage type per engine
-     * (`boolean` is `TINYINT(1)` on MySQL and `INTEGER` on SQLite), so that comparison reports an
-     * alteration for those columns on every single sync.
+     * Additive only: an index the entity does not name may well have been created deliberately outside
+     * the ORM, and dropping it is a decision for a reviewed migration.
      */
-    protected isTypeEqual(current: ColumnSchema, desired: ColumnSchema): boolean;
+    private missingIndexes;
+    protected diffOptions(): DiffOptions;
+    private columnNodeToSchema;
     /**
      * Compare two default values for equality
      */
@@ -156,6 +146,22 @@ export declare class SqlSchemaGenerator implements SqlDdlGenerator {
     generateRenameColumnSql(tableName: string, oldName: string, newName: string): string;
     generateAddForeignKeySql(tableName: string, foreignKey: TableForeignKeyDefinition): string;
     generateDropForeignKeySql(tableName: string, constraintName: string): string;
+    /**
+     * `ALTER TABLE ... ADD CONSTRAINT <name> PRIMARY KEY (...)`, the other half of
+     * {@link generateDropPrimaryKeySql}. Refused where the engine cannot alter a key at all, by name,
+     * rather than emitting DDL it will reject.
+     */
+    generateAddPrimaryKeySql(tableName: string, columns: readonly string[], name?: string): string;
+    /**
+     * Drops whatever key the table has.
+     *
+     * `constraintName` has to be what the constraint is *actually* called: the name introspection
+     * reported for a key the database already had, or the derived one for a key this generator itself
+     * added, which is what reversing a migration drops. Guessing either way names nothing. MySQL takes
+     * no name at all - a table's key is always `PRIMARY` there.
+     */
+    generateDropPrimaryKeySql(tableName: string, constraintName?: string): string;
+    private assertPrimaryKeyAlterable;
 }
 /**
  * The entities as an AST, named the way `generator` names things.