@zyno-io/dk-server-foundation 26.412.2137 → 26.601.2229

package/src/database/factory.ts

@@ -0,0 +1,59 @@
+import { ClassType } from '@deepkit/core';
+import { Database } from '@deepkit/orm';
+
+import { BaseDatabase } from './common';
+import { Dialect } from './dialect';
+import { createMySQLDatabase, IMySQLDatabaseAdapterConfig, MySQLDatabaseAdapter } from './mysql';
+import { createPostgresDatabase, IPostgresDatabaseAdapterConfig, PostgresDatabaseAdapter } from './postgres';
+
+export type AnyDatabaseAdapter = MySQLDatabaseAdapter | PostgresDatabaseAdapter;
+
+export interface ICommonDatabaseAdapterConfig {
+    enableLocksTable?: boolean;
+}
+
+type Entities = ConstructorParameters<typeof Database>[1];
+
+export function createDatabase(config: ICommonDatabaseAdapterConfig, entities?: Entities): ClassType<BaseDatabase<AnyDatabaseAdapter>>;
+export function createDatabase(
+    dialect: 'mysql',
+    config: IMySQLDatabaseAdapterConfig,
+    entities?: Entities
+): ClassType<BaseDatabase<MySQLDatabaseAdapter>>;
+export function createDatabase(
+    dialect: 'postgres',
+    config: IPostgresDatabaseAdapterConfig,
+    entities?: Entities
+): ClassType<BaseDatabase<PostgresDatabaseAdapter>>;
+export function createDatabase(
+    dialectOrConfig: Dialect | ICommonDatabaseAdapterConfig,
+    configOrEntities?: IMySQLDatabaseAdapterConfig | IPostgresDatabaseAdapterConfig | Entities,
+    maybeEntities?: Entities
+): ClassType<BaseDatabase<AnyDatabaseAdapter>> {
+    let dialect: Dialect;
+    let config: IMySQLDatabaseAdapterConfig | IPostgresDatabaseAdapterConfig;
+    let entities: Entities;
+
+    if (typeof dialectOrConfig === 'string') {
+        dialect = dialectOrConfig;
+        config = configOrEntities as IMySQLDatabaseAdapterConfig | IPostgresDatabaseAdapterConfig;
+        entities = maybeEntities ?? [];
+    } else {
+        dialect = resolveDialectFromEnv();
+        config = dialectOrConfig;
+        entities = (configOrEntities as Entities | undefined) ?? [];
+    }
+
+    return dialect === 'postgres'
+        ? createPostgresDatabase(config as IPostgresDatabaseAdapterConfig, entities)
+        : createMySQLDatabase(config as IMySQLDatabaseAdapterConfig, entities);
+}
+
+function resolveDialectFromEnv(): Dialect {
+    const value = process.env.DB_ADAPTER;
+    if (value === 'mysql' || value === 'postgres') return value;
+    throw new Error(
+        `createDatabase(sharedConfig) requires the DB_ADAPTER env var to be 'mysql' or 'postgres' (got: ${value ?? 'undefined'}). ` +
+            `Either set DB_ADAPTER or call createDatabase(dialect, config) explicitly.`
+    );
+}

package/src/database/index.ts

@@ -1,7 +1,9 @@
 export * from './common';
 export * from './dialect';
 export * from './entity';
+export * from './factory';
 export { createMigration, runMigrations, standardizeDbCollation } from './migration';
+export * from './schema';
 export * from './mysql';
 export * from './postgres';
 export * from './types';

package/src/database/migration/MigrationResetCommand.ts

@@ -3,14 +3,11 @@ import { SQLDatabaseAdapter } from '@deepkit/sql';
 import { existsSync, mkdirSync, readdirSync, unlinkSync, writeFileSync } from 'fs';
 import path from 'path';
 
-import { getAppConfig } from '../../app/resolver';
 import { DBProvider } from '../../app/state';
 import { createLogger } from '../../services';
 import { getDialect } from '../dialect';
-import { generateDDL } from './create/ddl-generator';
+import { generateBuilderMigrationFile } from './create/builder-regenerator';
 import { readEntitiesSchema } from './create/entity-reader';
-import { buildFileContent } from './create/file-generator';
-import { SchemaDiff } from './create/schema-model';
 import { getSourceMigrationsDir } from './helpers';
 
 @cli.controller('migration:reset')
@@ -21,13 +18,11 @@ export class MigrationResetCommand {
     constructor(private dbProvider: DBProvider) {}
 
     async execute() {
-        // Step 1: Ensure migrations directory exists
         if (!existsSync(this.migrationsDir)) {
             this.logger.info(`Creating migrations directory: ${this.migrationsDir}`);
             mkdirSync(this.migrationsDir, { recursive: true });
         }
 
-        // Step 2: Remove all .ts files from migrations directory
         const files = readdirSync(this.migrationsDir).filter(f => f.endsWith('.ts'));
         this.logger.info(`Removing ${files.length} migration file(s)`);
         for (const file of files) {
@@ -36,33 +31,22 @@ export class MigrationResetCommand {
             this.logger.info(`Removed ${file}`);
         }
 
-        // Step 3: Read entity schema from code definitions
         const db = this.dbProvider.db;
         const dialect = getDialect(db.adapter as SQLDatabaseAdapter);
-        const pgSchema = dialect === 'postgres' ? (getAppConfig().PG_SCHEMA ?? 'public') : 'public';
 
-        this.logger.info('Reading entity definitions...');
+        // Reset reads entities in the active dialect's canonical form. The generated migration uses
+        // dialect-portable builder calls, but cross-dialect parity isn't perfect — see docs.
+        this.logger.info(`Reading entity definitions (dialect: ${dialect})...`);
         const entitySchema = readEntitiesSchema(db, dialect);
         const tables = Array.from(entitySchema.values());
         this.logger.info(`Found ${tables.length} entity table(s)`);
 
-        // Step 4: Generate DDL by treating all entity tables as "added"
-        const diff: SchemaDiff = {
-            dialect,
-            pgSchema: dialect === 'postgres' ? pgSchema : undefined,
-            addedTables: tables,
-            removedTables: [],
-            modifiedTables: []
-        };
-        const statements = generateDDL(diff);
-
-        if (statements.length === 0) {
+        if (tables.length === 0) {
             this.logger.info('No tables found to generate base migration.');
             return;
         }
 
-        // Step 6: Write migration file
-        const migrationContent = buildFileContent(statements);
+        const migrationContent = generateBuilderMigrationFile(tables);
         const migrationPath = path.join(this.migrationsDir, '00000000_000000_base.ts');
 
         writeFileSync(migrationPath, migrationContent, 'utf8');

package/src/database/migration/MigrationRunCommand.ts

@@ -110,6 +110,8 @@ export class MigrationRunCommand {
 
         try {
             await migrationModule.default(this.dbProvider.db);
+            // Apply deferred schema-builder statements (FKs) and reset per-migration state.
+            await this.dbProvider.db.schema.flush();
         } catch (err) {
             this.logger.error('Migration function failed to execute', err, { file });
             throw err;

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

@@ -5,11 +5,12 @@ import { getAppConfig } from '../../../app/resolver';
 import { DBProvider } from '../../../app/state';
 import { createLogger, pinoLogger } from '../../../services';
 import { getDialect } from '../../dialect';
+import { generateBuilderMigrationFromDiff } from './builder-regenerator';
 import { compareSchemas } from './comparator';
 import { readAllTableNames, readDatabaseSchema } from './db-reader';
 import { generateDDL } from './ddl-generator';
 import { readEntitiesSchema } from './entity-reader';
-import { generateMigrationFile } from './file-generator';
+import { generateMigrationFile, writeMigrationFile } from './file-generator';
 import { promptMigrationDescription, setNonInteractive } from './prompt';
 import { INTERNAL_TABLES } from './schema-model';
 
@@ -19,7 +20,10 @@ export class MigrationCreateCommand {
 
     constructor(private dbProvider: DBProvider) {}
 
-    async execute(nonInteractive: boolean & Flag<{ description: 'Skip interactive prompts' }> = false) {
+    async execute(
+        nonInteractive: boolean & Flag<{ description: 'Skip interactive prompts' }> = false,
+        raw: boolean & Flag<{ description: 'Emit raw dialect-specific SQL instead of dialect-portable schema-builder calls' }> = false
+    ) {
         if (nonInteractive) {
             setNonInteractive(true);
         }
@@ -50,10 +54,28 @@ export class MigrationCreateCommand {
             this.logger.info('Comparing schemas...');
             const diff = await compareSchemas(entitySchema, dbSchema, dialect, !nonInteractive, pgSchema);
 
-            // Step 5: Generate DDL
-            const statements = generateDDL(diff);
+            // Step 5: Decide if there are any changes
+            const hasChanges =
+                diff.addedTables.length > 0 ||
+                diff.removedTables.length > 0 ||
+                diff.modifiedTables.some(
+                    t =>
+                        t.addedColumns.length > 0 ||
+                        t.removedColumns.length > 0 ||
+                        t.modifiedColumns.length > 0 ||
+                        t.renamedColumns.length > 0 ||
+                        t.addedIndexes.length > 0 ||
+                        t.removedIndexes.length > 0 ||
+                        t.renamedIndexes.length > 0 ||
+                        t.addedForeignKeys.length > 0 ||
+                        t.removedForeignKeys.length > 0 ||
+                        t.primaryKeyChanged ||
+                        t.addedEnumTypes.length > 0 ||
+                        t.removedEnumTypes.length > 0 ||
+                        t.modifiedEnumTypes.length > 0
+                );
 
-            if (statements.length === 0) {
+            if (!hasChanges) {
                 this.logger.info('No schema changes detected.');
                 return;
             }
@@ -74,20 +96,28 @@ export class MigrationCreateCommand {
                 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.renamedIndexes.length > 0) changes.push(`~${table.renamedIndexes.length} idx name`);
                 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
+            // Step 7: Render migration content (builder by default; --raw for legacy SQL)
+            let filePath: string;
             pinoLogger.flush();
             await new Promise(resolve => setTimeout(resolve, 100));
             const description = await promptMigrationDescription();
-            const filePath = generateMigrationFile(statements, description);
+
+            if (raw) {
+                const statements = generateDDL(diff);
+                this.logger.info(`\nDDL statements (${statements.length}):`);
+                for (const stmt of statements) this.logger.info(`  ${stmt}`);
+                filePath = generateMigrationFile(statements, description);
+            } else {
+                const content = generateBuilderMigrationFromDiff(diff);
+                this.logger.info(`\nGenerated builder migration (${content.split('\n').length} lines)`);
+                filePath = writeMigrationFile(content, description);
+            }
+
             this.logger.info(`\nMigration file created: ${filePath}`);
         } finally {
             setNonInteractive(false);

package/src/database/migration/create/builder-regenerator.ts

@@ -0,0 +1,294 @@
+import { ColumnSchema, Dialect, ForeignKeySchema, IndexSchema, SchemaDiff, TableDiff, TableSchema } from './schema-model';
+
+const FILE_HEADER = `import { createMigration } from '@zyno-io/dk-server-foundation';\n\nexport default createMigration(async db => {\n`;
+const FILE_FOOTER = `\n});\n`;
+
+/** Render a TypeScript migration file that uses db.schema builder to recreate the given tables. */
+export function generateBuilderMigrationFile(tables: TableSchema[]): string {
+    const blocks = tables.map(t => renderTableBlock(t));
+    return `${FILE_HEADER}${blocks.join('\n\n')}${FILE_FOOTER}`;
+}
+
+/**
+ * Render a TypeScript migration file from a SchemaDiff. Used by migration:create to emit
+ * portable builder-based migrations.
+ *
+ * Order: drop removed tables → create added tables → alter modified tables. Within an alter:
+ * Schema.alter() internally orders operations dependency-safe, so emission order doesn't matter.
+ */
+export function generateBuilderMigrationFromDiff(diff: SchemaDiff): string {
+    const blocks: string[] = [];
+
+    for (const table of diff.removedTables) {
+        blocks.push(`    await db.schema.drop(${quoteStr(table.name)});`);
+    }
+
+    for (const table of diff.addedTables) {
+        blocks.push(renderTableBlock(table));
+    }
+
+    for (const tableDiff of diff.modifiedTables) {
+        const block = renderAlterBlock(tableDiff, diff.dialect);
+        if (block) blocks.push(block);
+    }
+
+    if (blocks.length === 0) {
+        return `${FILE_HEADER}    // No schema changes detected.${FILE_FOOTER}`;
+    }
+    return `${FILE_HEADER}${blocks.join('\n\n')}${FILE_FOOTER}`;
+}
+
+function renderAlterBlock(td: TableDiff, dialect: Dialect): string {
+    const preLines: string[] = [];
+    const innerLines: string[] = [];
+    const postLines: string[] = [];
+
+    // PG enum lifecycle (raw SQL — first-class builder support is post-Phase-2)
+    if (dialect === 'postgres') {
+        for (const newType of td.addedEnumTypes) {
+            preLines.push(`    await db.schema.enumType(${quoteStr(newType.typeName)}, [${newType.values.map(quoteStr).join(', ')}]);`);
+        }
+        for (const mod of td.modifiedEnumTypes) {
+            for (const value of mod.added) {
+                preLines.push(
+                    `    await db.schema.raw(${quoteStr(`ALTER TYPE "${mod.typeName}" ADD VALUE IF NOT EXISTS '${value.replace(/'/g, "''")}'`)});`
+                );
+            }
+        }
+        for (const typeName of td.removedEnumTypes) {
+            postLines.push(`    await db.schema.raw(${quoteStr(`DROP CAST IF EXISTS (text AS "${typeName}")`)});`);
+            postLines.push(`    await db.schema.raw(${quoteStr(`DROP TYPE IF EXISTS "${typeName}"`)});`);
+        }
+    }
+
+    // PK changes (drop existing first, replacement comes via .primary())
+    if (td.primaryKeyChanged && td.oldPrimaryKey && td.oldPrimaryKey.length > 0) {
+        innerLines.push(`        t.dropPrimary();`);
+    }
+
+    for (const fk of td.removedForeignKeys) innerLines.push(`        t.dropForeign(${quoteStr(fk.name)});`);
+    for (const idx of td.removedIndexes) innerLines.push(`        t.dropIndex(${quoteStr(idx.name)});`);
+    for (const r of td.renamedIndexes) innerLines.push(`        t.renameIndex(${quoteStr(r.from)}, ${quoteStr(r.to)});`);
+    for (const col of td.removedColumns) innerLines.push(`        t.dropColumn(${quoteStr(col.name)});`);
+    for (const r of td.renamedColumns) innerLines.push(`        t.renameColumn(${quoteStr(r.from)}, ${quoteStr(r.to)});`);
+
+    const stubTable: TableSchema = { name: td.tableName, columns: [], indexes: [], foreignKeys: [] };
+
+    for (const col of td.addedColumns) {
+        let line = renderColumnLine(col, stubTable);
+        // MySQL: if we know the entity-order position, emit .after() / .first() to preserve column layout
+        if (dialect === 'mysql' && td.entityColumns) {
+            const positioning = renderPositioning(col, td.entityColumns, td.addedColumns);
+            if (positioning) line = line.replace(/;$/, `${positioning};`);
+        }
+        innerLines.push(`        ${line}`);
+    }
+    for (const mod of td.modifiedColumns) {
+        // Modified column: render as if adding, append .change()
+        const line = renderColumnLine(mod.newColumn, stubTable);
+        innerLines.push(`        ${line.replace(/;$/, '.change();')}`);
+    }
+
+    if (td.primaryKeyChanged && td.newPrimaryKey && td.newPrimaryKey.length > 0) {
+        innerLines.push(`        t.primary([${td.newPrimaryKey.map(quoteStr).join(', ')}]);`);
+    }
+
+    for (const idx of td.addedIndexes) innerLines.push(`        ${renderIndexLine(idx, stubTable)}`);
+    for (const fk of td.addedForeignKeys) innerLines.push(`        ${renderForeignKeyLine(fk, stubTable)}`);
+
+    if (innerLines.length === 0 && preLines.length === 0 && postLines.length === 0) return '';
+
+    const parts: string[] = [];
+    if (preLines.length > 0) parts.push(preLines.join('\n'));
+    if (innerLines.length > 0) {
+        parts.push(`    await db.schema.alter(${quoteStr(td.tableName)}, t => {\n${innerLines.join('\n')}\n    });`);
+    }
+    if (postLines.length > 0) parts.push(postLines.join('\n'));
+    return parts.join('\n\n');
+}
+
+function renderTableBlock(table: TableSchema): string {
+    const lines: string[] = [];
+
+    for (const col of table.columns) {
+        lines.push(`        ${renderColumnLine(col, table)}`);
+    }
+
+    // Composite PK — single-column PK is emitted via .primary() on the column line
+    const pkCols = table.columns.filter(c => c.isPrimaryKey).map(c => c.name);
+    if (pkCols.length > 1) {
+        lines.push(`        t.primary([${pkCols.map(quoteStr).join(', ')}]);`);
+    }
+
+    for (const idx of table.indexes) {
+        lines.push(`        ${renderIndexLine(idx, table)}`);
+    }
+
+    for (const fk of table.foreignKeys) {
+        lines.push(`        ${renderForeignKeyLine(fk, table)}`);
+    }
+
+    return `    await db.schema.create(${quoteStr(table.name)}, t => {\n${lines.join('\n')}\n    });`;
+}
+
+/** Emit `.after('x')` / `.first()` based on entity-order position of an added column. */
+function renderPositioning(col: ColumnSchema, entityColumns: ColumnSchema[], addedColumns: ColumnSchema[]): string {
+    const idx = entityColumns.findIndex(c => c.name === col.name);
+    if (idx < 0) return '';
+    const addedNames = new Set(addedColumns.map(c => c.name));
+    // Walk backwards to find the previous column that already exists in the DB (not in the same add batch)
+    for (let i = idx - 1; i >= 0; i--) {
+        const prev = entityColumns[i];
+        if (!addedNames.has(prev.name)) return `.after(${quoteStr(prev.name)})`;
+    }
+    return '.first()';
+}
+
+function renderColumnLine(col: ColumnSchema, table: TableSchema): string {
+    let line = `t.${pickBuilderMethod(col)}`;
+
+    // Modifier order chosen to read naturally
+    if (col.unsigned) line += '.unsigned()';
+    if (col.nullable) line += '.nullable()';
+    if (col.autoIncrement) line += '.autoIncrement()';
+
+    const pkCount = table.columns.filter(c => c.isPrimaryKey).length;
+    if (col.isPrimaryKey && pkCount === 1) line += '.primary()';
+
+    if (col.defaultExpression) {
+        line += `.defaultRaw(${quoteStr(col.defaultExpression)})`;
+    } else if (col.defaultValue !== undefined) {
+        line += `.default(${renderJsValue(col.defaultValue)})`;
+    }
+
+    if (col.onUpdateExpression) {
+        line += `.onUpdate(${quoteStr(col.onUpdateExpression)})`;
+    }
+
+    return line + ';';
+}
+
+function pickBuilderMethod(col: ColumnSchema): string {
+    const n = quoteStr(col.name);
+    switch (col.type) {
+        case 'varchar':
+            return `string(${n}, ${col.size ?? 255})`;
+        case 'char':
+            // CHAR(36) is the canonical string-form UUID storage (dksf:uuid annotation)
+            if (col.size === 36) return `uuidString(${n})`;
+            return `char(${n}, ${col.size ?? 1})`;
+        case 'text':
+            return `text(${n})`;
+        case 'tinytext':
+            return `tinyText(${n})`;
+        case 'mediumtext':
+            return `mediumText(${n})`;
+        case 'longtext':
+            return `longText(${n})`;
+        case 'tinyint':
+            // tinyint(1) is the canonical MySQL boolean storage; map back to .boolean()
+            if (col.size === 1) return `boolean(${n})`;
+            return `tinyint(${n})`;
+        case 'smallint':
+            return `smallint(${n})`;
+        case 'int':
+        case 'integer':
+            return `integer(${n})`;
+        case 'bigint':
+            return `bigInteger(${n})`;
+        case 'boolean':
+            return `boolean(${n})`;
+        case 'float':
+        case 'real':
+            return `float(${n})`;
+        case 'double':
+        case 'double precision':
+            return `double(${n})`;
+        case 'decimal':
+        case 'numeric': {
+            const args = [n];
+            if (col.size !== undefined) {
+                args.push(String(col.size));
+                if (col.scale !== undefined) args.push(String(col.scale));
+            }
+            return `decimal(${args.join(', ')})`;
+        }
+        case 'date':
+            return `date(${n})`;
+        case 'datetime':
+        case 'timestamp':
+            return `dateTime(${n})`;
+        case 'timestamptz':
+            return `timestamptz(${n})`;
+        case 'binary':
+            // BINARY(16) is the canonical UUID storage on MySQL (Deepkit's UUIDv4 annotation)
+            if (col.size === 16) return `uuid(${n})`;
+            return `binary(${n}, ${col.size ?? 16})`;
+        case 'blob':
+        case 'bytea':
+            return `blob(${n})`;
+        case 'json':
+            return `json(${n})`;
+        case 'jsonb':
+            return `jsonb(${n})`;
+        case 'uuid':
+            return `uuid(${n})`;
+        case 'point':
+            return `point(${n})`;
+        case 'enum': {
+            const values = col.enumValues ?? [];
+            const valuesArg = `[${values.map(v => quoteStr(v)).join(', ')}]`;
+            const typeName = col.enumTypeName;
+            const args = typeName ? [n, valuesArg, quoteStr(typeName)] : [n, valuesArg];
+            return `enum(${args.join(', ')})`;
+        }
+        default:
+            throw new Error(`Unsupported column type for builder regeneration: '${col.type}' (column ${col.name})`);
+    }
+}
+
+function renderIndexLine(idx: IndexSchema, table: TableSchema): string {
+    const colsArg = renderColumnsArg(idx.columns);
+
+    const suffix = idx.spatial ? 'spatial' : idx.unique ? 'unique' : 'index';
+    const expectedName = `${table.name}_${idx.columns.join('_')}_${suffix}`;
+    const nameArg = idx.name === expectedName ? '' : `, ${quoteStr(idx.name)}`;
+
+    if (idx.spatial) return `t.spatialIndex(${colsArg}${nameArg});`;
+    if (idx.unique) return `t.unique(${colsArg}${nameArg});`;
+    return `t.index(${colsArg}${nameArg});`;
+}
+
+function renderForeignKeyLine(fk: ForeignKeySchema, table: TableSchema): string {
+    const colsArg = renderColumnsArg(fk.columns);
+    const expectedName = `${table.name}_${fk.columns.join('_')}_foreign`;
+    const nameArg = fk.name === expectedName ? '' : `, ${quoteStr(fk.name)}`;
+
+    let line = `t.foreign(${colsArg}${nameArg})`;
+    if (fk.referencedColumns.length === 1) {
+        line += `.references(${quoteStr(fk.referencedColumns[0])})`;
+    } else {
+        line += `.referencesAll([${fk.referencedColumns.map(quoteStr).join(', ')}])`;
+    }
+    line += `.on(${quoteStr(fk.referencedTable)})`;
+    if (fk.onDelete && fk.onDelete.toUpperCase() !== 'RESTRICT') line += `.onDelete(${quoteStr(fk.onDelete)})`;
+    if (fk.onUpdate && fk.onUpdate.toUpperCase() !== 'RESTRICT') line += `.onUpdate(${quoteStr(fk.onUpdate)})`;
+    return line + ';';
+}
+
+function renderColumnsArg(columns: string[]): string {
+    if (columns.length === 1) return quoteStr(columns[0]);
+    return `[${columns.map(quoteStr).join(', ')}]`;
+}
+
+function quoteStr(s: string): string {
+    return `'${s.replace(/\\/g, '\\\\').replace(/'/g, "\\'")}'`;
+}
+
+function renderJsValue(value: unknown): string {
+    if (value === null) return 'null';
+    if (typeof value === 'boolean') return value ? 'true' : 'false';
+    if (typeof value === 'number') return String(value);
+    if (typeof value === 'string') return quoteStr(value);
+    return JSON.stringify(value);
+}

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

@@ -73,6 +73,7 @@ async function compareTable(entityTable: TableSchema, dbTable: TableSchema, dial
         reorderedColumns: [],
         addedIndexes: [],
         removedIndexes: [],
+        renamedIndexes: [],
         addedForeignKeys: [],
         removedForeignKeys: [],
         primaryKeyChanged: false,
@@ -154,9 +155,10 @@ async function compareTable(entityTable: TableSchema, dbTable: TableSchema, dial
     }
 
     // --- Indexes ---
-    const { added: addedIdx, removed: removedIdx } = compareIndexes(entityTable.indexes, dbTable.indexes);
+    const { added: addedIdx, removed: removedIdx, renamed: renamedIdx } = compareIndexes(entityTable.indexes, dbTable.indexes);
     diff.addedIndexes = addedIdx;
     diff.removedIndexes = removedIdx;
+    diff.renamedIndexes = renamedIdx;
 
     // --- Foreign Keys ---
     const { added: addedFK, removed: removedFK } = compareForeignKeys(entityTable.foreignKeys, dbTable.foreignKeys);
@@ -177,6 +179,7 @@ async function compareTable(entityTable: TableSchema, dbTable: TableSchema, dial
         diff.reorderedColumns.length === 0 &&
         diff.addedIndexes.length === 0 &&
         diff.removedIndexes.length === 0 &&
+        diff.renamedIndexes.length === 0 &&
         diff.addedForeignKeys.length === 0 &&
         diff.removedForeignKeys.length === 0 &&
         !diff.primaryKeyChanged &&
@@ -288,7 +291,16 @@ function defaultsMatch(a: ColumnSchema, b: ColumnSchema): boolean {
     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);
+    const av = String(a.defaultValue);
+    const bv = String(b.defaultValue);
+    if (av === bv) return true;
+
+    // Numeric defaults: '1' and '1.0'/'1.00' are equivalent (MySQL reports decimal defaults with scale).
+    const an = Number(av);
+    const bn = Number(bv);
+    if (av.trim() !== '' && bv.trim() !== '' && !Number.isNaN(an) && !Number.isNaN(bn)) return an === bn;
+
+    return false;
 }
 
 async function detectRenames(
@@ -356,7 +368,10 @@ function detectReorderingMySQL(entityTable: TableSchema, dbTable: TableSchema, d
     return reorders;
 }
 
-function compareIndexes(entityIndexes: IndexSchema[], dbIndexes: IndexSchema[]): { added: IndexSchema[]; removed: IndexSchema[] } {
+function compareIndexes(
+    entityIndexes: IndexSchema[],
+    dbIndexes: IndexSchema[]
+): { added: IndexSchema[]; removed: IndexSchema[]; renamed: { from: string; to: string }[] } {
     // Match by column set + uniqueness + spatial, not by name
     const indexKey = (idx: IndexSchema) => `${idx.columns.join(',')}:${idx.unique}:${idx.spatial}`;
 
@@ -366,7 +381,22 @@ function compareIndexes(entityIndexes: IndexSchema[], dbIndexes: IndexSchema[]):
     const added = entityIndexes.filter(i => !dbKeys.has(indexKey(i)));
     const removed = dbIndexes.filter(i => !entityKeys.has(indexKey(i)));
 
-    return { added, removed };
+    // Name reconciliation: when an entity index sets an explicit name but the column-matched DB
+    // index carries a different name, rename it (instead of leaving the index permanently under a
+    // stale/auto name). Skip when the target name is still held by a DB index we're keeping — that
+    // would collide; the rename only fires once the conflicting index is among `removed`.
+    const removedNames = new Set(removed.map(i => i.name));
+    const keptDbNames = new Set(dbIndexes.filter(i => !removedNames.has(i.name)).map(i => i.name));
+    const renamed: { from: string; to: string }[] = [];
+    for (const e of entityIndexes) {
+        if (!e.explicitName) continue;
+        const dbMatch = dbKeys.get(indexKey(e));
+        if (!dbMatch || dbMatch.name === e.name) continue;
+        if (keptDbNames.has(e.name)) continue; // target name taken by an index we're keeping
+        renamed.push({ from: dbMatch.name, to: e.name });
+    }
+
+    return { added, removed, renamed };
 }
 
 function normalizeFkAction(action: string): string {