@hed-hog/cli 0.0.94 → 0.0.96

package/dist/src/modules/hedhog/services/diff.service.d.ts

@@ -0,0 +1,107 @@
+import { FileSystemService } from './file-system.service';
+import { TableColumn, TableDefinition } from './table.service';
+export interface ColumnChange {
+    column: TableColumn;
+    oldType: string;
+    newType: string;
+    oldNullable: boolean;
+    newNullable: boolean;
+    oldDefault: any;
+    newDefault: any;
+    oldLength: number | undefined;
+    newLength: number | undefined;
+}
+export interface RenameCandidate {
+    oldColumn: TableColumn;
+    newColumn: TableColumn;
+}
+export interface RenameDecision {
+    oldName: string;
+    newName: string;
+    oldColumn: TableColumn;
+    newColumn: TableColumn;
+    isRename: boolean;
+}
+export interface EnumValueChanges {
+    columnName: string;
+    addedValues: string[];
+    removedValues: string[];
+}
+export interface TableChanges {
+    tableName: string;
+    addedColumns: TableColumn[];
+    /** Columns dropped AFTER rename resolution (confirmed drops only) */
+    removedColumns: TableColumn[];
+    /** Confirmed renames (isRename === true) */
+    renamedColumns: RenameDecision[];
+    changedColumns: ColumnChange[];
+    addedUniqueConstraints: string[];
+    removedUniqueConstraints: string[];
+    addedForeignKeys: TableColumn[];
+    removedForeignKeys: TableColumn[];
+    enumValueChanges: EnumValueChanges[];
+}
+export interface SchemaDiff {
+    newTables: TableDefinition[];
+    removedTables: TableDefinition[];
+    changedTables: TableChanges[];
+}
+export interface RelationChange {
+    parentKeyValue: string;
+    targetTable: string;
+    addedRelations: any[];
+    removedRelations: any[];
+}
+export interface DataRowChange {
+    tableName: string;
+    keyColumn: string | string[];
+    insertedRows: any[];
+    updatedRows: any[];
+    removedRows: any[];
+    relationChanges: RelationChange[];
+}
+export interface DataFileChange {
+    tableName: string;
+    /** New data file — all rows are inserts */
+    isNew: boolean;
+    /** Data file removed — all rows may be deleted (after prompt) */
+    isRemoved: boolean;
+    allRows: any[];
+}
+export interface DataDiff {
+    changes: DataRowChange[];
+    fileChanges: DataFileChange[];
+}
+export declare class DiffService {
+    private readonly fileSystem;
+    constructor(fileSystem: FileSystemService);
+    diffSchema(oldTables: TableDefinition[], newTables: TableDefinition[]): SchemaDiff;
+    private diffTableColumns;
+    private detectColumnChange;
+    /** Normalize a processed TableColumn to its effective SQL type string for comparison */
+    normalizeColType(col: TableColumn): string;
+    private hasSchemaChanges;
+    diffData(oldLibraryPath: string, newLibraryPath: string, fallbackTableDefs?: Map<string, TableDefinition>): Promise<DataDiff>;
+    private loadAllRawData;
+    private loadRawTableDef;
+    /** Returns the identity key column name(s) for a table, or null if none found.
+     *  Priority: slug > column-level isUnique > table-level uniqueIndices > FK columns (junction fallback)
+     */
+    findIdentityKey(table: TableDefinition): string | string[] | null;
+    private getRowKeyValue;
+    private rowScalarsChanged;
+    private diffRelations;
+    detectRenameCandidates(droppedColumns: TableColumn[], addedColumns: TableColumn[]): RenameCandidate[];
+    private prompt;
+    promptRenames(tableName: string, candidates: RenameCandidate[]): Promise<RenameDecision[]>;
+    promptDropColumns(tableName: string, columns: TableColumn[]): Promise<TableColumn[]>;
+    promptDeleteRows(tableName: string, rows: any[], keyColumn: string | string[]): Promise<any[]>;
+    promptDeleteEntireDataFile(tableName: string, rows: any[]): Promise<'delete' | 'ignore'>;
+    promptDeleteRelations(parentTable: string, targetTable: string, pairs: {
+        parentKeyValue: string;
+        relation: any;
+    }[]): Promise<{
+        parentKeyValue: string;
+        relation: any;
+    }[]>;
+}

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

@@ -0,0 +1,573 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DiffService = void 0;
+const common_1 = require("@nestjs/common");
+const chalk = require("chalk");
+const path_1 = require("path");
+const file_system_service_1 = require("./file-system.service");
+// ── Service ───────────────────────────────────────────────────────────────────
+let DiffService = class DiffService {
+    fileSystem;
+    constructor(fileSystem) {
+        this.fileSystem = fileSystem;
+    }
+    // ── Schema diff ─────────────────────────────────────────────────────────────
+    diffSchema(oldTables, newTables) {
+        const oldTableMap = new Map(oldTables.map((t) => [t.name, t]));
+        const newTableMap = new Map(newTables.map((t) => [t.name, t]));
+        const newTableDefs = [];
+        const removedTables = [];
+        const changedTables = [];
+        for (const [name, table] of newTableMap) {
+            if (!oldTableMap.has(name))
+                newTableDefs.push(table);
+        }
+        for (const [name, table] of oldTableMap) {
+            if (!newTableMap.has(name))
+                removedTables.push(table);
+        }
+        for (const [name, newTable] of newTableMap) {
+            const oldTable = oldTableMap.get(name);
+            if (!oldTable)
+                continue;
+            const changes = this.diffTableColumns(oldTable, newTable);
+            if (this.hasSchemaChanges(changes))
+                changedTables.push(changes);
+        }
+        return { newTables: newTableDefs, removedTables, changedTables };
+    }
+    diffTableColumns(oldTable, newTable) {
+        const oldColMap = new Map(oldTable.columns.map((c) => [c.name, c]));
+        const newColMap = new Map(newTable.columns.map((c) => [c.name, c]));
+        const addedColumns = [];
+        const removedColumns = [];
+        const changedColumns = [];
+        for (const [name, col] of newColMap) {
+            if (!oldColMap.has(name))
+                addedColumns.push(col);
+        }
+        for (const [name, col] of oldColMap) {
+            if (!newColMap.has(name))
+                removedColumns.push(col);
+        }
+        for (const [name, newCol] of newColMap) {
+            const oldCol = oldColMap.get(name);
+            if (!oldCol)
+                continue;
+            const change = this.detectColumnChange(oldCol, newCol);
+            if (change)
+                changedColumns.push(change);
+        }
+        const oldUniqueSet = new Set(oldTable.columns.filter((c) => c.isUnique).map((c) => c.name));
+        const newUniqueSet = new Set(newTable.columns.filter((c) => c.isUnique).map((c) => c.name));
+        const addedUniqueConstraints = [...newUniqueSet].filter((n) => !oldUniqueSet.has(n));
+        const removedUniqueConstraints = [...oldUniqueSet].filter((n) => !newUniqueSet.has(n));
+        const oldFkMap = new Map(oldTable.columns.filter((c) => c.type === 'fk').map((c) => [c.name, c]));
+        const newFkMap = new Map(newTable.columns.filter((c) => c.type === 'fk').map((c) => [c.name, c]));
+        const addedForeignKeys = [...newFkMap.values()].filter((c) => !oldFkMap.has(c.name));
+        const removedForeignKeys = [...oldFkMap.values()].filter((c) => !newFkMap.has(c.name));
+        const enumValueChanges = [];
+        for (const [name, newCol] of newColMap) {
+            const oldCol = oldColMap.get(name);
+            if (!oldCol || newCol.type !== 'enum')
+                continue;
+            const oldEnum = [...(oldCol.enum || oldCol.values || [])];
+            const newEnum = [...(newCol.enum || newCol.values || [])];
+            const addedValues = newEnum.filter((v) => !oldEnum.includes(v));
+            const removedValues = oldEnum.filter((v) => !newEnum.includes(v));
+            if (addedValues.length || removedValues.length) {
+                enumValueChanges.push({
+                    columnName: name,
+                    addedValues,
+                    removedValues,
+                });
+            }
+        }
+        return {
+            tableName: newTable.name,
+            addedColumns,
+            removedColumns,
+            renamedColumns: [],
+            changedColumns,
+            addedUniqueConstraints,
+            removedUniqueConstraints,
+            addedForeignKeys,
+            removedForeignKeys,
+            enumValueChanges,
+        };
+    }
+    detectColumnChange(oldCol, newCol) {
+        const oldType = this.normalizeColType(oldCol);
+        const newType = this.normalizeColType(newCol);
+        const oldNullable = oldCol.isNullable ?? false;
+        const newNullable = newCol.isNullable ?? false;
+        const oldDefault = String(oldCol.default ?? '');
+        const newDefault = String(newCol.default ?? '');
+        const oldLength = oldCol.length;
+        const newLength = newCol.length;
+        if (oldType === newType &&
+            oldNullable === newNullable &&
+            oldDefault === newDefault &&
+            oldLength === newLength) {
+            return null;
+        }
+        return {
+            column: newCol,
+            oldType,
+            newType,
+            oldNullable,
+            newNullable,
+            oldDefault: oldCol.default,
+            newDefault: newCol.default,
+            oldLength,
+            newLength,
+        };
+    }
+    /** Normalize a processed TableColumn to its effective SQL type string for comparison */
+    normalizeColType(col) {
+        switch (col.type.toLowerCase()) {
+            case 'pk':
+                return 'SERIAL';
+            case 'fk':
+                return 'INTEGER';
+            case 'slug':
+            case 'varchar':
+                return `VARCHAR(${col.length || 255})`;
+            case 'order':
+                return 'INTEGER';
+            case 'created_at':
+            case 'updated_at':
+                return 'TIMESTAMPTZ';
+            case 'enum':
+                return 'enum';
+            case 'locale_varchar':
+                return `VARCHAR(${col.length || 255})`;
+            case 'locale_text':
+                return 'TEXT';
+            case 'char':
+                return `CHAR(${col.length || 1})`;
+            case 'int':
+                return 'INTEGER';
+            default:
+                return col.type.toUpperCase();
+        }
+    }
+    hasSchemaChanges(changes) {
+        return (changes.addedColumns.length > 0 ||
+            changes.removedColumns.length > 0 ||
+            changes.changedColumns.length > 0 ||
+            changes.addedUniqueConstraints.length > 0 ||
+            changes.removedUniqueConstraints.length > 0 ||
+            changes.addedForeignKeys.length > 0 ||
+            changes.removedForeignKeys.length > 0 ||
+            changes.enumValueChanges.length > 0);
+    }
+    // ── Data diff ───────────────────────────────────────────────────────────────
+    async diffData(oldLibraryPath, newLibraryPath, fallbackTableDefs) {
+        const changes = [];
+        const fileChanges = [];
+        const oldDataMap = await this.loadAllRawData(oldLibraryPath);
+        const newDataMap = await this.loadAllRawData(newLibraryPath);
+        const allTableNames = new Set([...oldDataMap.keys(), ...newDataMap.keys()]);
+        for (const tableName of allTableNames) {
+            const oldRows = oldDataMap.get(tableName) ?? [];
+            const newRows = newDataMap.get(tableName) ?? [];
+            if (oldRows.length === 0 && newRows.length > 0) {
+                fileChanges.push({
+                    tableName,
+                    isNew: true,
+                    isRemoved: false,
+                    allRows: newRows,
+                });
+                continue;
+            }
+            if (oldRows.length > 0 && newRows.length === 0) {
+                fileChanges.push({
+                    tableName,
+                    isNew: false,
+                    isRemoved: true,
+                    allRows: oldRows,
+                });
+                continue;
+            }
+            // Find identity key from the new YAML table definition, then old, then fallback
+            const tableDef = (await this.loadRawTableDef((0, path_1.join)(newLibraryPath, 'hedhog', 'table'), tableName)) ??
+                (await this.loadRawTableDef((0, path_1.join)(oldLibraryPath, 'hedhog', 'table'), tableName)) ??
+                fallbackTableDefs?.get(tableName) ??
+                null;
+            if (!tableDef) {
+                console.warn(chalk.yellow(`[update] Cannot diff data for table "${tableName}": table definition not found. Treating all rows as inserts.`));
+                fileChanges.push({
+                    tableName,
+                    isNew: true,
+                    isRemoved: false,
+                    allRows: newRows,
+                });
+                continue;
+            }
+            const keyColumn = this.findIdentityKey(tableDef);
+            if (!keyColumn) {
+                console.warn(chalk.yellow(`[update] Cannot diff data for table "${tableName}": no identity key (slug or unique column) found. Treating all rows as inserts.`));
+                fileChanges.push({
+                    tableName,
+                    isNew: true,
+                    isRemoved: false,
+                    allRows: newRows,
+                });
+                continue;
+            }
+            const oldRowIndex = new Map();
+            for (const row of oldRows) {
+                const keyVal = this.getRowKeyValue(row, keyColumn);
+                if (keyVal !== null)
+                    oldRowIndex.set(keyVal, row);
+            }
+            const insertedRows = [];
+            const updatedRows = [];
+            const removedRows = [];
+            const relationChanges = [];
+            for (const newRow of newRows) {
+                const keyVal = this.getRowKeyValue(newRow, keyColumn);
+                if (keyVal === null) {
+                    insertedRows.push(newRow);
+                    continue;
+                }
+                const oldRow = oldRowIndex.get(keyVal);
+                if (!oldRow) {
+                    insertedRows.push(newRow);
+                }
+                else {
+                    if (this.rowScalarsChanged(oldRow, newRow))
+                        updatedRows.push(newRow);
+                    relationChanges.push(...this.diffRelations(oldRow, newRow, keyVal));
+                }
+            }
+            const newKeySet = new Set(newRows
+                .map((r) => this.getRowKeyValue(r, keyColumn))
+                .filter((v) => v !== null));
+            for (const oldRow of oldRows) {
+                const keyVal = this.getRowKeyValue(oldRow, keyColumn);
+                if (keyVal !== null && !newKeySet.has(keyVal))
+                    removedRows.push(oldRow);
+            }
+            if (insertedRows.length ||
+                updatedRows.length ||
+                removedRows.length ||
+                relationChanges.length) {
+                changes.push({
+                    tableName,
+                    keyColumn,
+                    insertedRows,
+                    updatedRows,
+                    removedRows,
+                    relationChanges,
+                });
+            }
+        }
+        return { changes, fileChanges };
+    }
+    async loadAllRawData(libraryPath) {
+        const result = new Map();
+        const dataDir = (0, path_1.join)(libraryPath, 'hedhog', 'data');
+        try {
+            const files = await this.fileSystem.getYamlFiles(dataDir);
+            for (const file of files) {
+                const name = this.fileSystem.getFileNameWithoutExtension(file);
+                const rows = await this.fileSystem.readYamlFile((0, path_1.join)(dataDir, file));
+                if (Array.isArray(rows))
+                    result.set(name, rows);
+            }
+        }
+        catch {
+            // directory may not exist for this library version
+        }
+        return result;
+    }
+    async loadRawTableDef(tablesPath, tableName) {
+        try {
+            const yamlPath = (0, path_1.join)(tablesPath, `${tableName}.yaml`);
+            const ymlPath = (0, path_1.join)(tablesPath, `${tableName}.yml`);
+            let filePath = null;
+            if (await this.fileSystem.exists(yamlPath))
+                filePath = yamlPath;
+            else if (await this.fileSystem.exists(ymlPath))
+                filePath = ymlPath;
+            if (!filePath)
+                return null;
+            const parsed = await this.fileSystem.readYamlFile(filePath);
+            if (!parsed?.columns)
+                return null;
+            // Minimal processing: only what we need for identity key detection
+            const mainCols = parsed.columns.filter((c) => !['locale_varchar', 'locale_text'].includes(c.type));
+            // Apply basic type normalizations so slug/unique detection works
+            for (const col of mainCols) {
+                if (col.type === 'pk') {
+                    col.name = 'id';
+                    col.isPrimaryKey = true;
+                }
+                else if (col.type === 'slug') {
+                    col.name = col.name ?? 'slug';
+                    col.isUnique = true;
+                }
+            }
+            // Parse table-level unique indices from indices: section
+            const uniqueIndices = [];
+            if (Array.isArray(parsed.indices)) {
+                for (const idx of parsed.indices) {
+                    if (idx.isUnique &&
+                        Array.isArray(idx.columns) &&
+                        idx.columns.length > 0) {
+                        uniqueIndices.push(idx.columns);
+                    }
+                }
+            }
+            return {
+                name: tableName,
+                columns: mainCols,
+                data: [],
+                pk: mainCols.find((c) => c.isPrimaryKey || c.type === 'pk')?.name ||
+                    'id',
+                uniqueIndices: uniqueIndices.length > 0 ? uniqueIndices : undefined,
+            };
+        }
+        catch {
+            return null;
+        }
+    }
+    /** Returns the identity key column name(s) for a table, or null if none found.
+     *  Priority: slug > column-level isUnique > table-level uniqueIndices > FK columns (junction fallback)
+     */
+    findIdentityKey(table) {
+        if (table.columns.some((c) => c.name === 'slug'))
+            return 'slug';
+        const uniqueCols = table.columns.filter((c) => c.isUnique);
+        if (uniqueCols.length === 1)
+            return uniqueCols[0].name;
+        if (uniqueCols.length > 1)
+            return uniqueCols.map((c) => c.name);
+        // Table-level composite unique index (e.g. from YAML indices: section)
+        if (table.uniqueIndices?.length)
+            return table.uniqueIndices[0];
+        // Junction-table fallback: use all FK columns as composite key
+        const fkCols = table.columns.filter((c) => c.type === 'fk');
+        if (fkCols.length > 0)
+            return fkCols.map((c) => c.name);
+        return null;
+    }
+    getRowKeyValue(row, keyColumn) {
+        if (Array.isArray(keyColumn)) {
+            const parts = keyColumn.map((k) => {
+                const val = row[k];
+                if (val === undefined || val === null)
+                    return null;
+                if (typeof val === 'object' && 'where' in val)
+                    return JSON.stringify(val.where);
+                return String(val);
+            });
+            if (parts.some((p) => p === null))
+                return null;
+            return parts.join('::');
+        }
+        const val = row[keyColumn];
+        if (val === undefined || val === null)
+            return null;
+        if (typeof val === 'object' && 'where' in val) {
+            return JSON.stringify(val.where);
+        }
+        return String(val);
+    }
+    rowScalarsChanged(oldRow, newRow) {
+        const extractScalars = (row) => {
+            const result = {};
+            for (const [key, value] of Object.entries(row)) {
+                if (key !== 'relations')
+                    result[key] = value;
+            }
+            return result;
+        };
+        return (JSON.stringify(extractScalars(oldRow)) !==
+            JSON.stringify(extractScalars(newRow)));
+    }
+    diffRelations(oldRow, newRow, parentKeyValue) {
+        const changes = [];
+        const oldRels = oldRow.relations || {};
+        const newRels = newRow.relations || {};
+        const allTargets = new Set([
+            ...Object.keys(oldRels),
+            ...Object.keys(newRels),
+        ]);
+        for (const targetTable of allTargets) {
+            const oldRelList = (oldRels[targetTable] ?? []);
+            const newRelList = (newRels[targetTable] ?? []);
+            const oldRelSet = new Set(oldRelList.map((r) => JSON.stringify(r)));
+            const newRelSet = new Set(newRelList.map((r) => JSON.stringify(r)));
+            const addedRelations = newRelList.filter((r) => !oldRelSet.has(JSON.stringify(r)));
+            const removedRelations = oldRelList.filter((r) => !newRelSet.has(JSON.stringify(r)));
+            if (addedRelations.length || removedRelations.length) {
+                changes.push({
+                    parentKeyValue,
+                    targetTable,
+                    addedRelations,
+                    removedRelations,
+                });
+            }
+        }
+        return changes;
+    }
+    // ── Rename detection ────────────────────────────────────────────────────────
+    detectRenameCandidates(droppedColumns, addedColumns) {
+        const candidates = [];
+        for (const dropped of droppedColumns) {
+            const normalizedDropped = this.normalizeColType(dropped);
+            for (const added of addedColumns) {
+                if (normalizedDropped === this.normalizeColType(added)) {
+                    candidates.push({ oldColumn: dropped, newColumn: added });
+                }
+            }
+        }
+        return candidates;
+    }
+    // ── Interactive prompts (inquirer v12 via dynamic import) ───────────────────
+    async prompt(questions) {
+        const { default: inquirer } = await Promise.resolve().then(() => require('inquirer'));
+        return inquirer.prompt(questions);
+    }
+    async promptRenames(tableName, candidates) {
+        const decisions = [];
+        for (const candidate of candidates) {
+            const type = this.normalizeColType(candidate.oldColumn);
+            const answers = await this.prompt([
+                {
+                    type: 'confirm',
+                    name: 'isRename',
+                    message: chalk.yellow(`[Table "${tableName}"] Column "${candidate.oldColumn.name}" was removed and "${candidate.newColumn.name}" was added (same type: ${type}). Is this a RENAME?`) + chalk.gray(' (No = DROP + ADD)'),
+                    default: false,
+                },
+            ]);
+            decisions.push({
+                oldName: candidate.oldColumn.name,
+                newName: candidate.newColumn.name,
+                oldColumn: candidate.oldColumn,
+                newColumn: candidate.newColumn,
+                isRename: answers.isRename,
+            });
+        }
+        return decisions;
+    }
+    async promptDropColumns(tableName, columns) {
+        const approved = [];
+        for (const col of columns) {
+            console.warn(chalk.red(`\n⚠️  WARNING: Dropping column "${col.name}" from table "${tableName}" will cause permanent DATA LOSS.\n`));
+            const answers = await this.prompt([
+                {
+                    type: 'list',
+                    name: 'action',
+                    message: `Column "${col.name}" (${this.normalizeColType(col)}) was removed from the YAML. What should be done?`,
+                    choices: [
+                        {
+                            name: `DROP COLUMN "${col.name}" (recommended — removes column and all its data)`,
+                            value: 'drop',
+                        },
+                        {
+                            name: `IGNORE (keep the column in the database as-is)`,
+                            value: 'ignore',
+                        },
+                    ],
+                    default: 'drop',
+                },
+            ]);
+            if (answers.action === 'drop')
+                approved.push(col);
+        }
+        return approved;
+    }
+    async promptDeleteRows(tableName, rows, keyColumn) {
+        const approved = [];
+        for (const row of rows) {
+            const keyVal = Array.isArray(keyColumn)
+                ? keyColumn.map((k) => row[k]).join('::')
+                : row[keyColumn];
+            const answers = await this.prompt([
+                {
+                    type: 'list',
+                    name: 'action',
+                    message: `Row "${keyVal}" was removed from the data file for table "${tableName}". What should be done?`,
+                    choices: [
+                        {
+                            name: `IGNORE (keep the row in the database)`,
+                            value: 'ignore',
+                        },
+                        {
+                            name: `DELETE "${keyVal}" from "${tableName}"`,
+                            value: 'delete',
+                        },
+                    ],
+                    default: 'ignore',
+                },
+            ]);
+            if (answers.action === 'delete')
+                approved.push(row);
+        }
+        return approved;
+    }
+    async promptDeleteEntireDataFile(tableName, rows) {
+        console.warn(chalk.red(`\n⚠️  The entire data file for table "${tableName}" was removed in the new version (${rows.length} rows).\n`));
+        const answers = await this.prompt([
+            {
+                type: 'list',
+                name: 'action',
+                message: `Generate DELETE for all ${rows.length} rows in "${tableName}", or ignore?`,
+                choices: [
+                    {
+                        name: `IGNORE (keep all existing rows in the database)`,
+                        value: 'ignore',
+                    },
+                    {
+                        name: `DELETE all ${rows.length} rows from "${tableName}"`,
+                        value: 'delete',
+                    },
+                ],
+                default: 'ignore',
+            },
+        ]);
+        return answers.action;
+    }
+    async promptDeleteRelations(parentTable, targetTable, pairs) {
+        const approved = [];
+        for (const pair of pairs) {
+            const answers = await this.prompt([
+                {
+                    type: 'list',
+                    name: 'action',
+                    message: `Relation between "${parentTable}:${pair.parentKeyValue}" and "${targetTable}:${JSON.stringify(pair.relation)}" was removed. DELETE or IGNORE?`,
+                    choices: [
+                        {
+                            name: `IGNORE (keep the relation in the database)`,
+                            value: 'ignore',
+                        },
+                        { name: `DELETE the relation`, value: 'delete' },
+                    ],
+                    default: 'ignore',
+                },
+            ]);
+            if (answers.action === 'delete')
+                approved.push(pair);
+        }
+        return approved;
+    }
+};
+exports.DiffService = DiffService;
+exports.DiffService = DiffService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [file_system_service_1.FileSystemService])
+], DiffService);
+//# sourceMappingURL=diff.service.js.map