@signal24/dk-server-foundation 26.213.615

package/dist/src/database/migration/characters.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationCharactersCommand = void 0;
+exports.standardizeDbCollation = standardizeDbCollation;
+const tslib_1 = require("tslib");
+function __assignType(fn, args) {
+    fn.__type = args;
+    return fn;
+}
+const app_1 = require("@deepkit/app");
+const state_1 = require("../../app/state");
+const common_1 = require("../common");
+const dialect_1 = require("../dialect");
+const __ΩICollationOptions = ['charset', 'collation', 'ICollationOptions', 'P&4!8&4"8Mw#y'];
+const DEFAULT_CHARSET = 'utf8mb4';
+const DEFAULT_COLLATION = 'utf8mb4_0900_ai_ci';
+async function standardizeDbCollation(db, options) {
+    const dialect = (0, dialect_1.getDialect)(db.adapter);
+    if (dialect === 'postgres') {
+        console.warn('standardizeDbCollation is not applicable to PostgreSQL — skipping');
+        return;
+    }
+    const charset = options?.charset ?? DEFAULT_CHARSET;
+    const collation = options?.collation ?? DEFAULT_COLLATION;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const dbNameResult = await db.rawQuery('SELECT DATABASE()');
+    const dbName = Object.values(dbNameResult[0])[0];
+    await db.rawQuery(`ALTER DATABASE ${dbName} CHARACTER SET = ${charset} COLLATE = ${collation}`);
+    const tablesResult = await db.rawQuery('SHOW TABLES');
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const tables = tablesResult.map(__assignType((row) => Object.values(row)[0], ['row', '', 'P"2!"/"']));
+    for (const table of tables) {
+        await db.rawQuery(`ALTER TABLE ${table} CONVERT TO CHARACTER SET ${charset} COLLATE ${collation}`);
+    }
+}
+standardizeDbCollation.__type = [() => common_1.BaseDatabase, 'db', () => __ΩICollationOptions, 'options', 'standardizeDbCollation', 'PP7!2"n#2$8"/%'];
+let MigrationCharactersCommand = class MigrationCharactersCommand {
+    constructor(dbProvider) {
+        this.dbProvider = dbProvider;
+    }
+    async execute(charset = DEFAULT_CHARSET, collation = DEFAULT_COLLATION) {
+        const dialect = (0, dialect_1.getDialect)(this.dbProvider.db.adapter);
+        if (dialect === 'postgres') {
+            console.warn('Character set standardization is not applicable to PostgreSQL');
+            return;
+        }
+        await standardizeDbCollation(this.dbProvider.db, { charset, collation });
+    }
+};
+exports.MigrationCharactersCommand = MigrationCharactersCommand;
+MigrationCharactersCommand.__type = [() => state_1.DBProvider, 'dbProvider', 'constructor', 'charset', () => DEFAULT_CHARSET, 'collation', () => DEFAULT_COLLATION, 'execute', 'MigrationCharactersCommand', 'PP7!2";"0#P&2$>%&2&>\'"0(5w)'];
+exports.MigrationCharactersCommand = MigrationCharactersCommand = tslib_1.__decorate([
+    app_1.cli.controller('migration:characters'),
+    tslib_1.__metadata("design:paramtypes", [state_1.DBProvider])
+], MigrationCharactersCommand);
+//# sourceMappingURL=characters.js.map

package/dist/src/database/migration/characters.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"characters.js","sourceRoot":"","sources":["../../../../src/database/migration/characters.ts"],"names":[],"mappings":";;;AAeA,wDAuBC;;;;;;AAtCD,sCAAmC;AAGnC,2CAA6C;AAC7C,sCAAyC;AACzC,wCAAwC;;AAOxC,MAAM,eAAe,GAAG,SAAS,CAAC;AAClC,MAAM,iBAAiB,GAAG,oBAAoB,CAAC;AAExC,KAAK,UAAU,sBAAsB,CAAC,EAAgB,EAAE,OAA2B;IACtF,MAAM,OAAO,GAAG,IAAA,oBAAU,EAAC,EAAE,CAAC,OAA6B,CAAC,CAAC;IAC7D,IAAI,OAAO,KAAK,UAAU,EAAE,CAAC;QACzB,OAAO,CAAC,IAAI,CAAC,mEAAmE,CAAC,CAAC;QAClF,OAAO;IACX,CAAC;IAED,MAAM,OAAO,GAAG,OAAO,EAAE,OAAO,IAAI,eAAe,CAAC;IACpD,MAAM,SAAS,GAAG,OAAO,EAAE,SAAS,IAAI,iBAAiB,CAAC;IAE1D,8DAA8D;IAC9D,MAAM,YAAY,GAAU,MAAM,EAAE,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC;IACnE,MAAM,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;IAEjD,MAAM,EAAE,CAAC,QAAQ,CAAC,kBAAkB,MAAM,oBAAoB,OAAO,cAAc,SAAS,EAAE,CAAC,CAAC;IAEhG,MAAM,YAAY,GAAG,MAAM,EAAE,CAAC,QAAQ,CAAC,aAAa,CAAC,CAAC;IACtD,8DAA8D;IAC9D,MAAM,MAAM,GAAG,YAAY,CAAC,GAAG,cAAC,CAAC,GAAQ,EAAE,EAAE,CAAC,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,0BAAC,CAAC;IAErE,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QACzB,MAAM,EAAE,CAAC,QAAQ,CAAC,eAAe,KAAK,6BAA6B,OAAO,YAAY,SAAS,EAAE,CAAC,CAAC;IACvG,CAAC;AACL,CAAC;;AAGM,IAAM,0BAA0B,GAAhC,MAAM,0BAA0B;IACnC,YAAoB,UAAsB;QAAtB,eAAU,GAAV,UAAU,CAAY;IAAG,CAAC;IAE9C,KAAK,CAAC,OAAO,CAAC,UAAkB,eAAe,EAAE,YAAoB,iBAAiB;QAClF,MAAM,OAAO,GAAG,IAAA,oBAAU,EAAC,IAAI,CAAC,UAAU,CAAC,EAAE,CAAC,OAA6B,CAAC,CAAC;QAC7E,IAAI,OAAO,KAAK,UAAU,EAAE,CAAC;YACzB,OAAO,CAAC,IAAI,CAAC,+DAA+D,CAAC,CAAC;YAC9E,OAAO;QACX,CAAC;QACD,MAAM,sBAAsB,CAAC,IAAI,CAAC,UAAU,CAAC,EAAE,EAAE,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC;IAC7E,CAAC;;AAVQ,gEAA0B;;qCAA1B,0BAA0B;IADtC,SAAG,CAAC,UAAU,CAAC,sBAAsB,CAAC;6CAEH,kBAAU;GADjC,0BAA0B,CAWtC"}

package/dist/src/database/migration/create/MigrationCreateCommand.d.ts

@@ -0,0 +1,11 @@
+import { Flag } from '@deepkit/app';
+import { DBProvider } from '../../../app/state';
+export declare class MigrationCreateCommand {
+    private dbProvider;
+    private logger;
+    constructor(dbProvider: DBProvider);
+    execute(nonInteractive?: boolean & Flag<{
+        description: 'Skip interactive prompts';
+    }>): Promise<void>;
+}
+//# sourceMappingURL=MigrationCreateCommand.d.ts.map

package/dist/src/database/migration/create/MigrationCreateCommand.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"MigrationCreateCommand.d.ts","sourceRoot":"","sources":["../../../../../src/database/migration/create/MigrationCreateCommand.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,IAAI,EAAE,MAAM,cAAc,CAAC;AAGzC,OAAO,EAAE,UAAU,EAAE,MAAM,oBAAoB,CAAC;AAYhD,qBACa,sBAAsB;IAGnB,OAAO,CAAC,UAAU;IAF9B,OAAO,CAAC,MAAM,CAAmC;gBAE7B,UAAU,EAAE,UAAU;IAEpC,OAAO,CAAC,cAAc,GAAE,OAAO,GAAG,IAAI,CAAC;QAAE,WAAW,EAAE,0BAA0B,CAAA;KAAE,CAAS;CAwEpG"}

package/dist/src/database/migration/create/MigrationCreateCommand.js

@@ -0,0 +1,104 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MigrationCreateCommand = void 0;
+const tslib_1 = require("tslib");
+function __assignType(fn, args) {
+    fn.__type = args;
+    return fn;
+}
+/*@ts-ignore*/
+var { __ΩFlag } = require('@deepkit/app');
+const app_1 = require("@deepkit/app");
+const state_1 = require("../../../app/state");
+const resolver_1 = require("../../../app/resolver");
+const services_1 = require("../../../services");
+const dialect_1 = require("../../dialect");
+const entity_reader_1 = require("./entity-reader");
+const db_reader_1 = require("./db-reader");
+const comparator_1 = require("./comparator");
+const ddl_generator_1 = require("./ddl-generator");
+const file_generator_1 = require("./file-generator");
+const prompt_1 = require("./prompt");
+const schema_model_1 = require("./schema-model");
+let MigrationCreateCommand = class MigrationCreateCommand {
+    constructor(dbProvider) {
+        this.dbProvider = dbProvider;
+        this.logger = (0, services_1.createLogger)('MigrationCreate');
+    }
+    async execute(nonInteractive = false) {
+        if (nonInteractive) {
+            (0, prompt_1.setNonInteractive)(true);
+        }
+        try {
+            const db = this.dbProvider.db;
+            const dialect = (0, dialect_1.getDialect)(db.adapter);
+            const pgSchema = dialect === 'postgres' ? ((0, resolver_1.getAppConfig)().PG_SCHEMA ?? 'public') : 'public';
+            this.logger.info(`Dialect: ${dialect}`);
+            // Step 1: Read entity schema
+            this.logger.info('Reading entity definitions...');
+            const entitySchema = (0, entity_reader_1.readEntitiesSchema)(db, dialect);
+            const entityTableNames = Array.from(entitySchema.keys());
+            this.logger.info(`Found ${entityTableNames.length} entity table(s): ${entityTableNames.join(', ')}`);
+            // Step 2: Discover all DB tables and union with entity table names
+            const allDbTableNames = await (0, db_reader_1.readAllTableNames)(db, dialect, pgSchema);
+            const dbOnlyTables = allDbTableNames.filter(__assignType(n => !entitySchema.has(n) && !schema_model_1.INTERNAL_TABLES.has(n), ['n', '', 'P"2!"/"']));
+            const tableNames = [...entityTableNames, ...dbOnlyTables];
+            // Step 3: Read database schema
+            this.logger.info('Reading database schema...');
+            const dbSchema = await (0, db_reader_1.readDatabaseSchema)(db, dialect, tableNames, pgSchema);
+            // Step 4: Compare schemas
+            this.logger.info('Comparing schemas...');
+            const diff = await (0, comparator_1.compareSchemas)(entitySchema, dbSchema, dialect, !nonInteractive, pgSchema);
+            // Step 5: Generate DDL
+            const statements = (0, ddl_generator_1.generateDDL)(diff);
+            if (statements.length === 0) {
+                this.logger.info('No schema changes detected.');
+                return;
+            }
+            // Step 6: Show summary
+            this.logger.info(`\nChanges detected:`);
+            if (diff.addedTables.length > 0) {
+                this.logger.info(`  Added tables: ${diff.addedTables.map(__assignType(t => t.name, ['t', '', 'P"2!"/"'])).join(', ')}`);
+            }
+            if (diff.removedTables.length > 0) {
+                this.logger.info(`  Removed tables: ${diff.removedTables.map(__assignType(t => t.name, ['t', '', 'P"2!"/"'])).join(', ')}`);
+            }
+            for (const table of diff.modifiedTables) {
+                const changes = [];
+                if (table.addedColumns.length > 0)
+                    changes.push(`+${table.addedColumns.length} cols`);
+                if (table.removedColumns.length > 0)
+                    changes.push(`-${table.removedColumns.length} cols`);
+                if (table.modifiedColumns.length > 0)
+                    changes.push(`~${table.modifiedColumns.length} cols`);
+                if (table.renamedColumns.length > 0)
+                    changes.push(`${table.renamedColumns.length} renamed`);
+                if (table.addedIndexes.length > 0)
+                    changes.push(`+${table.addedIndexes.length} idx`);
+                if (table.removedIndexes.length > 0)
+                    changes.push(`-${table.removedIndexes.length} idx`);
+                if (table.primaryKeyChanged)
+                    changes.push('PK changed');
+                this.logger.info(`  ${table.tableName}: ${changes.join(', ')}`);
+            }
+            this.logger.info(`\nDDL statements (${statements.length}):`);
+            for (const stmt of statements) {
+                this.logger.info(`  ${stmt}`);
+            }
+            // Step 7: Prompt for description and generate file
+            const description = await (0, prompt_1.promptMigrationDescription)();
+            const filePath = (0, file_generator_1.generateMigrationFile)(statements, description);
+            this.logger.info(`\nMigration file created: ${filePath}`);
+        }
+        finally {
+            (0, prompt_1.setNonInteractive)(false);
+        }
+    }
+};
+exports.MigrationCreateCommand = MigrationCreateCommand;
+MigrationCreateCommand.__type = ['logger', function () { return (0, services_1.createLogger)('MigrationCreate'); }, () => state_1.DBProvider, 'dbProvider', 'constructor', () => __ΩFlag, "Skip interactive prompts", 'description', 'nonInteractive', () => false, 'execute', 'MigrationCreateCommand', '!3!;>"PP7#2$;"0%PP)P.\'4(Mo&"K2)>*"0+5w,'];
+exports.MigrationCreateCommand = MigrationCreateCommand = tslib_1.__decorate([
+    app_1.cli.controller('migration:create'),
+    tslib_1.__metadata("design:paramtypes", [state_1.DBProvider])
+], MigrationCreateCommand);
+//# sourceMappingURL=MigrationCreateCommand.js.map

package/dist/src/database/migration/create/MigrationCreateCommand.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MigrationCreateCommand.js","sourceRoot":"","sources":["../../../../../src/database/migration/create/MigrationCreateCommand.ts"],"names":[],"mappings":"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"}

package/dist/src/database/migration/create/comparator.d.ts

@@ -0,0 +1,3 @@
+import { DatabaseSchema, Dialect, SchemaDiff } from './schema-model';
+export declare function compareSchemas(entitySchema: DatabaseSchema, dbSchema: DatabaseSchema, dialect: Dialect, interactive: boolean, pgSchema?: string): Promise<SchemaDiff>;
+//# sourceMappingURL=comparator.d.ts.map

package/dist/src/database/migration/create/comparator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"comparator.d.ts","sourceRoot":"","sources":["../../../../../src/database/migration/create/comparator.ts"],"names":[],"mappings":"AAAA,OAAO,EAGH,cAAc,EACd,OAAO,EAGP,UAAU,EAGb,MAAM,gBAAgB,CAAC;AAGxB,wBAAsB,cAAc,CAChC,YAAY,EAAE,cAAc,EAC5B,QAAQ,EAAE,cAAc,EACxB,OAAO,EAAE,OAAO,EAChB,WAAW,EAAE,OAAO,EACpB,QAAQ,CAAC,EAAE,MAAM,GAClB,OAAO,CAAC,UAAU,CAAC,CA4CrB"}

package/dist/src/database/migration/create/comparator.js

@@ -0,0 +1,408 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.compareSchemas = compareSchemas;
+function __assignType(fn, args) {
+    fn.__type = args;
+    return fn;
+}
+/*@ts-ignore*/
+var { __ΩDatabaseSchema, __ΩDialect, __ΩSchemaDiff, __ΩTableSchema, __ΩTableDiff, __ΩColumnSchema, __ΩColumnModification, __ΩIndexSchema, __ΩForeignKeySchema } = require('./schema-model');
+const prompt_1 = require("./prompt");
+async function compareSchemas(entitySchema, dbSchema, dialect, interactive, pgSchema) {
+    const addedTables = [];
+    const removedTables = [];
+    const modifiedTables = [];
+    // Find added tables (in entities but not in DB)
+    for (const [name, table] of entitySchema) {
+        if (!dbSchema.has(name)) {
+            addedTables.push(table);
+        }
+    }
+    // Find removed tables (in DB but not in entities)
+    for (const [name, table] of dbSchema) {
+        if (!entitySchema.has(name)) {
+            removedTables.push(table);
+        }
+    }
+    // Compare matching tables
+    for (const [name, entityTable] of entitySchema) {
+        const dbTable = dbSchema.get(name);
+        if (!dbTable)
+            continue;
+        const diff = await compareTable(entityTable, dbTable, dialect, interactive);
+        if (diff) {
+            modifiedTables.push(diff);
+        }
+    }
+    // Collect all enum type names from entity tables (for safe PG DROP TYPE filtering)
+    let entityEnumTypes;
+    if (dialect === 'postgres') {
+        entityEnumTypes = (Set.Ω = [['&']], new Set());
+        for (const table of entitySchema.values()) {
+            for (const col of table.columns) {
+                if (col.type === 'enum' && col.enumTypeName) {
+                    entityEnumTypes.add(col.enumTypeName);
+                }
+            }
+        }
+    }
+    return { dialect, pgSchema, addedTables, removedTables, modifiedTables, entityEnumTypes };
+}
+compareSchemas.__type = [() => __ΩDatabaseSchema, 'entitySchema', () => __ΩDatabaseSchema, 'dbSchema', () => __ΩDialect, 'dialect', 'interactive', 'pgSchema', () => __ΩSchemaDiff, 'compareSchemas', 'Pn!2"n#2$n%2&)2\'&2(8n)`/*'];
+async function compareTable(entityTable, dbTable, dialect, interactive) {
+    const diff = {
+        tableName: entityTable.name,
+        addedColumns: [],
+        removedColumns: [],
+        modifiedColumns: [],
+        renamedColumns: [],
+        reorderedColumns: [],
+        addedIndexes: [],
+        removedIndexes: [],
+        addedForeignKeys: [],
+        removedForeignKeys: [],
+        primaryKeyChanged: false,
+        addedEnumTypes: [],
+        removedEnumTypes: [],
+        modifiedEnumTypes: [],
+        entityColumns: entityTable.columns
+    };
+    // --- Columns ---
+    const entityColMap = new Map(entityTable.columns.map(__assignType(c => [c.name, c], ['c', '', 'P"2!"/"'])));
+    const dbColMap = new Map(dbTable.columns.map(__assignType(c => [c.name, c], ['c', '', 'P"2!"/"'])));
+    let candidateAdds = entityTable.columns.filter(__assignType(c => !dbColMap.has(c.name), ['c', '', 'P"2!"/"']));
+    let candidateDrops = dbTable.columns.filter(__assignType(c => !entityColMap.has(c.name) && !entityTable.skippedColumns?.has(c.name), ['c', '', 'P"2!"/"']));
+    // Rename detection
+    if (candidateAdds.length > 0 && candidateDrops.length > 0) {
+        if (interactive) {
+            const renames = await detectRenames(entityTable.name, candidateAdds, candidateDrops);
+            for (const rename of renames) {
+                diff.renamedColumns.push(rename);
+                candidateAdds = candidateAdds.filter(__assignType(c => c.name !== rename.to, ['c', '', 'P"2!"/"']));
+                candidateDrops = candidateDrops.filter(__assignType(c => c.name !== rename.from, ['c', '', 'P"2!"/"']));
+            }
+        }
+        else {
+            console.warn(`Warning: Table \`${entityTable.name}\` has columns added (${candidateAdds.map(__assignType(c => c.name, ['c', '', 'P"2!"/"'])).join(', ')}) ` +
+                `and removed (${candidateDrops.map(__assignType(c => c.name, ['c', '', 'P"2!"/"'])).join(', ')}). ` +
+                `In non-interactive mode, these are treated as separate DROP/ADD operations (potential data loss). ` +
+                `Run without --non-interactive to detect renames.`);
+        }
+    }
+    diff.addedColumns = candidateAdds;
+    diff.removedColumns = candidateDrops;
+    // Modified columns (present in both by same name)
+    for (const [name, entityCol] of entityColMap) {
+        const dbCol = dbColMap.get(name);
+        if (!dbCol)
+            continue;
+        const mod = compareColumn(entityCol, dbCol);
+        if (mod)
+            diff.modifiedColumns.push(mod);
+    }
+    // Renamed columns may also have property changes (type, nullable, default, etc.)
+    // For MySQL, CHANGE COLUMN already includes the full new definition so these are handled.
+    // For PG, RENAME COLUMN only renames — separate ALTER COLUMN statements are needed.
+    for (const rename of diff.renamedColumns) {
+        const dbCol = dbColMap.get(rename.from);
+        if (!dbCol)
+            continue;
+        const mod = compareColumn(rename.column, dbCol);
+        if (mod)
+            diff.modifiedColumns.push(mod);
+    }
+    // Column reordering (MySQL only)
+    if (dialect === 'mysql') {
+        diff.reorderedColumns = detectReorderingMySQL(entityTable, dbTable, diff);
+    }
+    // --- Primary Key ---
+    const entityPK = entityTable.columns.filter(__assignType(c => c.isPrimaryKey, ['c', '', 'P"2!"/"'])).map(__assignType(c => c.name, ['c', '', 'P"2!"/"']));
+    const rawDbPK = dbTable.columns.filter(__assignType(c => c.isPrimaryKey, ['c', '', 'P"2!"/"'])).map(__assignType(c => c.name, ['c', '', 'P"2!"/"']));
+    // Apply rename mappings to DB PK names so that pure PK column renames
+    // are not falsely detected as PK changes
+    const renamedFromToMap = new Map(diff.renamedColumns.map(__assignType(r => [r.from, r.to], ['r', '', 'P"2!"/"'])));
+    const dbPK = rawDbPK.map(__assignType(name => renamedFromToMap.get(name) ?? name, ['name', '', 'P"2!"/"']));
+    if (!arraysEqual(entityPK, dbPK)) {
+        diff.primaryKeyChanged = true;
+        diff.newPrimaryKey = entityPK;
+        // Store the raw DB column names (before rename mapping) so that DDL generation
+        // can reference columns by their current DB names when stripping AUTO_INCREMENT
+        // before DROP PRIMARY KEY (which happens before CHANGE COLUMN renames).
+        diff.oldPrimaryKey = rawDbPK;
+        diff.oldPrimaryKeyConstraintName = dbTable.primaryKeyConstraintName;
+    }
+    // --- Indexes ---
+    const { added: addedIdx, removed: removedIdx } = compareIndexes(entityTable.indexes, dbTable.indexes);
+    diff.addedIndexes = addedIdx;
+    diff.removedIndexes = removedIdx;
+    // --- Foreign Keys ---
+    const { added: addedFK, removed: removedFK } = compareForeignKeys(entityTable.foreignKeys, dbTable.foreignKeys);
+    diff.addedForeignKeys = addedFK;
+    diff.removedForeignKeys = removedFK;
+    // --- Enum types (PG only) ---
+    if (dialect === 'postgres') {
+        detectEnumChanges(diff, entityTable, dbTable);
+    }
+    // Check if there are any actual changes
+    if (diff.addedColumns.length === 0 &&
+        diff.removedColumns.length === 0 &&
+        diff.modifiedColumns.length === 0 &&
+        diff.renamedColumns.length === 0 &&
+        diff.reorderedColumns.length === 0 &&
+        diff.addedIndexes.length === 0 &&
+        diff.removedIndexes.length === 0 &&
+        diff.addedForeignKeys.length === 0 &&
+        diff.removedForeignKeys.length === 0 &&
+        !diff.primaryKeyChanged &&
+        diff.addedEnumTypes.length === 0 &&
+        diff.removedEnumTypes.length === 0 &&
+        diff.modifiedEnumTypes.length === 0) {
+        return null;
+    }
+    return diff;
+}
+compareTable.__type = [() => __ΩTableSchema, 'entityTable', () => __ΩTableSchema, 'dbTable', () => __ΩDialect, 'dialect', 'interactive', () => __ΩTableDiff, 'compareTable', 'Pn!2"n#2$n%2&)2\'Pn(,J`/)'];
+function compareColumn(entityCol, dbCol) {
+    const typeChanged = !typesMatch(entityCol, dbCol);
+    const nullableChanged = entityCol.nullable !== dbCol.nullable;
+    const defaultChanged = !defaultsMatch(entityCol, dbCol);
+    const autoIncrementChanged = entityCol.autoIncrement !== dbCol.autoIncrement;
+    // ON UPDATE expression (MySQL only). If entity side has no onUpdateExpression, treat as "remove it".
+    const onUpdateChanged = (entityCol.onUpdateExpression || '') !== (dbCol.onUpdateExpression || '');
+    if (!typeChanged && !nullableChanged && !defaultChanged && !autoIncrementChanged && !onUpdateChanged) {
+        return null;
+    }
+    return {
+        name: entityCol.name,
+        oldColumn: dbCol,
+        newColumn: entityCol,
+        typeChanged,
+        nullableChanged,
+        defaultChanged,
+        autoIncrementChanged,
+        onUpdateChanged
+    };
+}
+compareColumn.__type = [() => __ΩColumnSchema, 'entityCol', () => __ΩColumnSchema, 'dbCol', () => __ΩColumnModification, 'compareColumn', 'Pn!2"n#2$Pn%,J/&'];
+function normalizeTypeAlias(type) {
+    switch (type) {
+        case 'integer':
+            return 'int';
+        case 'numeric':
+            return 'decimal';
+        default:
+            return type;
+    }
+}
+normalizeTypeAlias.__type = ['type', 'normalizeTypeAlias', 'P&2!&/"'];
+function typesMatch(a, b) {
+    if (normalizeTypeAlias(a.type) !== normalizeTypeAlias(b.type))
+        return false;
+    // Compare size when relevant
+    if (a.size !== undefined || b.size !== undefined) {
+        if (a.size !== b.size)
+            return false;
+    }
+    // Compare scale
+    if (a.scale !== undefined || b.scale !== undefined) {
+        if (a.scale !== b.scale)
+            return false;
+    }
+    // Compare unsigned
+    if (a.unsigned !== b.unsigned)
+        return false;
+    // Compare enum type name (PG)
+    if (a.enumTypeName || b.enumTypeName) {
+        if (a.enumTypeName !== b.enumTypeName)
+            return false;
+    }
+    // Compare enum values (sorted to ignore order-only differences)
+    if (a.enumValues || b.enumValues) {
+        const aVals = [...(a.enumValues || [])].sort();
+        const bVals = [...(b.enumValues || [])].sort();
+        if (!arraysEqual(aVals, bVals))
+            return false;
+    }
+    return true;
+}
+typesMatch.__type = [() => __ΩColumnSchema, 'a', () => __ΩColumnSchema, 'b', 'typesMatch', 'Pn!2"n#2$)/%'];
+function normalizeDefaultExpression(expr) {
+    let s = expr.toUpperCase().trim();
+    // Normalize now() and CURRENT_TIMESTAMP() variants to CURRENT_TIMESTAMP (no parens)
+    s = s.replace(/\bNOW\s*\(\)/g, 'CURRENT_TIMESTAMP');
+    s = s.replace(/\bCURRENT_TIMESTAMP\s*\(\)/g, 'CURRENT_TIMESTAMP');
+    return s;
+}
+normalizeDefaultExpression.__type = ['expr', 'normalizeDefaultExpression', 'P&2!&/"'];
+function defaultsMatch(a, b) {
+    // Skip default comparison for auto-increment columns
+    if (a.autoIncrement || b.autoIncrement)
+        return true;
+    // If entity side has no default info at all, treat as "unspecified" and skip comparison.
+    // The entity reader does not populate default values from Deepkit metadata.
+    if (a.defaultValue === undefined && a.defaultExpression === undefined)
+        return true;
+    // Both have expression defaults
+    if (a.defaultExpression && b.defaultExpression) {
+        return normalizeDefaultExpression(a.defaultExpression) === normalizeDefaultExpression(b.defaultExpression);
+    }
+    // One has expression, other doesn't
+    if (a.defaultExpression !== b.defaultExpression) {
+        if ((a.defaultExpression && !b.defaultExpression) || (!a.defaultExpression && b.defaultExpression)) {
+            return false;
+        }
+    }
+    // Compare values
+    if (a.defaultValue === undefined && b.defaultValue === undefined)
+        return true;
+    if (a.defaultValue === undefined || b.defaultValue === undefined)
+        return false;
+    return String(a.defaultValue) === String(b.defaultValue);
+}
+defaultsMatch.__type = [() => __ΩColumnSchema, 'a', () => __ΩColumnSchema, 'b', 'defaultsMatch', 'Pn!2"n#2$)/%'];
+async function detectRenames(tableName, candidateAdds, candidateDrops) {
+    const renames = [];
+    let remainingDrops = [...candidateDrops];
+    for (const added of candidateAdds) {
+        // Prefer exact type matches
+        let compatibleDrops = remainingDrops.filter(__assignType(d => typesMatch(added, d), ['d', '', 'P"2!"/"']));
+        // Fall back to all remaining drops (type differs — prompt will warn)
+        if (compatibleDrops.length === 0 && remainingDrops.length > 0) {
+            compatibleDrops = remainingDrops;
+        }
+        if (compatibleDrops.length === 0)
+            continue;
+        const result = await (0, prompt_1.promptRename)(tableName, added.name, compatibleDrops.map(__assignType(d => d.name, ['d', '', 'P"2!"/"'])));
+        if (result) {
+            renames.push({ from: result, to: added.name, column: added });
+            remainingDrops = remainingDrops.filter(__assignType(d => d.name !== result, ['d', '', 'P"2!"/"']));
+        }
+    }
+    return renames;
+}
+detectRenames.__type = ['tableName', () => __ΩColumnSchema, 'candidateAdds', () => __ΩColumnSchema, 'candidateDrops', 'from', 'to', () => __ΩColumnSchema, 'column', 'detectRenames', 'P&2!n"F2#n$F2%P&4&&4\'n(4)MF`/*'];
+function detectReorderingMySQL(entityTable, dbTable, diff) {
+    // Build the expected column order from the entity
+    const entityOrder = entityTable.columns.map(__assignType(c => c.name, ['c', '', 'P"2!"/"']));
+    // Build the current DB order, accounting for adds/drops/renames
+    const renamedFrom = new Map(diff.renamedColumns.map(__assignType(r => [r.from, r.to], ['r', '', 'P"2!"/"'])));
+    const removedNames = new Set(diff.removedColumns.map(__assignType(c => c.name, ['c', '', 'P"2!"/"'])));
+    const addedNames = new Set(diff.addedColumns.map(__assignType(c => c.name, ['c', '', 'P"2!"/"'])));
+    // Current DB order with renames applied and removals excluded
+    const dbOrder = dbTable.columns.map(__assignType(c => renamedFrom.get(c.name) || c.name, ['c', '', 'P"2!"/"'])).filter(__assignType(name => !removedNames.has(name), ['name', '', 'P"2!"/"']));
+    // Entity order without new additions (the columns that should be in DB order)
+    const existingEntityOrder = entityOrder.filter(__assignType(name => !addedNames.has(name), ['name', '', 'P"2!"/"']));
+    // Check if the existing columns are in the same relative order
+    if (arraysEqual(existingEntityOrder, dbOrder)) {
+        return [];
+    }
+    // Compute which columns need MODIFY with AFTER
+    const reorders = [];
+    for (let i = 0; i < existingEntityOrder.length; i++) {
+        if (existingEntityOrder[i] !== dbOrder[i]) {
+            const after = i === 0 ? null : existingEntityOrder[i - 1];
+            reorders.push({ name: existingEntityOrder[i], after });
+        }
+    }
+    return reorders;
+}
+detectReorderingMySQL.__type = [() => __ΩTableSchema, 'entityTable', () => __ΩTableSchema, 'dbTable', () => __ΩTableDiff, 'diff', 'name', 'after', 'detectReorderingMySQL', 'Pn!2"n#2$n%2&P&4\'P&,J4(MF/)'];
+function compareIndexes(entityIndexes, dbIndexes) {
+    // Match by column set + uniqueness + spatial, not by name
+    const indexKey = __assignType((idx) => `${idx.columns.join(',')}:${idx.unique}:${idx.spatial}`, [() => __ΩIndexSchema, 'idx', '', 'Pn!2""/#']);
+    const entityKeys = new Map(entityIndexes.map(__assignType(i => [indexKey(i), i], ['i', '', 'P"2!"/"'])));
+    const dbKeys = new Map(dbIndexes.map(__assignType(i => [indexKey(i), i], ['i', '', 'P"2!"/"'])));
+    const added = entityIndexes.filter(__assignType(i => !dbKeys.has(indexKey(i)), ['i', '', 'P"2!"/"']));
+    const removed = dbIndexes.filter(__assignType(i => !entityKeys.has(indexKey(i)), ['i', '', 'P"2!"/"']));
+    return { added, removed };
+}
+compareIndexes.__type = [() => __ΩIndexSchema, 'entityIndexes', () => __ΩIndexSchema, 'dbIndexes', () => __ΩIndexSchema, 'added', () => __ΩIndexSchema, 'removed', 'compareIndexes', 'Pn!F2"n#F2$Pn%F4&n\'F4(M/)'];
+function normalizeFkAction(action) {
+    const upper = action.toUpperCase();
+    // NO ACTION and RESTRICT are semantically equivalent for comparison
+    return upper === 'NO ACTION' ? 'RESTRICT' : upper;
+}
+normalizeFkAction.__type = ['action', 'normalizeFkAction', 'P&2!&/"'];
+function compareForeignKeys(entityFKs, dbFKs) {
+    // Match by structure including actions, not by name
+    // NO ACTION and RESTRICT are treated as equivalent to avoid diff churn
+    const fkKey = __assignType((fk) => `${fk.columns.join(',')}→${fk.referencedTable}(${fk.referencedColumns.join(',')})/${normalizeFkAction(fk.onDelete)}/${normalizeFkAction(fk.onUpdate)}`, [() => __ΩForeignKeySchema, 'fk', '', 'Pn!2""/#']);
+    const entityKeys = new Map(entityFKs.map(__assignType(fk => [fkKey(fk), fk], ['fk', '', 'P"2!"/"'])));
+    const dbKeys = new Map(dbFKs.map(__assignType(fk => [fkKey(fk), fk], ['fk', '', 'P"2!"/"'])));
+    const added = entityFKs.filter(__assignType(fk => !dbKeys.has(fkKey(fk)), ['fk', '', 'P"2!"/"']));
+    const removed = dbFKs.filter(__assignType(fk => !entityKeys.has(fkKey(fk)), ['fk', '', 'P"2!"/"']));
+    return { added, removed };
+}
+compareForeignKeys.__type = [() => __ΩForeignKeySchema, 'entityFKs', () => __ΩForeignKeySchema, 'dbFKs', () => __ΩForeignKeySchema, 'added', () => __ΩForeignKeySchema, 'removed', 'compareForeignKeys', 'Pn!F2"n#F2$Pn%F4&n\'F4(M/)'];
+function detectEnumChanges(diff, entityTable, dbTable) {
+    const dbColMap = new Map(dbTable.columns.map(__assignType(c => [c.name, c], ['c', '', 'P"2!"/"'])));
+    for (const col of entityTable.columns) {
+        if (col.type !== 'enum' || !col.enumValues || !col.enumTypeName)
+            continue;
+        const dbCol = dbColMap.get(col.name);
+        // New enum type for new columns
+        if (!dbCol) {
+            diff.addedEnumTypes.push({
+                typeName: col.enumTypeName,
+                values: col.enumValues
+            });
+            continue;
+        }
+        // Existing column: non-enum → enum requires CREATE TYPE
+        if (dbCol.type !== 'enum') {
+            diff.addedEnumTypes.push({
+                typeName: col.enumTypeName,
+                values: col.enumValues
+            });
+            continue;
+        }
+        // Enum type name changed — need to create the new type and drop the old one
+        if (dbCol.enumTypeName && dbCol.enumTypeName !== col.enumTypeName) {
+            diff.addedEnumTypes.push({
+                typeName: col.enumTypeName,
+                values: col.enumValues
+            });
+            diff.removedEnumTypes.push(dbCol.enumTypeName);
+            // The type change will be picked up by compareColumn() → typesMatch() → enumTypeName comparison
+            continue;
+        }
+        // Existing column with enum value changes (same type name)
+        if (dbCol.enumValues) {
+            const added = col.enumValues.filter(__assignType(v => !dbCol.enumValues.includes(v), ['v', '', 'P"2!"/"']));
+            const removed = dbCol.enumValues.filter(__assignType(v => !col.enumValues.includes(v), ['v', '', 'P"2!"/"']));
+            if (added.length > 0 || removed.length > 0) {
+                diff.modifiedEnumTypes.push({
+                    typeName: col.enumTypeName,
+                    added,
+                    removed,
+                    newValues: col.enumValues,
+                    tableName: diff.tableName,
+                    columnName: col.name
+                });
+            }
+        }
+    }
+    // Detect orphaned enum types from removed columns or enum→non-enum changes
+    const entityColMap = new Map(entityTable.columns.map(__assignType(c => [c.name, c], ['c', '', 'P"2!"/"'])));
+    for (const dbCol of dbTable.columns) {
+        if (dbCol.type !== 'enum' || !dbCol.enumTypeName)
+            continue;
+        const entityCol = entityColMap.get(dbCol.name);
+        // Column removed entirely — its enum type may be orphaned
+        // Column changed from enum to non-enum — old type may be orphaned
+        if (!entityCol || entityCol.type !== 'enum' || entityCol.enumTypeName !== dbCol.enumTypeName) {
+            // Only schedule drop if not already handled above (type-name change already pushes to removedEnumTypes)
+            if (!diff.removedEnumTypes.includes(dbCol.enumTypeName)) {
+                diff.removedEnumTypes.push(dbCol.enumTypeName);
+            }
+        }
+    }
+}
+detectEnumChanges.__type = [() => __ΩTableDiff, 'diff', () => __ΩTableSchema, 'entityTable', () => __ΩTableSchema, 'dbTable', 'detectEnumChanges', 'Pn!2"n#2$n%2&$/\''];
+function arraysEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    return a.every(__assignType((v, i) => v === b[i], ['v', 'i', '', 'P"2!"2""/#']));
+}
+arraysEqual.__type = ['a', 'b', 'arraysEqual', 'P"F2!"F2")/#'];
+//# sourceMappingURL=comparator.js.map