uql-orm 0.74.0 → 0.74.1

package/dist/migrate/drift/driftDetector.js

@@ -199,7 +199,7 @@ function detectIndexDrifts(diff) {
                 table: idxDiff.table,
                 index: idxDiff.name,
                 details: `Index "${idxDiff.name}" exists in database but not defined in entity`,
-                suggestion: 'Add @Field({ index }) or create migration to drop',
+                suggestion: 'Declare it, or drop it via migration: generate:entities drops one uql named',
             });
         }
         else {
@@ -211,7 +211,7 @@ function detectIndexDrifts(diff) {
                 table: idxDiff.table,
                 index: idxDiff.name,
                 details: `Index "${idxDiff.name}" differs from the entity (${idxDiff.description})`,
-                suggestion: 'Drop and recreate the index via migration',
+                suggestion: 'Recreate it via migration, which generate:entities writes',
             });
         }
     }

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

@@ -33,6 +33,7 @@ export declare class MongoSchemaGenerator extends MongoDialect implements Schema
     generateDropTable(tableName: string): string;
     generateAlterTable(diff: SchemaDiff): string[];
     generateAlterTableDown(diff: SchemaDiff): 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;
     /** An Atlas vector search index: its vector field first, then each field a `$vectorSearch` pre-filters on. */

package/dist/migrate/generator/mongoSchemaGenerator.js

@@ -1,6 +1,7 @@
 import { getMeta } from '../../entity/index.js';
 import { MongoDialect } from '../../mongo/mongoDialect.js';
 import { textLanguage } from '../../mongo/textLanguage.js';
+import { indexChanges } from '../../schema/indexDifferences.js';
 import { QueryRaw, } from '../../type/index.js';
 import { indexDistance, unsupportedVectorMetric } from '../../type/vector.js';
 import { declaredIndexes, declaredIndexName, renderIndexColumn } from '../../util/ddlExpression.util.js';
@@ -8,6 +9,7 @@ import { fulltextConfig, fulltextWeights } from '../../util/dialect.util.js';
 import { assertIndexFeatures, assertIndexType } from '../ddl/indexDdl.js';
 import { assertIndexPredicate, refusedIndexPredicate } from '../indexPredicate.js';
 import { renderIndexDefinition } from './definitionToNode.js';
+import { indexNodeToSchema } from './indexNodeToSchema.js';
 import { serializeMongoCommand } from './mongoCommand.js';
 /** The index types a key spec can say, a plain key or `'text'`, and Atlas's vector search index. */
 const MONGO_INDEX_TYPES = new Set(['btree', 'fulltext', 'vectorSearch']);
@@ -105,12 +107,21 @@ export class MongoSchemaGenerator extends MongoDialect {
         return serializeMongoCommand({ action: 'dropCollection', name: tableName });
     }
     generateAlterTable(diff) {
-        return (diff.indexesToAdd ?? []).map((index) => this.generateCreateIndex(diff.tableName, index));
+        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) => index.type === 'vectorSearch'
-            ? serializeMongoCommand({ action: 'dropSearchIndex', collection: diff.tableName, name: index.name })
-            : this.generateDropIndex(diff.tableName, index.name));
+        return [
+            ...(diff.indexesToAdd ?? []).map((index) => this.dropIndexCommand(diff.tableName, index)),
+            ...(diff.indexesToDrop ?? []).map((index) => this.generateCreateIndex(diff.tableName, index)),
+        ];
+    }
+    dropIndexCommand(tableName, index) {
+        return index.type === 'vectorSearch'
+            ? serializeMongoCommand({ action: 'dropSearchIndex', collection: tableName, name: index.name })
+            : this.generateDropIndex(tableName, index.name);
     }
     /** An index as MongoDB's key spec (`-1` descending, `'text'` full-text), refusing the SQL-only options. */
     generateCreateIndex(tableName, index) {
@@ -200,15 +211,16 @@ export class MongoSchemaGenerator extends MongoDialect {
         if (!currentTable) {
             return { tableName: collectionName, type: 'create' };
         }
-        const existingIndexes = new Set(currentTable.indexes.map((i) => i.name));
-        const indexesToAdd = this.indexesOf(meta, collectionName).filter((index) => !existingIndexes.has(index.name));
-        if (indexesToAdd.length === 0) {
+        // 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,
+            indexesToAdd: toAdd.length ? toAdd : undefined,
+            indexesToDrop: toDrop.length ? toDrop.map(indexNodeToSchema) : undefined,
         };
     }
 }

package/dist/migrate/migrator.js

@@ -189,15 +189,16 @@ export class Migrator {
             this.logger.logInfo('No schema changes detected.');
             return '';
         }
+        // Diff by diff in reverse, each rolled back in the order its generator wrote it.
         const down = [
-            ...created.map((tableName) => generator.generateDropTable(tableName, { ifExists: true })),
-            ...altered.flatMap((diff) => generator.generateAlterTableDown(diff)),
+            ...altered.toReversed().flatMap((diff) => generator.generateAlterTableDown(diff)),
+            ...created.toReversed().map((tableName) => generator.generateDropTable(tableName, { ifExists: true })),
         ];
         const { emit } = this.target.source;
         const filePath = await this.writeMigration(name, {
             docExtraLines: ['Generated from entity definitions'],
             upInner: emit(up),
-            downInner: emit(down.reverse()),
+            downInner: emit(down),
         });
         this.logger.logInfo(`Created migration from entities: ${filePath}`);
         return filePath;
@@ -345,7 +346,13 @@ export class Migrator {
                 this.logger.logSkippedMigration(`[AutoSync] Skipped altering ${filteredDiff.foreignKeysToAlter.length} foreign keys in table '${diff.tableName}': ${filteredDiff.foreignKeysToAlter.map((fk) => fk.to.name).join(', ')} (safe mode active). Use a migration or { safe: false } to apply.`);
                 delete filteredDiff.foreignKeysToAlter;
             }
-            delete filteredDiff.indexesToDrop;
+            if (filteredDiff.indexesToDrop?.length) {
+                // An index recreated under its old name is a drop and an add, held back together.
+                const dropped = new Set(filteredDiff.indexesToDrop.map((index) => index.name));
+                this.logger.logSkippedMigration(`[AutoSync] Skipped dropping ${dropped.size} indexes in table '${diff.tableName}': ${[...dropped].join(', ')} (safe mode active). Use a migration or { safe: false } to apply.`);
+                filteredDiff.indexesToAdd = filteredDiff.indexesToAdd?.filter((index) => !dropped.has(index.name));
+                delete filteredDiff.indexesToDrop;
+            }
             delete filteredDiff.foreignKeysToDrop;
         }
         if (!options.drop && filteredDiff.columnsToDrop?.length) {

package/dist/migrate/schemaGenerator.d.ts

@@ -62,12 +62,16 @@ export declare class SqlSchemaGenerator implements SchemaGenerator {
     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[];
     generateCreateIndex(tableName: string, index: IndexSchema, options?: {
         ifNotExists?: boolean;
     }): string;
-    /** An index added to a table that may already have rows: its `CREATE`, then what the engine needs after. */
-    private addIndexStatements;
     /**
      * `schema` is the table's, because that is where its indexes live. MySQL takes it from the table
      * operand instead, which is already qualified.
@@ -106,13 +110,6 @@ export declare class SqlSchemaGenerator implements SchemaGenerator {
      * drift detection runs, with types normalized as the engine stores them.
      */
     diffSchema(entity: Type<object>, currentTable: TableNode | undefined, desiredAst?: SchemaAST): SchemaDiff | undefined;
-    /**
-     * Indexes the entity declares that the table does not already have, in any shape.
-     *
-     * 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.
-     */
-    private missingIndexes;
     protected diffOptions(): DiffOptions;
     /** Spread, not copied field by field, so a field the node gains cannot go missing here. */
     private columnNodeToSchema;

package/dist/migrate/schemaGenerator.js

@@ -1,6 +1,6 @@
 import { getMeta } from '../entity/index.js';
 import { canonicalToSql, engineType, isVectorCategory } from '../schema/canonicalType.js';
-import { indexSignature } from '../schema/indexDifferences.js';
+import { indexChanges } from '../schema/indexDifferences.js';
 import { buildSchemaAST, resolveColumnCanonicalType } from '../schema/schemaASTBuilder.js';
 import { diffRelationshipNodes, diffTable } from '../schema/schemaASTDiffer.js';
 import { isAutoIncrement, qualifyName } from '../util/index.js';
@@ -144,40 +144,19 @@ export class SqlSchemaGenerator {
             ...(diff.foreignKeysToDrop ?? []),
             ...(diff.foreignKeysToAlter ?? []).map((it) => constraintNameOf(diff.tableName, it.from)),
         ]));
-        // Add new columns
-        if (diff.columnsToAdd?.length) {
-            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));
-            }
-        }
-        // Alter existing columns
-        if (diff.columnsToAlter?.length) {
-            for (const { to } of diff.columnsToAlter) {
-                const colDef = this.generateColumnDefinitionFromSchema(to);
-                const colStatements = this.generateAlterColumnStatements(diff.tableName, to, colDef);
-                statements.push(...colStatements);
-            }
-        }
-        // Drop columns
-        if (diff.columnsToDrop?.length) {
-            for (const columnName of diff.columnsToDrop) {
-                statements.push(...this.tableDdl.dropColumn(diff.tableName, columnName));
-            }
-        }
-        // Add indexes
-        if (diff.indexesToAdd?.length) {
-            for (const index of diff.indexesToAdd) {
-                statements.push(...this.addIndexStatements(diff.tableName, index));
-            }
-        }
-        // Drop indexes
-        if (diff.indexesToDrop?.length) {
-            for (const indexName of diff.indexesToDrop) {
-                statements.push(this.generateDropIndex(diff.tableName, indexName, diff.schema));
-            }
-        }
+        // 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));
@@ -198,6 +177,21 @@ export class SqlSchemaGenerator {
     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 = []) {
+        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
@@ -212,44 +206,26 @@ export class SqlSchemaGenerator {
         if (diff.primaryKey?.to.length) {
             statements.push(this.generateDropPrimaryKeySql(diff.tableName, derivedPrimaryKeyName(diff.tableName, diff.primaryKey.to)));
         }
-        // Reverse column additions by dropping them
-        if (diff.columnsToAdd?.length) {
-            for (const column of diff.columnsToAdd) {
-                statements.push(...this.tableDdl.dropColumn(diff.tableName, column.name));
-            }
-        }
-        // Reverse column alterations by restoring original schema
-        if (diff.columnsToAlter?.length) {
-            for (const { from } of diff.columnsToAlter) {
-                const colDef = this.generateColumnDefinitionFromSchema(from);
-                const colStatements = this.generateAlterColumnStatements(diff.tableName, from, colDef);
-                statements.push(...colStatements);
-            }
-        }
-        // Reverse index additions by dropping them
-        if (diff.indexesToAdd?.length) {
-            for (const index of diff.indexesToAdd) {
-                statements.push(this.generateDropIndex(diff.tableName, index.name, diff.schema));
-            }
+        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.indexesToDrop?.length || diff.foreignKeysToDrop?.length) {
-            statements.push(`-- TODO: Manual reversal needed for dropped columns/indexes/foreign keys`);
+        if (diff.columnsToDrop?.length || diff.foreignKeysToDrop?.length) {
+            statements.push(`-- TODO: Manual reversal needed for dropped columns/foreign keys`);
         }
         return statements;
     }
     generateCreateIndex(tableName, index, options = {}) {
         return this.indexDdl.getCreateIndexStatement(tableName, index, options);
     }
-    /** An index added to a table that may already have rows: its `CREATE`, then what the engine needs after. */
-    addIndexStatements(tableName, index) {
-        return [this.generateCreateIndex(tableName, index), ...this.indexDdl.settleStatements(tableName, index)];
-    }
     /**
      * `schema` is the table's, because that is where its indexes live. MySQL takes it from the table
      * operand instead, which is already qualified.
@@ -351,10 +327,12 @@ export class SqlSchemaGenerator {
         }
         // 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 a
-        // separate index rather than a change - no engine alters an index's columns or uniqueness.
+        // 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 indexesToAdd = this.missingIndexes(desired, currentTable);
+        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] : []));
@@ -387,6 +365,7 @@ export class SqlSchemaGenerator {
             !columnsToAlter.length &&
             !columnsToDrop.length &&
             !indexesToAdd.length &&
+            !indexesToDrop.length &&
             !foreignKeysToAdd.length &&
             !foreignKeysToDrop.length &&
             !foreignKeysToAlter.length &&
@@ -402,21 +381,12 @@ export class SqlSchemaGenerator {
             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,
         };
     }
-    /**
-     * Indexes the entity declares that the table does not already have, in any shape.
-     *
-     * 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.
-     */
-    missingIndexes(desired, currentTable) {
-        const present = new Set(currentTable.indexes.map(indexSignature));
-        return desired.indexes.filter((index) => !present.has(indexSignature(index))).map(indexNodeToSchema);
-    }
     diffOptions() {
         return {
             normalizeType: engineType(this.dialect),
@@ -563,7 +533,9 @@ export class SqlSchemaGenerator {
             case 'alterColumn':
                 return this.generateAlterColumnSql(operation.tableName, operation.columnName, operation.changes);
             case 'createIndex':
-                return this.addIndexStatements(operation.tableName, renderIndexDefinition(operation.index, (sql) => this.dialect.compileDdl(sql)));
+                return this.addIndexStatements(operation.tableName, [
+                    renderIndexDefinition(operation.index, (sql) => this.dialect.compileDdl(sql)),
+                ]);
             case 'dropIndex':
                 return [this.generateDropIndex(operation.tableName, operation.indexName)];
             case 'addForeignKey':

package/dist/schema/indexDifferences.d.ts

@@ -5,18 +5,28 @@ import type { IndexNode } from './types.js';
  * `textIndex` is a text index's weights and language, kept by an engine that lists its fields in no declared order.
  */
 export type IndexFacet = 'order' | 'nulls' | 'opsClass' | 'accessMethod' | 'include' | 'vector' | 'textIndex';
+type ComparableIndex = Pick<IndexNode, 'name' | 'entries' | 'unique'>;
 /**
  * Whether the table has this index already, by shape rather than name, uniqueness included. An index
  * over an expression, whose text the engine reprints, falls back to its name.
  */
-export declare function indexSignature(index: Pick<IndexNode, 'name' | 'entries' | 'unique'>): string;
+export declare function indexSignature(index: ComparableIndex): string;
 /**
  * A constraint name without its kind marker, pairing an index with its older spelling
  * (`idx_User_email` with `User__email_idx`). Only one marker, the trailing one first.
  */
 export declare function indexNameStem(name: string): string;
+/**
+ * The indexes a table lacks and the ones it no longer needs, matched by `keyOf`. Only an index uql
+ * named, or whose name the entity claims, is dropped: any other may have been made outside the ORM.
+ */
+export declare function indexChanges<I extends ComparableIndex>(table: string, declared: readonly I[], current: readonly IndexNode[], keyOf?: (index: ComparableIndex) => string): {
+    toAdd: I[];
+    toDrop: IndexNode[];
+};
 /**
  * What two indexes differ by, comparing only what both sides state structurally: an expression, a JSON
  * path or a predicate is reprinted by the engine, so never compared.
  */
 export declare function describeIndexDifferences(source: IndexNode, target: IndexNode, facets: ReadonlySet<IndexFacet>): string[];
+export {};

package/dist/schema/indexDifferences.js

@@ -1,11 +1,16 @@
 import { isVectorIndexType } from '../type/vector.js';
 import { fulltextConfig } from '../util/dialect.util.js';
+import { derivedIndexName } from '../util/sql.util.js';
+/** An entry the engine reprints in its own words, so never compared as written. */
+function isReprinted(entry) {
+    return Boolean(entry.expression || entry.jsonPath || entry.jsonArray);
+}
 /**
  * Whether the table has this index already, by shape rather than name, uniqueness included. An index
  * over an expression, whose text the engine reprints, falls back to its name.
  */
 export function indexSignature(index) {
-    const comparable = !index.entries.some((entry) => entry.expression || entry.jsonPath || entry.jsonArray);
+    const comparable = !index.entries.some(isReprinted);
     const identity = comparable
         ? index.entries.map((entry) => entry.column).join(',')
         : `name:${indexNameStem(index.name)}`;
@@ -20,6 +25,33 @@ export function indexNameStem(name) {
     const bare = withoutSuffix === name ? name.replace(KIND_PREFIX, '') : withoutSuffix;
     return bare.replace(/__/g, '_');
 }
+/**
+ * The indexes a table lacks and the ones it no longer needs, matched by `keyOf`. Only an index uql
+ * named, or whose name the entity claims, is dropped: any other may have been made outside the ORM.
+ */
+export function indexChanges(table, declared, current, keyOf = indexSignature) {
+    const present = new Set(current.map(keyOf));
+    const wanted = new Set(declared.map(keyOf));
+    const claimed = new Set(declared.map((index) => index.name));
+    const owned = (index) => claimed.has(index.name) || hasDerivedName(table, index);
+    return {
+        toAdd: declared.filter((index) => !present.has(keyOf(index))),
+        toDrop: current.filter((index) => !wanted.has(keyOf(index)) && owned(index)),
+    };
+}
+/**
+ * Whether uql named the index itself, from its own columns: `Order__total_idx`, its unique `_uk`, or
+ * the `idx_Order_total` it wrote until 0.42.1.
+ */
+function hasDerivedName(table, index) {
+    const parts = index.entries.map((entry, at) => (isReprinted(entry) ? `expr${at}` : entry.column));
+    const derived = [
+        derivedIndexName(table, parts),
+        derivedIndexName(table, parts, true),
+        `idx_${table}_${parts.join('_')}`,
+    ];
+    return derived.includes(index.name);
+}
 /** What this version emits. */
 const KIND_SUFFIX = /_(?:idx|fk|ck|pk|uk|uq)$/i;
 /**
@@ -34,7 +66,7 @@ const KIND_PREFIX = /^(?:idx|fk|ck|pk|uk|uq)_/i;
  */
 export function describeIndexDifferences(source, target, facets) {
     const differences = [];
-    const comparableEntries = ![...source.entries, ...target.entries].some((entry) => entry.expression || entry.jsonPath || entry.jsonArray);
+    const comparableEntries = ![...source.entries, ...target.entries].some(isReprinted);
     if (comparableEntries) {
         const [sourceColumns, targetColumns] = [source, target].map((index) => textFieldOrder(index, facets, index.entries.map((entry) => entrySignature(entry, facets))).join(', '));
         if (sourceColumns !== targetColumns) {

package/dist/type/migration.d.ts

@@ -203,7 +203,8 @@ export interface SchemaDiff {
     }[];
     readonly columnsToDrop?: string[];
     readonly indexesToAdd?: IndexSchema[];
-    readonly indexesToDrop?: string[];
+    /** Whole rather than by name, so the rollback can create each again. */
+    readonly indexesToDrop?: IndexSchema[];
     readonly foreignKeysToAdd?: ForeignKeySchema[];
     /** Dropped under the name the *database* reported, which is the only name a `DROP` can use. */
     readonly foreignKeysToDrop?: string[];

package/package.json

@@ -3,7 +3,7 @@
   "homepage": "https://uql-orm.dev",
   "description": "The JSON-native TypeScript ORM for Bun, Browsers, Edge, Deno, Node, Workers. Supports PostgreSQL, PGlite, MySQL, MariaDB, SQLite, CockroachDB, SQL Server, Turso, Neon, Cloudflare D1 and MongoDB. Queries are plain JSON, typed to the leaf.",
   "license": "MIT",
-  "version": "0.74.0",
+  "version": "0.74.1",
   "type": "module",
   "engines": {
     "node": ">=24"