@hed-hog/cli 0.0.95 → 0.0.96

package/dist/src/modules/hedhog/services/migration.service.js

@@ -17,6 +17,7 @@ const path_1 = require("path");
 const sql_formatter_1 = require("sql-formatter");
 const database_service_1 = require("../../database/database.service");
 const developer_service_1 = require("../../developer/developer.service");
+const diff_service_1 = require("./diff.service");
 const file_system_service_1 = require("./file-system.service");
 const table_service_1 = require("./table.service");
 let MigrationService = class MigrationService {
@@ -24,14 +25,16 @@ let MigrationService = class MigrationService {
     developer;
     fileSystem;
     tableService;
+    diffService;
     indexWithClauseLocale = 0;
     touchUpdatedAtCreated = false;
     verbose = false;
-    constructor(database, developer, fileSystem, tableService) {
+    constructor(database, developer, fileSystem, tableService, diffService) {
         this.database = database;
         this.developer = developer;
         this.fileSystem = fileSystem;
         this.tableService = tableService;
+        this.diffService = diffService;
     }
     log(message) {
         if (this.verbose) {
@@ -311,6 +314,64 @@ let MigrationService = class MigrationService {
         }
         return transformedContent;
     }
+    /**
+     * Makes SQL statements idempotent using standard DDL (no DO blocks, which
+     * the sql-formatter breaks apart).
+     *
+     * Handles three cases for after-query SQL files:
+     *
+     * 1. ALTER COLUMN ... TYPE blocked by views:
+     *    If the file contains ALTER COLUMN ... TYPE AND defines views with
+     *    CREATE [OR REPLACE] VIEW, prepend DROP VIEW IF EXISTS for each view so
+     *    the ALTER succeeds. The views are recreated by the CREATE OR REPLACE
+     *    VIEW statements already in the same file.
+     *
+     * 2. ALTER TABLE … ADD CONSTRAINT <name> (bare, not inside a DO block):
+     *    → prepend DROP CONSTRAINT IF EXISTS <name>
+     *
+     * 3. CREATE [UNIQUE] INDEX <name> without IF NOT EXISTS:
+     *    → insert IF NOT EXISTS
+     */
+    wrapIdempotentSql(sql) {
+        const stripped = sql.replace(/--[^\n]*/g, '').trim();
+        let result = sql;
+        // ── Case 1: ALTER COLUMN ... TYPE / view dependency ──────────────────────
+        // If the file alters a column's type AND defines views, those views likely
+        // depend on the column. Drop them first; CREATE OR REPLACE VIEW later in
+        // the file will recreate them.
+        if (/\bALTER\s+COLUMN\b.+?\bTYPE\s+\w/is.test(stripped)) {
+            const viewNames = [];
+            const viewRegex = /\bCREATE\s+(?:OR\s+REPLACE\s+)?VIEW\s+"?(\w+)"?/gi;
+            let m;
+            while ((m = viewRegex.exec(stripped)) !== null) {
+                viewNames.push(m[1]);
+            }
+            if (viewNames.length > 0) {
+                const drops = viewNames
+                    .map((v) => `DROP VIEW IF EXISTS "${v}";`)
+                    .join('\n');
+                result = `${drops}\n\n${result}`;
+            }
+        }
+        // ── Case 2: Bare ADD CONSTRAINT (not already inside a DO $$ block) ───────
+        // Files that have DO $$ guards around constraints are already idempotent.
+        const hasDOBlocks = /\bDO\s*\$\$/.test(stripped);
+        if (!hasDOBlocks) {
+            const constraintMatch = /ALTER\s+TABLE\s+"?(\w+)"?\s+ADD\s+CONSTRAINT\s+"?(\w+)"?/is.exec(stripped);
+            if (constraintMatch) {
+                const table = constraintMatch[1];
+                const constraint = constraintMatch[2];
+                const drop = `ALTER TABLE "${table}" DROP CONSTRAINT IF EXISTS "${constraint}";`;
+                result = `${drop}\n${result.trim()}`;
+            }
+        }
+        // ── Case 3: CREATE [UNIQUE] INDEX without IF NOT EXISTS ───────────────────
+        if (/\bCREATE\b.*\bINDEX\b/is.test(stripped) &&
+            !/\bIF\s+NOT\s+EXISTS\b/is.test(stripped)) {
+            result = result.replace(/\bCREATE(\s+UNIQUE)?\s+INDEX\b/gi, (_m, unique) => `CREATE${unique ?? ''} INDEX IF NOT EXISTS`);
+        }
+        return result;
+    }
     normalizeCustomSqlQuery(file, sqlContent, enumRegistry, columnRegistry) {
         const normalizedDeclarations = this.normalizeCustomSqlEnumDeclarations(file, sqlContent, enumRegistry, columnRegistry);
         return this.normalizeCustomSqlAgainstSchema(file, normalizedDeclarations, columnRegistry);
@@ -574,12 +635,12 @@ let MigrationService = class MigrationService {
                 this.log(`Creating unique constraints for table: ${table.name}`);
                 const uniqueColumns = table.columns.filter((c) => c.isUnique);
                 if (uniqueColumns.length) {
-                    migrationContent.push(`CREATE UNIQUE INDEX "${table.name}_${uniqueColumns.map((c) => c.name).join('_')}_unique" ON "${table.name}" (${uniqueColumns.map((c) => `"${c.name}"`).join(', ')});`, ``);
+                    migrationContent.push(`CREATE UNIQUE INDEX IF NOT EXISTS "${table.name}_${uniqueColumns.map((c) => c.name).join('_')}_unique" ON "${table.name}" (${uniqueColumns.map((c) => `"${c.name}"`).join(', ')});`, ``);
                 }
                 for (const column of table.columns) {
                     if (column.type === 'slug') {
                         this.log(`Adding unique constraint for column: ${column.name}`);
-                        migrationContent.push(`CREATE UNIQUE INDEX "${table.name}_${column.name}_unique" ON "${table.name}" ("${column.name}");`, ``);
+                        migrationContent.push(`CREATE UNIQUE INDEX IF NOT EXISTS "${table.name}_${column.name}_unique" ON "${table.name}" ("${column.name}");`, ``);
                     }
                 }
             }
@@ -844,9 +905,9 @@ let MigrationService = class MigrationService {
         }
         return [];
     }
-    async afterQueries(name, cwd, migrationContent, enumRegistry, columnRegistry) {
+    async afterQueries(name, cwd, migrationContent, enumRegistry, columnRegistry, customQueriesPath) {
         this.log(`Running after queries for ${name}...`);
-        const queriesPath = (0, path_1.resolve)(cwd, `./libraries/${name}/hedhog/query`);
+        const queriesPath = customQueriesPath ?? (0, path_1.resolve)(cwd, `./libraries/${name}/hedhog/query`);
         try {
             if (await this.fileSystem.exists(queriesPath)) {
                 const allFiles = await this.fileSystem.listFiles(queriesPath, () => true);
@@ -854,7 +915,7 @@ let MigrationService = class MigrationService {
                     if (file.endsWith('.sql')) {
                         const sqlContent = await this.fileSystem.readFileContent((0, path_1.join)(queriesPath, file));
                         const normalizedSql = this.normalizeCustomSqlQuery(file, sqlContent, enumRegistry, columnRegistry);
-                        migrationContent.push(`-- AfterQuery: ${file}`, normalizedSql, '');
+                        migrationContent.push(`-- AfterQuery: ${file}`, this.wrapIdempotentSql(normalizedSql), '');
                     }
                     else {
                         console.warn(chalk.yellow(`Arquivo ignorado no diretório de queries: ${file}`));
@@ -1052,6 +1113,538 @@ let MigrationService = class MigrationService {
         await this.fileSystem.writeJsonFile(hedhogFilePath, hedhogFile);
         this.log(`Migration file ${migrationFileName} created successfully.`);
     }
+    // ── Update migration ─────────────────────────────────────────────────────────
+    /**
+     * Generate a differential migration (ALTER TABLE + upserts) for an existing
+     * library being updated. Reads old schema/data from `libraries/<name>/` and
+     * new schema/data from `libraries/<name>/.hedhog-update/`.
+     */
+    async createUpdateMigrations(name, cwd = process.cwd(), verbose = false) {
+        this.verbose = verbose;
+        const oldLibraryPath = (0, path_1.resolve)(cwd, `./libraries/${name}`);
+        const newLibraryPath = (0, path_1.join)(oldLibraryPath, '.hedhog-update');
+        this.log(`Loading old table definitions from ${oldLibraryPath}...`);
+        const oldTables = await this.tableService.loadLibraryOwnedTables(oldLibraryPath, verbose);
+        this.log(`Loading new table definitions from ${newLibraryPath}...`);
+        const newTables = await this.tableService.loadLibraryOwnedTables(newLibraryPath, verbose);
+        // Build full allTables for FK/locale resolution during SQL generation
+        // Use new version's dependencies since it may have updated deps
+        const tablesDep = await this.tableService.getTablesFromDependencies(name, cwd);
+        const allTablesMap = new Map();
+        for (const t of [...tablesDep, ...newTables]) {
+            if (!allTablesMap.has(t.name))
+                allTablesMap.set(t.name, t);
+        }
+        const allTables = [...allTablesMap.values()];
+        // Diffs
+        const schemaDiff = this.diffService.diffSchema(oldTables, newTables);
+        const dataDiff = await this.diffService.diffData(oldLibraryPath, newLibraryPath, allTablesMap);
+        // ── Interactive prompts ────────────────────────────────────────────────────
+        // Resolve renames for changed tables
+        for (const tableChanges of schemaDiff.changedTables) {
+            const candidates = this.diffService.detectRenameCandidates(tableChanges.removedColumns, tableChanges.addedColumns);
+            if (candidates.length > 0) {
+                const decisions = await this.diffService.promptRenames(tableChanges.tableName, candidates);
+                tableChanges.renamedColumns = decisions.filter((d) => d.isRename);
+                // Remove confirmed renames from added/removed lists
+                const renamedOldNames = new Set(tableChanges.renamedColumns.map((r) => r.oldName));
+                const renamedNewNames = new Set(tableChanges.renamedColumns.map((r) => r.newName));
+                tableChanges.removedColumns = tableChanges.removedColumns.filter((c) => !renamedOldNames.has(c.name));
+                tableChanges.addedColumns = tableChanges.addedColumns.filter((c) => !renamedNewNames.has(c.name));
+            }
+        }
+        // Prompt for dropped columns
+        const approvedDropsMap = new Map();
+        for (const tableChanges of schemaDiff.changedTables) {
+            if (tableChanges.removedColumns.length > 0) {
+                const approved = await this.diffService.promptDropColumns(tableChanges.tableName, tableChanges.removedColumns);
+                approvedDropsMap.set(tableChanges.tableName, approved);
+            }
+        }
+        // Prompt for removed data rows
+        const approvedDeletesMap = new Map();
+        for (const change of dataDiff.changes) {
+            if (change.removedRows.length > 0) {
+                const approved = await this.diffService.promptDeleteRows(change.tableName, change.removedRows, change.keyColumn);
+                approvedDeletesMap.set(change.tableName, approved);
+            }
+        }
+        // Prompt for entirely removed data files
+        const approvedFileDeletesMap = new Map();
+        for (const fc of dataDiff.fileChanges) {
+            if (fc.isRemoved) {
+                const decision = await this.diffService.promptDeleteEntireDataFile(fc.tableName, fc.allRows);
+                approvedFileDeletesMap.set(fc.tableName, decision);
+            }
+        }
+        // Prompt for removed relations
+        const approvedRelationDeletesMap = new Map();
+        for (const change of dataDiff.changes) {
+            for (const relChange of change.relationChanges) {
+                if (relChange.removedRelations.length > 0) {
+                    const pairs = relChange.removedRelations.map((rel) => ({
+                        parentKeyValue: relChange.parentKeyValue,
+                        relation: rel,
+                    }));
+                    const mapKey = `${change.tableName}::${relChange.targetTable}`;
+                    const approved = await this.diffService.promptDeleteRelations(change.tableName, relChange.targetTable, pairs);
+                    approvedRelationDeletesMap.set(mapKey, approved);
+                }
+            }
+        }
+        // ── SQL generation ─────────────────────────────────────────────────────────
+        const dbType = await this.database.getDatabaseType(cwd);
+        if (!dbType)
+            throw new Error('Database type could not be determined');
+        const enumRegistry = this.buildEnumRegistry(allTables);
+        const migrationContent = [];
+        // 1. New tables (full CREATE TABLE pipeline)
+        if (schemaDiff.newTables.length > 0) {
+            const newEnumRegistry = this.buildEnumRegistry(schemaDiff.newTables);
+            this.processEnums(schemaDiff.newTables, dbType, migrationContent, newEnumRegistry);
+            const createdTables = [];
+            await this.createTableMigrations(schemaDiff.newTables, dbType, migrationContent, createdTables, cwd);
+            this.addUniqueConstraints(schemaDiff.newTables, dbType, migrationContent);
+            this.addForeignKeys(schemaDiff.newTables, dbType, migrationContent);
+        }
+        // 2. Removed tables (warning comment only)
+        for (const removed of schemaDiff.removedTables) {
+            migrationContent.push(`-- WARNING: Table "${removed.name}" was removed from the library YAML but was NOT dropped from the database. Manual action may be required.`, '');
+        }
+        // 3. ALTER TABLE statements for changed tables
+        for (const tableChanges of schemaDiff.changedTables) {
+            const approvedDrops = approvedDropsMap.get(tableChanges.tableName) ?? [];
+            const alterSql = this.generateAlterTableSQL(tableChanges, approvedDrops, enumRegistry, dbType, cwd);
+            migrationContent.push(...alterSql);
+        }
+        // 4. Data upserts / deletes
+        const dataSql = await this.generateDataUpdateSQL(dataDiff, allTables, approvedDeletesMap, approvedFileDeletesMap, approvedRelationDeletesMap, cwd);
+        migrationContent.push(...dataSql);
+        // 5. After queries (new version's hedhog/query/*.sql)
+        const columnRegistry = this.buildColumnTypeRegistry(allTables);
+        await this.afterQueries(name, cwd, migrationContent, enumRegistry, columnRegistry, (0, path_1.join)(newLibraryPath, 'hedhog', 'query'));
+        // ── Write migration file ──────────────────────────────────────────────────
+        const hasMeaningfulContent = migrationContent.some((line) => line.trim() && !line.startsWith('--'));
+        if (!hasMeaningfulContent) {
+            this.log(`No schema or data changes detected for ${name}. Skipping migration file.`);
+            console.info(chalk.blue(`[update] No changes detected for "${name}". Migration file not created.`));
+            return;
+        }
+        const timestamp = new Date()
+            .toISOString()
+            .replace(/[-:.T]/g, '')
+            .slice(0, 14);
+        const migrationFileName = `${timestamp}_update_${this.toSnackCase(name)}`;
+        const migrationFilePath = (0, path_1.resolve)(cwd, `./apps/api/prisma/migrations/${migrationFileName}`);
+        await this.fileSystem.createDirectory(migrationFilePath);
+        const formattedSQL = (0, sql_formatter_1.format)(migrationContent.join('\n') + '\n', {
+            language: 'postgresql',
+            newlineBeforeSemicolon: false,
+        });
+        await this.fileSystem.writeFileContent((0, path_1.resolve)(migrationFilePath, 'migration.sql'), formattedSQL);
+        // Update hedhog.json hash/migration entry
+        const hedhogFilePath = (0, path_1.join)(cwd, 'hedhog.json');
+        let hedhogFile = {};
+        if (await this.fileSystem.exists(hedhogFilePath)) {
+            hedhogFile = await this.fileSystem.readJsonFile(hedhogFilePath);
+        }
+        if (!hedhogFile.libraries)
+            hedhogFile.libraries = {};
+        // Hash the NEW version (still in .hedhog-update/) — hedhog.service.ts will
+        // replace the library folder AFTER this method returns.
+        const hashLib = await this.developer.hashDirectory(newLibraryPath);
+        hedhogFile.libraries[name] = {
+            hash: hashLib,
+            migration: migrationFileName,
+        };
+        await this.fileSystem.writeJsonFile(hedhogFilePath, hedhogFile);
+        this.log(`Update migration file ${migrationFileName} created successfully.`);
+    }
+    // ── ALTER TABLE SQL generation ────────────────────────────────────────────
+    generateAlterTableSQL(changes, approvedDrops, enumRegistry, dbType, cwd) {
+        if (dbType !== 'postgres')
+            return [];
+        const sql = [];
+        const t = changes.tableName;
+        // RENAMES (before any other operation on those columns)
+        for (const rename of changes.renamedColumns.filter((r) => r.isRename)) {
+            sql.push(`-- RenameColumn`, `ALTER TABLE "${t}" RENAME COLUMN "${rename.oldName}" TO "${rename.newName}";`, '');
+            // If type/nullable/default also changed, apply those after rename
+            const change = changes.changedColumns.find((c) => c.column.name === rename.newName);
+            if (change) {
+                sql.push(...this.generateColumnAlterSQL(t, change, enumRegistry));
+            }
+        }
+        const renamedNewNames = new Set(changes.renamedColumns.filter((r) => r.isRename).map((r) => r.newName));
+        // ADD COLUMNS
+        for (const col of changes.addedColumns) {
+            const typeDef = this.getColumnTypeDef(col, t, enumRegistry);
+            const nullable = col.isNullable ? 'NULL' : 'NOT NULL';
+            const defaultClause = col.default !== undefined
+                ? ` DEFAULT ${this.getDefaultValue(col)}`
+                : '';
+            sql.push(`-- AddColumn`, `ALTER TABLE "${t}" ADD COLUMN "${col.name}" ${typeDef} ${nullable}${defaultClause};`, '');
+        }
+        // DROP COLUMNS (approved only)
+        for (const col of approvedDrops) {
+            sql.push(`-- DropColumn`, `ALTER TABLE "${t}" DROP COLUMN "${col.name}";`, '');
+        }
+        // CHANGED COLUMNS (skip ones that were part of a rename — already handled)
+        for (const change of changes.changedColumns) {
+            if (renamedNewNames.has(change.column.name))
+                continue;
+            sql.push(...this.generateColumnAlterSQL(t, change, enumRegistry));
+        }
+        // NEW UNIQUE CONSTRAINTS
+        for (const colName of changes.addedUniqueConstraints) {
+            sql.push(`-- CreateUniqueIndex`, `CREATE UNIQUE INDEX IF NOT EXISTS "${t}_${colName}_unique" ON "${t}" ("${colName}");`, '');
+        }
+        // DROPPED UNIQUE CONSTRAINTS
+        for (const colName of changes.removedUniqueConstraints) {
+            sql.push(`-- DropUniqueIndex`, `DROP INDEX IF EXISTS "${t}_${colName}_unique";`, '');
+        }
+        // NEW FOREIGN KEYS
+        for (const col of changes.addedForeignKeys) {
+            const { table: fkTable, column: fkCol, onDelete, onUpdate, } = col.references;
+            sql.push(`-- AddForeignKey`, `ALTER TABLE "${t}" ADD CONSTRAINT "${fkTable}_${col.name}_fkey" FOREIGN KEY ("${col.name}") REFERENCES "${fkTable}" ("${fkCol}") ON DELETE ${onDelete || 'NO ACTION'} ON UPDATE ${onUpdate || 'NO ACTION'};`, '');
+        }
+        // DROPPED FOREIGN KEYS
+        for (const col of changes.removedForeignKeys) {
+            const { table: fkTable } = col.references;
+            sql.push(`-- DropForeignKey`, `ALTER TABLE "${t}" DROP CONSTRAINT "${fkTable}_${col.name}_fkey";`, '');
+        }
+        // ENUM VALUE CHANGES
+        for (const enumChange of changes.enumValueChanges) {
+            const enumName = this.getEnumName(t, enumChange.columnName);
+            for (const val of enumChange.addedValues) {
+                sql.push(`-- AddEnumValue`, `ALTER TYPE "${enumName}" ADD VALUE IF NOT EXISTS '${this.escapeSqlLiteral(val)}';`, '');
+            }
+            for (const val of enumChange.removedValues) {
+                sql.push(`-- WARNING: Cannot remove enum value '${val}' from type "${enumName}". PostgreSQL does not support removing enum values directly. Manual migration required (recreate type, update column, drop old type).`, '');
+            }
+        }
+        return sql;
+    }
+    generateColumnAlterSQL(tableName, change, enumRegistry) {
+        const sql = [];
+        const col = change.column;
+        const colName = col.name;
+        if (change.oldType !== change.newType ||
+            change.oldLength !== change.newLength) {
+            const newTypeDef = this.getColumnTypeDef(col, tableName, enumRegistry);
+            sql.push(`-- AlterColumnType`, `ALTER TABLE "${tableName}" ALTER COLUMN "${colName}" TYPE ${newTypeDef} USING "${colName}"::TEXT::${newTypeDef};`, '');
+        }
+        if (change.oldNullable !== change.newNullable) {
+            if (change.newNullable) {
+                sql.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${colName}" DROP NOT NULL;`, '');
+            }
+            else {
+                sql.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${colName}" SET NOT NULL;`, '');
+            }
+        }
+        const oldDef = String(change.oldDefault ?? '');
+        const newDef = String(change.newDefault ?? '');
+        if (oldDef !== newDef) {
+            if (change.newDefault === undefined || change.newDefault === null) {
+                sql.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${colName}" DROP DEFAULT;`, '');
+            }
+            else {
+                sql.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${colName}" SET DEFAULT ${this.getDefaultValue(col)};`, '');
+            }
+        }
+        return sql;
+    }
+    getColumnTypeDef(col, tableName, enumRegistry) {
+        switch (col.type.toLowerCase()) {
+            case 'pk':
+                return 'SERIAL';
+            case 'fk':
+            case 'int':
+            case 'order':
+                return 'INTEGER';
+            case 'slug':
+            case 'varchar':
+                return `VARCHAR(${col.length || 255})`;
+            case 'created_at':
+            case 'updated_at':
+            case 'datetime':
+                return 'TIMESTAMPTZ';
+            case 'locale_varchar':
+                return `VARCHAR(${col.length || 255})`;
+            case 'locale_text':
+                return 'TEXT';
+            case 'char':
+                return `CHAR(${col.length || 1})`;
+            case 'enum': {
+                const enumName = this.getEnumName(tableName, col.name);
+                return `"${enumName}"`;
+            }
+            default:
+                return col.type.toUpperCase();
+        }
+    }
+    // ── Data upsert SQL generation ────────────────────────────────────────────
+    async generateDataUpdateSQL(dataDiff, allTables, approvedDeletesMap, approvedFileDeletesMap, approvedRelationDeletesMap, cwd) {
+        const sql = [];
+        // Entirely new data files → all rows as upserts
+        for (const fc of dataDiff.fileChanges) {
+            if (fc.isNew) {
+                const tableDef = allTables.find((t) => t.name === fc.tableName);
+                if (!tableDef)
+                    continue;
+                const keyCol = this.diffService.findIdentityKey(tableDef);
+                if (!keyCol)
+                    continue;
+                sql.push(`-- UpsertData (new data file): ${fc.tableName}`);
+                for (const row of fc.allRows) {
+                    const rowSql = this.generateRowUpsertSQL(row, tableDef, keyCol, allTables);
+                    sql.push(...rowSql);
+                }
+                sql.push('');
+            }
+        }
+        // Entirely removed data files → DELETE if approved
+        for (const fc of dataDiff.fileChanges) {
+            if (fc.isRemoved) {
+                const decision = approvedFileDeletesMap.get(fc.tableName);
+                if (decision === 'delete') {
+                    const tableDef = allTables.find((t) => t.name === fc.tableName);
+                    const keyCol = tableDef
+                        ? this.diffService.findIdentityKey(tableDef)
+                        : null;
+                    sql.push(`-- DeleteData (data file removed): ${fc.tableName}`);
+                    if (Array.isArray(keyCol)) {
+                        sql.push(`-- WARNING: composite key — DELETE skipped for "${fc.tableName}". Manual action may be required.`);
+                    }
+                    else if (keyCol) {
+                        for (const row of fc.allRows) {
+                            const keyVal = row[keyCol];
+                            if (keyVal !== null && keyVal !== undefined) {
+                                sql.push(`DELETE FROM "${fc.tableName}" WHERE "${keyCol}" = $$${String(keyVal).replace(/\$\$/g, "''")}$$;`);
+                            }
+                        }
+                    }
+                    else {
+                        sql.push(`-- WARNING: Could not determine identity key for "${fc.tableName}". DELETE skipped.`);
+                    }
+                    sql.push('');
+                }
+                else {
+                    sql.push(`-- INFO: Data file for "${fc.tableName}" was removed in the new version. Existing rows preserved.`, '');
+                }
+            }
+        }
+        // Row-level changes
+        for (const change of dataDiff.changes) {
+            const tableDef = allTables.find((t) => t.name === change.tableName);
+            if (!tableDef)
+                continue;
+            // Inserted rows
+            if (change.insertedRows.length > 0) {
+                sql.push(`-- InsertData: ${change.tableName}`);
+                for (const row of change.insertedRows) {
+                    sql.push(...this.generateRowUpsertSQL(row, tableDef, change.keyColumn, allTables));
+                }
+                sql.push('');
+            }
+            // Updated rows
+            if (change.updatedRows.length > 0) {
+                sql.push(`-- UpdateData: ${change.tableName}`);
+                for (const row of change.updatedRows) {
+                    sql.push(...this.generateRowUpsertSQL(row, tableDef, change.keyColumn, allTables));
+                }
+                sql.push('');
+            }
+            // Deleted rows (approved)
+            const approvedDeletes = approvedDeletesMap.get(change.tableName) ?? [];
+            if (approvedDeletes.length > 0) {
+                sql.push(`-- DeleteData: ${change.tableName}`);
+                if (Array.isArray(change.keyColumn)) {
+                    sql.push(`-- WARNING: composite key — DELETE skipped for "${change.tableName}". Manual action may be required.`);
+                }
+                else {
+                    for (const row of approvedDeletes) {
+                        const keyVal = row[change.keyColumn];
+                        sql.push(`DELETE FROM "${change.tableName}" WHERE "${change.keyColumn}" = $$${String(keyVal).replace(/\$\$/g, "''")}$$;`);
+                    }
+                }
+                sql.push('');
+            }
+            // Relation changes
+            for (const relChange of change.relationChanges) {
+                if (Array.isArray(change.keyColumn))
+                    continue; // composite-key tables don't have nested relations
+                const mapKey = `${change.tableName}::${relChange.targetTable}`;
+                const approvedRelDeletes = approvedRelationDeletesMap.get(mapKey) ?? [];
+                const relSql = await this.generateRelationUpdateSQL(change.tableName, change.keyColumn, relChange.parentKeyValue, relChange.targetTable, relChange.addedRelations, relChange.removedRelations, approvedRelDeletes, allTables, cwd);
+                sql.push(...relSql);
+            }
+        }
+        return sql;
+    }
+    generateRowUpsertSQL(row, tableDef, keyColumn, allTables) {
+        const sql = [];
+        const keyCols = Array.isArray(keyColumn) ? keyColumn : [keyColumn];
+        const keyColsQuoted = new Set(keyCols.map((k) => `"${k}"`));
+        const scalarCols = [];
+        const scalarVals = [];
+        const localeEntries = [];
+        for (const [key, value] of Object.entries(row)) {
+            if (key === 'relations')
+                continue;
+            if (this.checkIsObjectLocale(value)) {
+                localeEntries.push({ name: key, values: value });
+            }
+            else if (tableDef.columns.some((c) => c.name === key)) {
+                scalarCols.push(`"${key}"`);
+                scalarVals.push(this.resolveRawValue(value, key, tableDef, allTables));
+            }
+        }
+        if (scalarCols.length > 0) {
+            if (keyCols.length > 1) {
+                // Use WHERE NOT EXISTS — safe even without a DB-level unique constraint
+                const whereConditions = keyCols
+                    .map((k) => {
+                    const idx = scalarCols.indexOf(`"${k}"`);
+                    const val = idx >= 0 ? scalarVals[idx] : 'NULL';
+                    return `"${k}" = ${val}`;
+                })
+                    .join(' AND ');
+                sql.push(`INSERT INTO "${tableDef.name}" (${scalarCols.join(', ')}) SELECT ${scalarVals.join(', ')} WHERE NOT EXISTS (SELECT 1 FROM "${tableDef.name}" WHERE ${whereConditions});`);
+            }
+            else {
+                const conflictTarget = `"${keyCols[0]}"`;
+                const setClauses = scalarCols
+                    .filter((c) => !keyColsQuoted.has(c))
+                    .map((c) => `${c} = EXCLUDED.${c}`)
+                    .join(', ');
+                const doConflict = setClauses
+                    ? `ON CONFLICT (${conflictTarget}) DO UPDATE SET ${setClauses}`
+                    : `ON CONFLICT (${conflictTarget}) DO NOTHING`;
+                sql.push(`INSERT INTO "${tableDef.name}" (${scalarCols.join(', ')}) VALUES (${scalarVals.join(', ')}) ${doConflict};`);
+            }
+        }
+        // Locale upserts — only applicable when key is a single column
+        const localeTableDef = allTables.find((t) => t.name === `${tableDef.name}_locale`);
+        if (localeTableDef &&
+            localeEntries.length > 0 &&
+            !Array.isArray(keyColumn)) {
+            const fkColName = localeTableDef.columns.find((c) => c.type === 'fk' && c.references?.table === tableDef.name)?.name;
+            const fkLocaleColName = localeTableDef.columns.find((c) => c.type === 'fk' && c.references?.table === 'locale')?.name;
+            if (fkColName && fkLocaleColName) {
+                const keyVal = row[keyColumn];
+                const parentKeySQL = this.resolveRawValue(keyVal, keyColumn, tableDef, allTables);
+                const parentSelect = `(SELECT "${tableDef.pk}" FROM "${tableDef.name}" WHERE "${keyColumn}" = ${parentKeySQL})`;
+                const localeCodes = new Set();
+                for (const entry of localeEntries) {
+                    for (const code of Object.keys(entry.values))
+                        localeCodes.add(code);
+                }
+                for (const code of localeCodes) {
+                    const localeCols2 = [];
+                    const localeVals = [];
+                    for (const entry of localeEntries) {
+                        if (entry.values[code] !== undefined) {
+                            localeCols2.push(`"${entry.name}"`);
+                            localeVals.push(`$$${String(entry.values[code]).replace(/\$\$/g, "''")}$$`);
+                        }
+                    }
+                    if (localeCols2.length > 0) {
+                        const insertCols = [
+                            `"${fkLocaleColName}"`,
+                            `"${fkColName}"`,
+                            ...localeCols2,
+                        ];
+                        const insertVals = [
+                            `(SELECT "id" FROM "locale" WHERE "code" = '${code}')`,
+                            parentSelect,
+                            ...localeVals,
+                        ];
+                        const setClauses2 = localeCols2
+                            .map((c) => `${c} = EXCLUDED.${c}`)
+                            .join(', ');
+                        sql.push(`INSERT INTO "${tableDef.name}_locale" (${insertCols.join(', ')}) VALUES (${insertVals.join(', ')}) ON CONFLICT ("${fkLocaleColName}", "${fkColName}") DO UPDATE SET ${setClauses2};`);
+                    }
+                }
+            }
+        }
+        return sql;
+    }
+    resolveRawValue(value, colName, tableDef, allTables) {
+        if (value === null || value === undefined)
+            return 'NULL';
+        if (typeof value === 'boolean')
+            return value ? 'TRUE' : 'FALSE';
+        if (typeof value === 'number')
+            return String(value);
+        if (typeof value === 'object' && 'where' in value) {
+            const colDef = tableDef.columns.find((c) => c.name === colName);
+            const refTableName = colDef?.references?.table;
+            if (!refTableName) {
+                console.warn(chalk.yellow(`[update] resolveRawValue: could not resolve FK table for column "${colName}" in "${tableDef.name}". Substituting NULL.`));
+                return 'NULL';
+            }
+            const refTableDef = allTables.find((t) => t.name === refTableName);
+            const refPk = refTableDef?.pk ?? 'id';
+            const whereClause = this.getWhereString(value);
+            return `(SELECT "${refPk}" FROM "${refTableName}" ${whereClause})`;
+        }
+        return `$$${String(value).replace(/\$\$/g, "''")}$$`;
+    }
+    async generateRelationUpdateSQL(parentTable, parentKeyColumn, parentKeyValue, targetTable, addedRelations, removedRelations, approvedRemovals, allTables, cwd) {
+        const sql = [];
+        const junctionResult = await this.tableService.getTableIntermediate(parentTable, targetTable, cwd);
+        if (!junctionResult) {
+            sql.push(`-- WARNING: Could not resolve junction table for relation "${parentTable}" ↔ "${targetTable}". Relation changes skipped.`, '');
+            return sql;
+        }
+        const targetTableDef = allTables.find((t) => t.name === targetTable);
+        const targetPk = targetTableDef?.pk ?? 'id';
+        const parentTableDef = allTables.find((t) => t.name === parentTable);
+        const parentPk = parentTableDef?.pk ?? 'id';
+        const parentKeySQL = `(SELECT "${parentPk}" FROM "${parentTable}" WHERE "${parentKeyColumn}" = $$${String(parentKeyValue).replace(/\$\$/g, "''")}$$)`;
+        if (junctionResult.intermediateTable) {
+            const junctionName = junctionResult.name;
+            const fkForParent = junctionResult.table.columns.find((c) => c.type === 'fk' && c.references?.table === parentTable)?.name;
+            const fkForTarget = junctionResult.table.columns.find((c) => c.type === 'fk' && c.references?.table === targetTable)?.name;
+            if (!fkForParent || !fkForTarget)
+                return sql;
+            for (const rel of addedRelations) {
+                const whereClause = this.getWhereString(rel);
+                const targetSQL = `(SELECT "${targetPk}" FROM "${targetTable}" ${whereClause})`;
+                sql.push(`-- AddRelation: ${parentTable} ↔ ${targetTable}`, `INSERT INTO "${junctionName}" ("${fkForParent}", "${fkForTarget}") VALUES (${parentKeySQL}, ${targetSQL}) ON CONFLICT DO NOTHING;`, '');
+            }
+            for (const rel of removedRelations) {
+                const isApproved = approvedRemovals.some((a) => a.parentKeyValue === parentKeyValue &&
+                    JSON.stringify(a.relation) === JSON.stringify(rel));
+                if (!isApproved)
+                    continue;
+                const whereClause = this.getWhereString(rel);
+                const targetSQL = `(SELECT "${targetPk}" FROM "${targetTable}" ${whereClause})`;
+                sql.push(`-- RemoveRelation: ${parentTable} ↔ ${targetTable}`, `DELETE FROM "${junctionName}" WHERE "${fkForParent}" = ${parentKeySQL} AND "${fkForTarget}" = ${targetSQL};`, '');
+            }
+        }
+        else {
+            // Direct child relation
+            const childTable = junctionResult.name;
+            const fkForParent = junctionResult.table.columns.find((c) => c.type === 'fk' && c.references?.table === parentTable)?.name;
+            if (!fkForParent)
+                return sql;
+            for (const rel of addedRelations) {
+                const whereClause = this.getWhereString(rel);
+                sql.push(`-- AddRelation (child): ${childTable}`, `INSERT INTO "${childTable}" ("${fkForParent}") SELECT ${parentKeySQL} WHERE EXISTS (SELECT 1 FROM "${targetTable}" ${whereClause}) ON CONFLICT DO NOTHING;`, '');
+            }
+            for (const rel of removedRelations) {
+                const isApproved = approvedRemovals.some((a) => a.parentKeyValue === parentKeyValue &&
+                    JSON.stringify(a.relation) === JSON.stringify(rel));
+                if (!isApproved)
+                    continue;
+                const whereClause = this.getWhereString(rel);
+                sql.push(`-- RemoveRelation (child): ${childTable}`, `DELETE FROM "${childTable}" WHERE "${fkForParent}" = ${parentKeySQL} AND EXISTS (SELECT 1 FROM "${targetTable}" ${whereClause});`, '');
+            }
+        }
+        return sql;
+    }
 };
 exports.MigrationService = MigrationService;
 exports.MigrationService = MigrationService = __decorate([
@@ -1059,6 +1652,7 @@ exports.MigrationService = MigrationService = __decorate([
     __metadata("design:paramtypes", [database_service_1.DatabaseService,
         developer_service_1.DeveloperService,
         file_system_service_1.FileSystemService,
-        table_service_1.TableService])
+        table_service_1.TableService,
+        diff_service_1.DiffService])
 ], MigrationService);
 //# sourceMappingURL=migration.service.js.map