frg-data-diff 2.0.0

package/dist/shared/prompts.js

@@ -0,0 +1,104 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prompt = prompt;
+exports.confirmProceed = confirmProceed;
+exports.confirmCreateConfig = confirmCreateConfig;
+exports.confirmUpdateConfig = confirmUpdateConfig;
+exports.confirmDirenvAllow = confirmDirenvAllow;
+const fs = __importStar(require("fs"));
+const readline = __importStar(require("readline"));
+let nonTtyAnswers;
+let nonTtyAnswerIndex = 0;
+/**
+ * Prompts the user with the given message and waits for input.
+ * Returns the trimmed input string.
+ */
+function prompt(message) {
+    if (!process.stdin.isTTY) {
+        nonTtyAnswers ??= fs.readFileSync(0, "utf-8").split(/\r?\n/);
+        process.stdout.write(message);
+        return Promise.resolve((nonTtyAnswers[nonTtyAnswerIndex++] ?? "").trim());
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(message, (answer) => {
+            rl.close();
+            resolve(answer.trim());
+        });
+    });
+}
+/**
+ * Asks the user to type "yes" to proceed.
+ * Returns true if the user typed exactly "yes", false otherwise.
+ */
+async function confirmProceed(message = 'Proceed? Type "yes" to continue: ', defaultYes = false) {
+    const answer = (await prompt(message)).trim().toLowerCase();
+    if (answer === "") {
+        return defaultYes;
+    }
+    if (answer === "no") {
+        return false;
+    }
+    return answer === "yes";
+}
+/**
+ * Asks the user whether to create a config file.
+ * Returns true if the user typed exactly "yes".
+ */
+async function confirmCreateConfig() {
+    const message = "\nNo .frg-data-diff.config.json file was found.\nCreate one from these options? [yes]: ";
+    return confirmProceed(message, true);
+}
+/**
+ * Asks the user whether to update an existing config file with the current options.
+ * Returns true if the user typed exactly "yes".
+ */
+async function confirmUpdateConfig() {
+    const message = "\nSave these options back to .frg-data-diff.config.json? [yes]: ";
+    return confirmProceed(message, true);
+}
+/**
+ * Asks the user whether to run `direnv allow` in the current directory.
+ * Returns true if the user typed exactly "yes".
+ */
+async function confirmDirenvAllow() {
+    const message = '\nA direnv installation was detected.\nRun "direnv allow" for this directory now? [yes]: ';
+    return confirmProceed(message, true);
+}
+//# sourceMappingURL=prompts.js.map

package/dist/shared/summary.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Summary of apply results.
+ */
+export interface ApplySummary {
+    applied: {
+        inserts: number;
+        updates: number;
+        deletes: number;
+    };
+    skipped: SkippedRow[];
+    conflicts: ConflictRow[];
+}
+export interface SkippedRow {
+    table: string;
+    operation: "insert" | "update" | "delete";
+    pk: Record<string, unknown>;
+    reason: string;
+}
+export interface ConflictRow {
+    table: string;
+    operation: "insert" | "update" | "delete";
+    pk: Record<string, unknown>;
+    reason: string;
+}
+/**
+ * Creates an empty summary object.
+ */
+export declare function createEmptySummary(): ApplySummary;
+/**
+ * Prints a human-readable summary to stdout.
+ */
+export declare function printSummary(summary: ApplySummary, dryRun: boolean): void;
+//# sourceMappingURL=summary.d.ts.map

package/dist/shared/summary.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEmptySummary = createEmptySummary;
+exports.printSummary = printSummary;
+/**
+ * Creates an empty summary object.
+ */
+function createEmptySummary() {
+    return {
+        applied: {
+            inserts: 0,
+            updates: 0,
+            deletes: 0,
+        },
+        skipped: [],
+        conflicts: [],
+    };
+}
+/**
+ * Prints a human-readable summary to stdout.
+ */
+function printSummary(summary, dryRun) {
+    const prefix = dryRun ? "[DRY RUN] " : "";
+    console.log(`\n${prefix}Apply summary:`);
+    console.log(`  Inserts applied: ${summary.applied.inserts}`);
+    console.log(`  Updates applied: ${summary.applied.updates}`);
+    console.log(`  Deletes applied: ${summary.applied.deletes}`);
+    if (summary.skipped.length > 0) {
+        console.log(`  Skipped rows: ${summary.skipped.length}`);
+        for (const s of summary.skipped) {
+            console.log(`    - ${s.table} [${s.operation}] pk=${JSON.stringify(s.pk)}: ${s.reason}`);
+        }
+    }
+    if (summary.conflicts.length > 0) {
+        console.log(`  Conflicts: ${summary.conflicts.length}`);
+        for (const c of summary.conflicts) {
+            console.log(`    - ${c.table} [${c.operation}] pk=${JSON.stringify(c.pk)}: ${c.reason}`);
+        }
+    }
+}
+//# sourceMappingURL=summary.js.map

package/dist/sql/generate-sql.d.ts

@@ -0,0 +1,19 @@
+import { type DiffJson } from "../diff/diff-schema";
+export interface GenerateSqlOptions {
+    applyInserts: boolean;
+    applyUpdates: boolean;
+    applyDeletes: boolean;
+    transaction: boolean;
+    onProgress?: (message: string) => void;
+}
+export interface GeneratedSqlResult {
+    sql: string;
+    summary: {
+        inserts: number;
+        updates: number;
+        deletes: number;
+    };
+}
+export declare function buildSqlOutputPath(inputPath: string): string;
+export declare function generateSqlScript(diff: DiffJson, options: GenerateSqlOptions): GeneratedSqlResult;
+//# sourceMappingURL=generate-sql.d.ts.map

package/dist/sql/generate-sql.js

@@ -0,0 +1,223 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSqlOutputPath = buildSqlOutputPath;
+exports.generateSqlScript = generateSqlScript;
+const identifiers_1 = require("../shared/identifiers");
+function buildSqlOutputPath(inputPath) {
+    return inputPath.endsWith(".json")
+        ? inputPath.replace(/\.json$/i, ".sql")
+        : `${inputPath}.sql`;
+}
+function generateSqlScript(diff, options) {
+    const lines = [];
+    const summary = {
+        inserts: 0,
+        updates: 0,
+        deletes: 0,
+    };
+    lines.push("-- Generated by frg-data-diff");
+    lines.push(`-- Diff format: ${diff.format}`);
+    lines.push(`-- Generated at: ${diff.generatedAt}`);
+    lines.push(`-- Source schema: ${diff.source.schema}`);
+    lines.push(`-- Destination schema: ${diff.dest.schema}`);
+    if (options.transaction) {
+        lines.push("");
+        lines.push("BEGIN;");
+    }
+    reportProgress(options.onProgress, `Generating data SQL for ${diff.tables.length} table diff(s)...`);
+    for (const [tableIndex, tableDiff] of diff.tables.entries()) {
+        const progressLabel = `[data-sql ${tableIndex + 1}/${diff.tables.length}] ${tableDiff.schema}.${tableDiff.table}`;
+        reportProgress(options.onProgress, `${progressLabel}: ${summarizeDataSqlWork(tableDiff, options)}`);
+        (0, identifiers_1.validateIdentifier)(tableDiff.schema, "schema name");
+        (0, identifiers_1.validateIdentifier)(tableDiff.table, "table name");
+        (0, identifiers_1.validateIdentifiers)(tableDiff.primaryKey, "primary key column");
+        const statements = [];
+        if (options.applyInserts) {
+            for (const insert of tableDiff.inserts) {
+                statements.push(buildInsertStatement(tableDiff.schema, tableDiff.table, insert, tableDiff.columnTypes));
+                summary.inserts++;
+            }
+        }
+        if (options.applyUpdates) {
+            for (const update of tableDiff.updates) {
+                statements.push(buildUpdateStatement(tableDiff.schema, tableDiff.table, tableDiff.primaryKey, update, tableDiff.columnTypes));
+                summary.updates++;
+            }
+        }
+        if (options.applyDeletes) {
+            for (const del of tableDiff.deletes) {
+                statements.push(buildDeleteStatement(tableDiff.schema, tableDiff.table, tableDiff.primaryKey, del, tableDiff.columnTypes));
+                summary.deletes++;
+            }
+        }
+        if (statements.length === 0) {
+            reportProgress(options.onProgress, `${progressLabel}: no SQL statements generated`);
+            continue;
+        }
+        reportProgress(options.onProgress, `${progressLabel}: generated ${statements.length} SQL statement(s)`);
+        lines.push("");
+        lines.push(`-- ${tableDiff.schema}.${tableDiff.table}`);
+        lines.push(...statements);
+    }
+    if (options.transaction) {
+        lines.push("");
+        lines.push("COMMIT;");
+    }
+    lines.push("");
+    return {
+        sql: lines.join("\n"),
+        summary,
+    };
+}
+function buildInsertStatement(schema, table, record, columnTypes) {
+    const columns = Object.keys(record.row);
+    (0, identifiers_1.validateIdentifiers)(columns, "insert column");
+    const qualifiedTable = (0, identifiers_1.quoteQualifiedTable)(schema, table);
+    const quotedColumns = columns.map(identifiers_1.quoteIdentifier).join(", ");
+    const values = columns
+        .map((column) => toSqlLiteral(record.row[column], "value", column, columnTypes?.[column]))
+        .join(", ");
+    return `INSERT INTO ${qualifiedTable} (${quotedColumns}) VALUES (${values});`;
+}
+function buildUpdateStatement(schema, table, pkColumns, record, columnTypes) {
+    const setColumns = Object.keys(record.changes);
+    (0, identifiers_1.validateIdentifiers)(setColumns, "update column");
+    const qualifiedTable = (0, identifiers_1.quoteQualifiedTable)(schema, table);
+    const setClause = setColumns
+        .map((column) => `${(0, identifiers_1.quoteIdentifier)(column)} = ${toSqlLiteral(record.changes[column].to, "value", column, columnTypes?.[column])}`)
+        .join(", ");
+    const pkWhere = buildSqlWhereClause(pkColumns.map((column) => [column, record.pk[column]]), "pk", columnTypes);
+    const guardWhere = buildSqlWhereClause(Object.entries(record.guard).filter(([column]) => !pkColumns.includes(column)), "guard", columnTypes);
+    const whereClause = guardWhere ? `${pkWhere} AND ${guardWhere}` : pkWhere;
+    return `UPDATE ${qualifiedTable} SET ${setClause} WHERE ${whereClause};`;
+}
+function buildDeleteStatement(schema, table, pkColumns, record, columnTypes) {
+    const qualifiedTable = (0, identifiers_1.quoteQualifiedTable)(schema, table);
+    const pkWhere = buildSqlWhereClause(pkColumns.map((column) => [column, record.pk[column]]), "pk", columnTypes);
+    const guardWhere = buildSqlWhereClause(Object.entries(record.guard).filter(([column]) => !pkColumns.includes(column)), "guard", columnTypes);
+    const whereClause = guardWhere ? `${pkWhere} AND ${guardWhere}` : pkWhere;
+    return `DELETE FROM ${qualifiedTable} WHERE ${whereClause};`;
+}
+function buildSqlWhereClause(entries, mode, columnTypes) {
+    const filteredEntries = entries.filter(([column, value]) => !(mode === "guard" && shouldSkipPointGuard(column, value)));
+    (0, identifiers_1.validateIdentifiers)(filteredEntries.map(([column]) => column), `${mode} column`);
+    return filteredEntries
+        .map(([column, value]) => {
+        const columnType = columnTypes?.[column];
+        const useJsonbComparison = mode === "guard" &&
+            (isJsonColumnType(columnType) || (!columnType && isPlainObject(value)));
+        const left = useJsonbComparison
+            ? `${(0, identifiers_1.quoteIdentifier)(column)}::jsonb`
+            : (0, identifiers_1.quoteIdentifier)(column);
+        return `${left} IS NOT DISTINCT FROM ${toSqlLiteral(value, useJsonbComparison ? "json_guard" : "value", column, columnType)}`;
+    })
+        .join(" AND ");
+}
+function toSqlLiteral(value, mode, columnName, columnType) {
+    if (value === null || value === undefined) {
+        return "NULL";
+    }
+    if (isJsonColumnType(columnType)) {
+        const jsonLiteral = sqlStringLiteral(JSON.stringify(value));
+        if (mode === "json_guard") {
+            return `${jsonLiteral}::jsonb`;
+        }
+        return `${jsonLiteral}::${columnType}`;
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new Error(`Cannot generate SQL for non-finite number: ${value}`);
+        }
+        return String(value);
+    }
+    if (typeof value === "boolean") {
+        return value ? "TRUE" : "FALSE";
+    }
+    if (typeof value === "string") {
+        const literal = sqlStringLiteral(value);
+        if (columnName && looksLikePointValue(columnName, value)) {
+            return `${literal}::point`;
+        }
+        return mode === "json_guard" ? `${literal}::jsonb` : literal;
+    }
+    if (Array.isArray(value)) {
+        return sqlStringLiteral(buildPostgresArrayLiteral(value));
+    }
+    if (isByteaValue(value)) {
+        return `decode(${sqlStringLiteral(value.$value)}, 'base64')`;
+    }
+    if (isPlainObject(value)) {
+        const literal = sqlStringLiteral(JSON.stringify(value));
+        return mode === "json_guard" ? `${literal}::jsonb` : literal;
+    }
+    return sqlStringLiteral(String(value));
+}
+function sqlStringLiteral(value) {
+    return `'${value.replace(/'/g, "''")}'`;
+}
+function buildPostgresArrayLiteral(values) {
+    return `{${values.map((value) => buildPostgresArrayElement(value)).join(",")}}`;
+}
+function buildPostgresArrayElement(value) {
+    if (value === null || value === undefined) {
+        return "NULL";
+    }
+    if (Array.isArray(value)) {
+        return buildPostgresArrayLiteral(value);
+    }
+    if (typeof value === "number") {
+        if (!Number.isFinite(value)) {
+            throw new Error(`Cannot generate SQL for non-finite number: ${value}`);
+        }
+        return String(value);
+    }
+    if (typeof value === "boolean") {
+        return value ? "true" : "false";
+    }
+    if (isByteaValue(value)) {
+        return quotePostgresArrayString(value.$value);
+    }
+    if (isPlainObject(value)) {
+        return quotePostgresArrayString(JSON.stringify(value));
+    }
+    return quotePostgresArrayString(String(value));
+}
+function quotePostgresArrayString(value) {
+    return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function summarizeDataSqlWork(tableDiff, options) {
+    const insertsToApply = options.applyInserts ? tableDiff.inserts.length : 0;
+    const updatesToApply = options.applyUpdates ? tableDiff.updates.length : 0;
+    const deletesToApply = options.applyDeletes ? tableDiff.deletes.length : 0;
+    return `processing ${insertsToApply} insert(s), ${updatesToApply} update(s), ${deletesToApply} delete(s)`;
+}
+function reportProgress(callback, message) {
+    if (callback) {
+        callback(message);
+    }
+}
+function isPlainObject(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        !isByteaValue(value));
+}
+function isByteaValue(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        !Array.isArray(value) &&
+        value["$type"] === "bytea" &&
+        typeof value["$value"] === "string");
+}
+function looksLikePointValue(columnName, value) {
+    return (columnName.toLowerCase().includes("point") &&
+        /^\(\s*-?\d+(?:\.\d+)?\s*,\s*-?\d+(?:\.\d+)?\s*\)$/.test(value));
+}
+function shouldSkipPointGuard(columnName, value) {
+    return typeof value === "string" && looksLikePointValue(columnName, value);
+}
+function isJsonColumnType(columnType) {
+    const normalizedColumnType = columnType?.toLowerCase();
+    return normalizedColumnType === "json" || normalizedColumnType === "jsonb";
+}
+//# sourceMappingURL=generate-sql.js.map

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "frg-data-diff",
+  "version": "2.0.0",
+  "description": "Safe PostgreSQL data diff and apply tooling. Compare data between two PostgreSQL databases and apply changes safely.",
+  "bin": "./dist/cli/root.js",
+  "scripts": {
+    "build": "tsc",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm run typecheck && npm run test:unit",
+    "test": "npm run test:unit && npm run test:integration && npm run test:guided",
+    "test:unit": "./scripts/preserve-envrc.sh vitest run tests/unit",
+    "pretest:integration": "docker compose down -v --remove-orphans && docker compose up -d --wait",
+    "test:integration": "./scripts/preserve-envrc.sh vitest run tests/integration",
+    "posttest:integration": "docker compose down -v --remove-orphans",
+    "test:guided": "./guided-manual-tests/run-all.sh",
+    "typecheck": "tsc --noEmit",
+    "lint": "npx prettier --write ."
+  },
+  "dependencies": {
+    "commander": "^12.0.0",
+    "pg": "^8.11.0",
+    "yaml": "^2.9.0",
+    "zod": "^3.22.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "@types/pg": "^8.11.0",
+    "@vitest/coverage-v8": "^3.1.0",
+    "eslint": "^8.57.0",
+    "@typescript-eslint/parser": "^7.0.0",
+    "@typescript-eslint/eslint-plugin": "^7.0.0",
+    "typescript": "^5.4.0",
+    "vitest": "^3.1.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "license": "MIT"
+}