@zyno-io/dk-server-foundation 26.216.430

package/src/database/entity.ts

@@ -0,0 +1,285 @@
+import { getClassTypeFromInstance } from '@deepkit/core';
+import {
+    ActiveRecord,
+    ActiveRecordClassType,
+    Database,
+    DatabaseAdapter,
+    DatabaseSession,
+    FilterQuery,
+    getClassState,
+    getInstanceState,
+    getInstanceStateFromItem
+} from '@deepkit/orm';
+import { SQLDatabaseAdapter } from '@deepkit/sql';
+import { ReflectionClass } from '@deepkit/type';
+import { compact, groupBy, keyBy, uniq } from 'lodash';
+
+import { EntityClassFields, EntityFields, getPKFieldForEntity, getPKFieldForEntityInstance } from './common';
+
+export function getDirtyDetails<T extends ActiveRecord, K extends keyof T>(entity: T): Record<K, { original: T[K]; current: T[K] }> {
+    const classState = getClassState(ReflectionClass.from(getClassTypeFromInstance(entity)));
+    const instanceState = getInstanceState(classState, entity);
+    const lastSnapshot = instanceState.getSnapshot();
+    const currentSnapshot = classState.snapshot(entity);
+    const changeSet = classState.changeDetector(lastSnapshot, currentSnapshot, entity);
+    const changedFields = Object.keys(changeSet?.$set || {});
+    return Object.fromEntries(
+        changedFields.map(f => [
+            f,
+            {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                original: (lastSnapshot as any)[f],
+                current: currentSnapshot[f]
+            }
+        ])
+    ) as Record<K, { original: T[K]; current: T[K] }>;
+}
+
+export function revertDirtyEntity(entity: ActiveRecord) {
+    const original = getEntityOriginal(entity);
+    for (const [field, value] of Object.entries(original)) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (entity as any)[field] = value;
+    }
+}
+
+export function getDirtyFields<T extends ActiveRecord>(entity: T): (keyof T)[] {
+    return Object.keys(getDirtyDetails(entity)) as (keyof T)[];
+}
+
+export function isEntityDirty(entity: ActiveRecord) {
+    return getDirtyFields(entity).length > 0;
+}
+
+export function isFieldDirty<T extends ActiveRecord>(entity: T, field: keyof T) {
+    return getDirtyFields(entity).includes(field);
+}
+
+export function getFieldOriginal<T extends ActiveRecord, K extends keyof T>(entity: T, field: K): T[K] | undefined {
+    const dirtyDetails = getDirtyDetails(entity);
+    const fieldDetails = dirtyDetails[field] as { original: T[K]; current: T[K] } | undefined;
+    return fieldDetails?.original;
+}
+
+export function getEntityOriginal<T extends ActiveRecord>(entity: T): EntityFields<T> {
+    return getInstanceStateFromItem(entity).getSnapshot() as EntityFields<T>;
+}
+
+export class BaseEntity extends ActiveRecord {}
+
+export type EntityPick<T extends ActiveRecord, K extends keyof EntityFields<T>> = ActiveRecord & Pick<T, K>;
+
+interface IGetEntityOptions<Schema extends ActiveRecordClassType, Field extends keyof EntityClassFields<Schema>> {
+    schema: Schema;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    ids: any[];
+    keyField?: Field;
+    fields?: Field[];
+    filter?: FilterQuery<InstanceType<Schema>>;
+    txn?: DatabaseSession<DatabaseAdapter>;
+}
+
+export async function getKeyedEntities<Schema extends ActiveRecordClassType, Fields extends keyof EntityClassFields<Schema>>(
+    options: IGetEntityOptions<Schema, Fields>
+) {
+    const { keyField, entities } = await getEntitiesByIdWithKeyName(options);
+    return keyBy(entities, keyField);
+}
+
+export async function getKeyedGroupedEntities<Schema extends ActiveRecordClassType, Fields extends keyof EntityClassFields<Schema>>(
+    options: IGetEntityOptions<Schema, Fields>
+) {
+    const { keyField, entities } = await getEntitiesByIdWithKeyName(options);
+    return groupBy(entities, keyField);
+}
+
+export async function getEntitiesById<Schema extends ActiveRecordClassType, Fields extends keyof EntityClassFields<Schema>>(
+    options: IGetEntityOptions<Schema, Fields>
+) {
+    const { entities } = await getEntitiesByIdWithKeyName(options);
+    return entities;
+}
+
+export async function getEntitiesByIdWithKeyName<Schema extends ActiveRecordClassType, Fields extends keyof EntityClassFields<Schema>>({
+    schema,
+    ids,
+    keyField,
+    fields,
+    filter,
+    txn
+}: IGetEntityOptions<Schema, Fields>) {
+    type ReturnType = typeof fields extends undefined ? InstanceType<Schema> : EntityPick<InstanceType<Schema>, Fields>;
+
+    const db: Database<SQLDatabaseAdapter> = schema.getDatabase();
+    const resolvedKeyField = keyField ?? getPKFieldForEntity(schema);
+
+    ids = uniq(compact(ids));
+    if (!ids.length) {
+        return {
+            keyField: resolvedKeyField,
+            entities: [] as ReturnType[]
+        };
+    }
+
+    const query = txn ? txn.query(schema) : db.query(schema);
+
+    const entities = fields
+        ? await query
+              .filter({ [resolvedKeyField]: { $in: ids }, ...filter })
+              // eslint-disable-next-line @typescript-eslint/no-explicit-any
+              .select(...(fields as any))
+              .find()
+        : await query.filter({ [resolvedKeyField]: { $in: ids }, ...filter }).find();
+
+    return {
+        keyField: resolvedKeyField,
+        entities: entities as ReturnType[]
+    };
+}
+
+interface IResolveRelatedOptions<
+    Schema extends ActiveRecord,
+    IdKey extends keyof EntityFields<Schema>,
+    RelatedSchema extends ActiveRecordClassType,
+    RelatedKey extends string,
+    RelatedFields extends keyof EntityClassFields<RelatedSchema>
+> {
+    src: Schema[];
+    srcIdField: IdKey;
+    targetField: RelatedKey;
+    targetSchema: RelatedSchema;
+    targetFields?: RelatedFields[];
+    txn?: DatabaseSession<DatabaseAdapter>;
+}
+
+export async function resolveRelated<
+    Schema extends ActiveRecord,
+    IdKey extends keyof EntityFields<Schema>,
+    RelatedSchema extends ActiveRecordClassType,
+    RelatedKey extends string,
+    RelatedFields extends keyof EntityClassFields<RelatedSchema>
+>(options: IResolveRelatedOptions<Schema, IdKey, RelatedSchema, RelatedKey, RelatedFields>) {
+    const { src, srcIdField, targetField, targetSchema, targetFields } = options;
+
+    type RelatedType = typeof targetFields extends undefined ? InstanceType<RelatedSchema> : EntityPick<InstanceType<RelatedSchema>, RelatedFields>;
+    type RelatedFieldType = null extends Schema[IdKey] ? { [K in RelatedKey]?: RelatedType } : { [K in RelatedKey]: RelatedType };
+    type ReturnType = Omit<Schema, IdKey> & RelatedFieldType;
+
+    if (!src.length) {
+        return [] as ReturnType[];
+    }
+
+    const subentitiesById = await getKeyedEntities({
+        ids: src.map(e => e[srcIdField]),
+        schema: targetSchema,
+        fields: targetFields,
+        txn: options.txn
+    });
+
+    src.forEach(e => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (e as any)[targetField] = subentitiesById[e[srcIdField] as any];
+    });
+
+    return src as ReturnType[];
+}
+
+interface IResolveRelatedByPivotOptions<
+    Schema extends object,
+    SrcIdField extends keyof EntityFields<Schema>,
+    PivotSchema extends ActiveRecordClassType,
+    PivotIdKey extends keyof EntityClassFields<PivotSchema>,
+    PivotRelatedKey extends keyof EntityClassFields<PivotSchema>,
+    RelatedSchema extends ActiveRecordClassType,
+    RelatedKey extends string,
+    RelatedFields extends keyof EntityClassFields<RelatedSchema>
+> {
+    src: Schema[];
+    srcIdField?: SrcIdField;
+    pivotSchema: PivotSchema;
+    pivotIdKey: PivotIdKey;
+    pivotRelatedKey: PivotRelatedKey;
+    pivotFilter?: FilterQuery<InstanceType<PivotSchema>>;
+    targetField: RelatedKey;
+    targetSchema: RelatedSchema;
+    targetFields?: RelatedFields[];
+    txn?: DatabaseSession<DatabaseAdapter>;
+}
+
+export async function resolveRelatedByPivot<
+    Schema extends object,
+    SrcIdField extends keyof EntityFields<Schema>,
+    PivotSchema extends ActiveRecordClassType,
+    PivotIdKey extends keyof EntityClassFields<PivotSchema>,
+    PivotRelatedKey extends keyof EntityClassFields<PivotSchema>,
+    RelatedSchema extends ActiveRecordClassType,
+    RelatedKey extends string,
+    RelatedFields extends keyof EntityClassFields<RelatedSchema>
+>(options: IResolveRelatedByPivotOptions<Schema, SrcIdField, PivotSchema, PivotIdKey, PivotRelatedKey, RelatedSchema, RelatedKey, RelatedFields>) {
+    const { src, srcIdField, pivotSchema, pivotIdKey, pivotRelatedKey, pivotFilter, targetField, targetSchema, targetFields } = options;
+
+    type RelatedType = typeof targetFields extends undefined ? InstanceType<RelatedSchema> : EntityPick<InstanceType<RelatedSchema>, RelatedFields>;
+    type RelatedTypeWithPivot = RelatedType & { pivot: InstanceType<PivotSchema> };
+    type RelatedFieldType = { [K in RelatedKey]: RelatedTypeWithPivot[] };
+    type ReturnType = Schema & RelatedFieldType;
+
+    if (!src.length) {
+        return [] as ReturnType[];
+    }
+
+    const sourcePkField = srcIdField ?? getPKFieldForEntityInstance(src[0]);
+    const pivotEntitiesBySourceId = await getKeyedGroupedEntities({
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ids: src.map(e => (e as any)[sourcePkField as any]),
+        schema: pivotSchema,
+        keyField: pivotIdKey,
+        filter: pivotFilter,
+        txn: options.txn
+    });
+
+    const relatedEntitiesById = await getKeyedEntities({
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        ids: Object.values(pivotEntitiesBySourceId).flatMap(p => p.map(p => (p as any)[pivotRelatedKey])),
+        schema: targetSchema,
+        fields: targetFields,
+        txn: options.txn
+    });
+
+    src.forEach(e => {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (e as any)[targetField] =
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            pivotEntitiesBySourceId[(e as any)[sourcePkField as any]]?.map(p => ({
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                ...relatedEntitiesById[(p as any)[pivotRelatedKey]],
+                pivot: p
+            })) ?? [];
+    });
+
+    return src as ReturnType[];
+}
+
+export async function resolveRelatedByPivotForOne<
+    Schema extends object,
+    SrcIdField extends keyof EntityFields<Schema>,
+    PivotSchema extends ActiveRecordClassType,
+    PivotIdKey extends keyof EntityClassFields<PivotSchema>,
+    PivotRelatedKey extends keyof EntityClassFields<PivotSchema>,
+    RelatedSchema extends ActiveRecordClassType,
+    RelatedKey extends string,
+    RelatedFields extends keyof EntityClassFields<RelatedSchema>
+>(
+    options: Omit<
+        IResolveRelatedByPivotOptions<Schema, SrcIdField, PivotSchema, PivotIdKey, PivotRelatedKey, RelatedSchema, RelatedKey, RelatedFields>,
+        'src'
+    > & {
+        src: Schema;
+    }
+) {
+    return (
+        await resolveRelatedByPivot({
+            ...options,
+            src: [options.src]
+        })
+    )[0];
+}

package/src/database/index.ts

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

package/src/database/migration/MigrationResetCommand.ts

@@ -0,0 +1,72 @@
+import { cli } from '@deepkit/app';
+import { SQLDatabaseAdapter } from '@deepkit/sql';
+import { existsSync, mkdirSync, readdirSync, unlinkSync, writeFileSync } from 'fs';
+import path from 'path';
+
+import { DBProvider } from '../../app/state';
+import { getAppConfig } from '../../app/resolver';
+import { createLogger } from '../../services';
+import { getDialect } from '../dialect';
+import { getSourceMigrationsDir } from './helpers';
+import { readEntitiesSchema } from './create/entity-reader';
+import { generateDDL } from './create/ddl-generator';
+import { buildFileContent } from './create/file-generator';
+import { SchemaDiff } from './create/schema-model';
+
+@cli.controller('migration:reset')
+export class MigrationResetCommand {
+    private logger = createLogger('MigrationReset');
+    private migrationsDir = getSourceMigrationsDir();
+
+    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) {
+            const filePath = path.join(this.migrationsDir, file);
+            unlinkSync(filePath);
+            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...');
+        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) {
+            this.logger.info('No tables found to generate base migration.');
+            return;
+        }
+
+        // Step 6: Write migration file
+        const migrationContent = buildFileContent(statements);
+        const migrationPath = path.join(this.migrationsDir, '00000000_000000_base.ts');
+
+        writeFileSync(migrationPath, migrationContent, 'utf8');
+        this.logger.info(`Created initial migration: ${migrationPath}`);
+        this.logger.info(`Migration reset complete with ${tables.length} table(s)`);
+    }
+}

package/src/database/migration/MigrationRunCommand.ts

@@ -0,0 +1,118 @@
+import { cli } from '@deepkit/app';
+import { SQLDatabaseAdapter } from '@deepkit/sql';
+import { existsSync, readdirSync } from 'fs';
+import { difference } from 'lodash';
+import path from 'path';
+
+import { DBProvider, globalState } from '../../app/state';
+import { createLogger } from '../../services';
+import { WorkerQueueRegistry } from '../../services/worker/queue';
+import { createPersistedEntity } from '../common';
+import { getDialect, tableExistsSql } from '../dialect';
+import { getMigrationsDir } from './helpers';
+import { MigrationEntity } from './migration.entity';
+
+@cli.controller('migration:run')
+export class MigrationRunCommand {
+    private logger = createLogger('Migrator');
+    private migrationsDir = getMigrationsDir();
+
+    constructor(private dbProvider: DBProvider) {}
+
+    async execute() {
+        if (!existsSync(this.migrationsDir)) {
+            throw new Error('Migrations directory does not exist');
+        }
+
+        const migrations = readdirSync(this.migrationsDir)
+            .filter(f => /\.[jt]s$/.test(f))
+            .map(f => f.replace(/\.[jt]s$/, ''));
+        migrations.sort();
+        this.logger.info(`${migrations.length} migrations found in package`);
+
+        await this.createMigrationsTableIfNotExists();
+
+        this.dbProvider.db.registerEntity(MigrationEntity);
+
+        const executedMigrations = await MigrationEntity.query().select('name').findField('name');
+        const unexecutedMigrations = difference(migrations, executedMigrations);
+        this.logger.info(`${executedMigrations.length} migrations previously executed`);
+        this.logger.info(`${unexecutedMigrations.length} migrations to run`);
+
+        const executedAt = new Date();
+
+        for (const migration of unexecutedMigrations) {
+            const startTs = Date.now();
+            this.logger.info(`Running migration: ${migration}`);
+
+            await this.runCodeMigration(migration);
+
+            this.logger.info(`Completed migration: ${migration}`);
+            await createPersistedEntity(MigrationEntity, {
+                executedAt,
+                name: migration,
+                durationMs: Date.now() - startTs
+            });
+        }
+
+        // this may seem out of place but it makes sense to do during a migration, since
+        // the application is about to start and will re-register all jobs with the new schedule
+        if (globalState.enableWorker) {
+            const queue = WorkerQueueRegistry.getDefaultQueue();
+            const repeatableJobs = await queue.getRepeatableJobs();
+            for (const job of repeatableJobs) {
+                this.logger.info('Removing repeatable job', { job: { name: job.name, key: job.key } });
+                await queue.removeRepeatableByKey(job.key);
+            }
+            await WorkerQueueRegistry.closeQueues();
+        }
+    }
+
+    async createMigrationsTableIfNotExists() {
+        const dialect = getDialect(this.dbProvider.db.adapter as SQLDatabaseAdapter);
+        const tableInfoRows = await this.dbProvider.db.rawQuery(tableExistsSql(dialect, '_migrations'));
+        if (tableInfoRows.length) return;
+
+        if (dialect === 'postgres') {
+            await this.dbProvider.db.rawQuery(`
+                CREATE TABLE "_migrations" (
+                    "name" varchar(255) NOT NULL PRIMARY KEY,
+                    "executedAt" timestamp NOT NULL,
+                    "durationMs" integer NOT NULL
+                )
+            `);
+        } else {
+            await this.dbProvider.db.rawQuery(`
+                CREATE TABLE _migrations (
+                    name varchar(255) NOT NULL,
+                    executedAt datetime NOT NULL,
+                    durationMs int unsigned NOT NULL,
+                    PRIMARY KEY (name)
+                ) ENGINE=InnoDB
+            `);
+        }
+    }
+
+    async runCodeMigration(file: string) {
+        let migrationModule;
+
+        try {
+            // eslint-disable-next-line @typescript-eslint/no-require-imports
+            migrationModule = require(path.join(process.cwd(), this.migrationsDir, file));
+        } catch (err) {
+            this.logger.error('Failed to load migration', { file });
+            throw err;
+        }
+
+        if (!('default' in migrationModule) || typeof migrationModule.default !== 'function') {
+            throw new Error(`Migration ${file} does not export a function`);
+        }
+
+        try {
+            await migrationModule.default(this.dbProvider.db);
+        } catch (err) {
+            this.logger.error('Migration function failed to execute', err, { file });
+            throw err;
+        }
+    }
+}

package/src/database/migration/characters.ts

@@ -0,0 +1,53 @@
+import { cli } from '@deepkit/app';
+import { SQLDatabaseAdapter } from '@deepkit/sql';
+
+import { DBProvider } from '../../app/state';
+import { BaseDatabase } from '../common';
+import { getDialect } from '../dialect';
+
+interface ICollationOptions {
+    charset?: string;
+    collation?: string;
+}
+
+const DEFAULT_CHARSET = 'utf8mb4';
+const DEFAULT_COLLATION = 'utf8mb4_0900_ai_ci';
+
+export async function standardizeDbCollation(db: BaseDatabase, options?: ICollationOptions) {
+    const dialect = getDialect(db.adapter as SQLDatabaseAdapter);
+    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: any[] = 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((row: any) => Object.values(row)[0]);
+
+    for (const table of tables) {
+        await db.rawQuery(`ALTER TABLE ${table} CONVERT TO CHARACTER SET ${charset} COLLATE ${collation}`);
+    }
+}
+
+@cli.controller('migration:characters')
+export class MigrationCharactersCommand {
+    constructor(private dbProvider: DBProvider) {}
+
+    async execute(charset: string = DEFAULT_CHARSET, collation: string = DEFAULT_COLLATION) {
+        const dialect = getDialect(this.dbProvider.db.adapter as SQLDatabaseAdapter);
+        if (dialect === 'postgres') {
+            console.warn('Character set standardization is not applicable to PostgreSQL');
+            return;
+        }
+        await standardizeDbCollation(this.dbProvider.db, { charset, collation });
+    }
+}

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

@@ -0,0 +1,96 @@
+import { cli, Flag } from '@deepkit/app';
+import { SQLDatabaseAdapter } from '@deepkit/sql';
+
+import { DBProvider } from '../../../app/state';
+import { getAppConfig } from '../../../app/resolver';
+import { createLogger, pinoLogger } from '../../../services';
+import { getDialect } from '../../dialect';
+import { readEntitiesSchema } from './entity-reader';
+import { readAllTableNames, readDatabaseSchema } from './db-reader';
+import { compareSchemas } from './comparator';
+import { generateDDL } from './ddl-generator';
+import { generateMigrationFile } from './file-generator';
+import { promptMigrationDescription, setNonInteractive } from './prompt';
+import { INTERNAL_TABLES } from './schema-model';
+
+@cli.controller('migration:create')
+export class MigrationCreateCommand {
+    private logger = createLogger('MigrationCreate');
+
+    constructor(private dbProvider: DBProvider) {}
+
+    async execute(nonInteractive: boolean & Flag<{ description: 'Skip interactive prompts' }> = false) {
+        if (nonInteractive) {
+            setNonInteractive(true);
+        }
+
+        try {
+            const db = this.dbProvider.db;
+            const dialect = getDialect(db.adapter as SQLDatabaseAdapter);
+            const pgSchema = dialect === 'postgres' ? (getAppConfig().PG_SCHEMA ?? 'public') : 'public';
+
+            this.logger.info(`Dialect: ${dialect}`);
+
+            // Step 1: Read entity schema
+            this.logger.info('Reading entity definitions...');
+            const entitySchema = 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 readAllTableNames(db, dialect, pgSchema);
+            const dbOnlyTables = allDbTableNames.filter(n => !entitySchema.has(n) && !INTERNAL_TABLES.has(n));
+            const tableNames = [...entityTableNames, ...dbOnlyTables];
+
+            // Step 3: Read database schema
+            this.logger.info('Reading database schema...');
+            const dbSchema = await readDatabaseSchema(db, dialect, tableNames, pgSchema);
+
+            // Step 4: Compare schemas
+            this.logger.info('Comparing schemas...');
+            const diff = await compareSchemas(entitySchema, dbSchema, dialect, !nonInteractive, pgSchema);
+
+            // Step 5: Generate DDL
+            const statements = 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(t => t.name).join(', ')}`);
+            }
+            if (diff.removedTables.length > 0) {
+                this.logger.info(`  Removed tables: ${diff.removedTables.map(t => t.name).join(', ')}`);
+            }
+            for (const table of diff.modifiedTables) {
+                const changes: string[] = [];
+                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
+            pinoLogger.flush();
+            await new Promise(resolve => setTimeout(resolve, 100));
+            const description = await promptMigrationDescription();
+            const filePath = generateMigrationFile(statements, description);
+            this.logger.info(`\nMigration file created: ${filePath}`);
+        } finally {
+            setNonInteractive(false);
+        }
+    }
+}