frg-data-diff 2.0.0

package/dist/cli/pg-triggers.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=pg-triggers.d.ts.map

package/dist/cli/pg-triggers.js

@@ -0,0 +1,185 @@
+"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 });
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const commander_1 = require("commander");
+const load_config_1 = require("../config/load-config");
+const resolve_options_1 = require("../config/resolve-options");
+const connection_1 = require("../db/connection");
+const pg_triggers_diff_1 = require("../diff/pg-triggers-diff");
+const program = new commander_1.Command();
+program
+    .name("frg-data-diff pg-triggers")
+    .description("Compare PostgreSQL triggers and functions and write a SQL diff script.")
+    .option("--source-pg-host <host>", "Source database host")
+    .option("--source-pg-port <port>", "Source database port", (v) => parseInt(v, 10))
+    .option("--source-pg-database <db>", "Source database name")
+    .option("--source-pg-user <user>", "Source database user")
+    .option("--source-pg-password-env <value>", "Source DB password or $ENV_VAR reference")
+    .option("--source-pg-ssl", "Use SSL for source database connection")
+    .option("--no-source-pg-ssl", "Do not use SSL for source database connection")
+    .option("--dest-pg-host <host>", "Destination database host")
+    .option("--dest-pg-port <port>", "Destination database port", (v) => parseInt(v, 10))
+    .option("--dest-pg-database <db>", "Destination database name")
+    .option("--dest-pg-user <user>", "Destination database user")
+    .option("--dest-pg-password-env <value>", "Destination DB password or $ENV_VAR reference")
+    .option("--dest-pg-ssl", "Use SSL for destination database connection")
+    .option("--no-dest-pg-ssl", "Do not use SSL for destination database connection")
+    .option("--schema <schema>", "PostgreSQL schema to compare")
+    .option("--table <table...>", "Table(s) to include")
+    .option("--exclude-table <table...>", "Table(s) to exclude")
+    .option("--output <file>", "Output diff file path", "frg-triggers-diff.sql")
+    .option("--verbose", "Enable verbose logging")
+    .option("--config <file>", "Path to config file", load_config_1.DEFAULT_CONFIG_FILENAME);
+program.parse(process.argv);
+const opts = program.opts();
+function normalizeOptionalBoolean(value) {
+    if (value === true)
+        return true;
+    if (value === false)
+        return false;
+    return undefined;
+}
+async function main() {
+    const configFilePath = path.resolve(opts["config"] || load_config_1.DEFAULT_CONFIG_FILENAME);
+    const configExists = fs.existsSync(configFilePath);
+    let generatorConfig = undefined;
+    if (configExists) {
+        const loadedConfig = (0, load_config_1.loadConfig)(configFilePath);
+        generatorConfig = loadedConfig.generator;
+    }
+    const cliArgs = {
+        sourcePgHost: opts["sourcePgHost"],
+        sourcePgPort: opts["sourcePgPort"],
+        sourcePgDatabase: opts["sourcePgDatabase"],
+        sourcePgUser: opts["sourcePgUser"],
+        sourcePgPassword: opts["sourcePgPasswordEnv"],
+        sourcePgSsl: normalizeOptionalBoolean(opts["sourcePgSsl"]),
+        destPgHost: opts["destPgHost"],
+        destPgPort: opts["destPgPort"],
+        destPgDatabase: opts["destPgDatabase"],
+        destPgUser: opts["destPgUser"],
+        destPgPassword: opts["destPgPasswordEnv"],
+        destPgSsl: normalizeOptionalBoolean(opts["destPgSsl"]),
+        schema: opts["schema"],
+        pgTriggersTables: opts["table"],
+        pgTriggersExcludeTables: opts["excludeTable"],
+        pgTriggersOutput: opts["output"],
+        verbose: opts["verbose"] ? true : undefined,
+    };
+    const cleanCliArgs = Object.fromEntries(Object.entries(cliArgs).filter(([, v]) => v !== undefined));
+    const resolved = (0, resolve_options_1.resolveGeneratorOptions)(generatorConfig, cleanCliArgs);
+    const runtimeResolved = (0, resolve_options_1.resolveRuntimeGeneratorOptions)({
+        ...resolved,
+        tables: [...resolved.tables],
+        excludeTables: [...resolved.excludeTables],
+        schemaDiffTables: [...resolved.schemaDiffTables],
+        schemaDiffExcludeTables: [...resolved.schemaDiffExcludeTables],
+        pgTriggersTables: [...resolved.pgTriggersTables],
+        pgTriggersExcludeTables: [...resolved.pgTriggersExcludeTables],
+        ignoreColumns: [...resolved.ignoreColumns],
+    });
+    console.log("frg-data-diff: generate pg-triggers");
+    if (!resolved.sourcePgHost || !resolved.destPgHost) {
+        console.error("Missing generator configuration. Please run with full arguments or define config.");
+        process.exit(1);
+    }
+    const sourceConnection = (0, connection_1.resolveConnectionParams)({
+        host: resolved.sourcePgHost,
+        port: resolved.sourcePgPort,
+        database: resolved.sourcePgDatabase,
+        user: resolved.sourcePgUser,
+        password: resolved.sourcePgPassword,
+        ssl: runtimeResolved.sourcePgSsl,
+    }, {
+        host: "source host",
+        port: "source port",
+        database: "source database",
+        user: "source user",
+        password: "source password",
+    });
+    const destConnection = (0, connection_1.resolveConnectionParams)({
+        host: resolved.destPgHost,
+        port: resolved.destPgPort,
+        database: resolved.destPgDatabase,
+        user: resolved.destPgUser,
+        password: resolved.destPgPassword,
+        ssl: runtimeResolved.destPgSsl,
+    }, {
+        host: "dest host",
+        port: "dest port",
+        database: "dest database",
+        user: "dest user",
+        password: "dest password",
+    });
+    const sourcePool = (0, connection_1.createPool)(sourceConnection);
+    const destPool = (0, connection_1.createPool)(destConnection);
+    try {
+        console.log("Preparing pg-triggers diff...");
+        const diffOptions = {
+            schema: runtimeResolved.schema,
+            tables: runtimeResolved.pgTriggersTables,
+            excludeTables: runtimeResolved.pgTriggersExcludeTables,
+            verbose: runtimeResolved.verbose,
+            onProgress: (message) => {
+                console.log(message);
+            },
+            onVerboseProgress: runtimeResolved.verbose
+                ? (message) => {
+                    console.log(message);
+                }
+                : undefined,
+        };
+        const sql = await (0, pg_triggers_diff_1.generatePgTriggersDiffSql)(sourcePool, destPool, diffOptions);
+        const output = runtimeResolved.pgTriggersOutput;
+        fs.writeFileSync(output, sql, "utf-8");
+        console.log(`Wrote triggers and functions diff SQL to ${output}`);
+    }
+    catch (error) {
+        console.error("Failed to generate pg-triggers diff.");
+        console.error(error.message);
+        process.exit(1);
+    }
+    finally {
+        await sourcePool.end();
+        await destPool.end();
+    }
+}
+main().catch((err) => {
+    console.error("Unhandled error:", err);
+    process.exit(1);
+});
+//# sourceMappingURL=pg-triggers.js.map

package/dist/cli/root.d.ts

@@ -0,0 +1,8 @@
+#!/usr/bin/env node
+/**
+ * frg-data-diff
+ *
+ * Root CLI dispatcher. Routes subcommands to the focused tools.
+ */
+export {};
+//# sourceMappingURL=root.d.ts.map

package/dist/cli/root.js

@@ -0,0 +1,231 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * frg-data-diff
+ *
+ * Root CLI dispatcher. Routes subcommands to the focused tools.
+ */
+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 });
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const subcommand = process.argv[2];
+const subcommandArgs = process.argv.slice(3);
+const commandFiles = {
+    generate: "generator.js",
+    apply: "apply.js",
+    sql: "sql.js",
+    "pg-triggers": "pg-triggers.js",
+};
+const helpText = `frg-data-diff
+
+Usage:
+
+  npx frg-data-diff <command> [options]
+
+Commands:
+
+  generate     Compare source and destination PostgreSQL databases and write diff artifacts.
+  apply        Read a JSON diff file and safely apply it to a destination PostgreSQL database.
+  sql          Read a JSON diff file and write a plain SQL script for manual review and execution.
+  pg-triggers  Compare PostgreSQL triggers and functions and write a SQL diff script.
+  version      Print the package version.
+
+Basic usage:
+
+  npx frg-data-diff generate
+  npx frg-data-diff apply --dry-run
+  npx frg-data-diff apply --execute
+  npx frg-data-diff sql --yes
+  npx frg-data-diff pg-triggers
+  npx frg-data-diff version
+
+Config file:
+  .frg-data-diff.config.json
+
+  Commands look for .frg-data-diff.config.json in the current directory.
+  Create it by running a command with --config or with CLI args on first run.
+
+How to generate a diff:
+
+  npx frg-data-diff generate \\
+    --source-pg-host dev-db.example.com \\
+    --source-pg-port 5432 \\
+    --source-pg-database app \\
+    --source-pg-user app_user \\
+    --source-pg-password-env '$PG_PASSWORD_DEV' \\
+    --dest-pg-host prod-db.example.com \\
+    --dest-pg-port 5432 \\
+    --dest-pg-database app \\
+    --dest-pg-user app_user \\
+    --dest-pg-password-env '$PG_PASSWORD_PROD' \\
+    --schema public \\
+    --output frg-data-diff.json \\
+    --include-deletes \\
+    --pretty
+
+How to apply a diff (dry-run first):
+
+  npx frg-data-diff apply \\
+    --dest-pg-host prod-db.example.com \\
+    --dest-pg-port 5432 \\
+    --dest-pg-database app \\
+    --dest-pg-user app_user \\
+    --dest-pg-password-env '$PG_PASSWORD_PROD' \\
+    --input frg-data-diff.json \\
+    --dry-run
+
+How to apply a diff (real execution):
+
+  npx frg-data-diff apply \\
+    --dest-pg-host prod-db.example.com \\
+    --dest-pg-port 5432 \\
+    --dest-pg-database app \\
+    --dest-pg-user app_user \\
+    --dest-pg-password-env '$PG_PASSWORD_PROD' \\
+    --input frg-data-diff.json \\
+    --execute
+
+How to generate SQL from a diff:
+
+  npx frg-data-diff sql \\
+    --input frg-data-diff.json \\
+    --output frg-data-diff.sql \\
+    --apply-deletes \\
+    --yes
+
+Config file example (.frg-data-diff.config.json):
+
+  {
+    "format": "frg-data-diff-config/v1",
+    "generator": {
+      "sourcePgHost": "dev-db.example.com",
+      "sourcePgPort": 5432,
+      "sourcePgDatabase": "app",
+      "sourcePgUser": "app_user",
+      "sourcePgPassword": "$PG_PASSWORD_DEV",
+      "destPgHost": "prod-db.example.com",
+      "destPgPort": 5432,
+      "destPgDatabase": "app",
+      "destPgUser": "app_user",
+      "destPgPassword": "$PG_PASSWORD_PROD",
+      "schema": "public",
+      "tables": ["my_table"],
+      "output": "frg-data-diff.json",
+      "schemaDiffTables": ["my_table"],
+      "schemaDiffOutput": "frg-schema-diff.json",
+      "pgTriggersTables": ["my_table"],
+      "pgTriggersOutput": "frg-triggers-diff.sql",
+      "includeDeletes": true,
+      "pretty": true
+    },
+    "apply": {
+      "destPgHost": "prod-db.example.com",
+      "destPgPort": 5432,
+      "destPgDatabase": "app",
+      "destPgUser": "app_user",
+      "destPgPassword": "$PG_PASSWORD_PROD",
+      "input": "frg-data-diff.json",
+      "dryRun": true,
+      "applyDeletes": false
+    }
+  }
+
+Safety notes:
+
+  - Do not commit secrets (passwords, connection strings) to version control.
+  - Connection values may be plain text or $ENV_VAR references.
+  - Passwords may be plain text, but $ENV_VAR is strongly recommended.
+  - Missing env vars will cause a clear error showing only the env var name, never the value.
+  - Apply defaults to dry-run mode. Use --execute to apply real changes.
+  - applyDeletes defaults to false. Deletes require explicit opt-in.
+  - Use --yes for CI/CD to skip interactive confirmation.
+  - If you choose plain-text passwords, they will be written exactly that way to the config file.
+
+For CI/CD:
+
+  npx frg-data-diff generate --yes
+  npx frg-data-diff apply --yes --execute
+`;
+if (!subcommand || subcommand === "--help" || subcommand === "-h") {
+    process.stdout.write(helpText);
+    process.exit(0);
+}
+if (subcommand === "version" ||
+    subcommand === "--version" ||
+    subcommand === "-v") {
+    console.log(readPackageVersion());
+    process.exit(0);
+}
+const commandFile = commandFiles[subcommand];
+if (!commandFile) {
+    console.error(`Unknown command: ${subcommand}`);
+    console.error("");
+    process.stderr.write(helpText);
+    process.exit(1);
+}
+const commandPath = path.join(__dirname, commandFile);
+if (!fs.existsSync(commandPath)) {
+    console.error(`Command file not found: ${commandPath}`);
+    console.error("Run npm run build and try again.");
+    process.exit(1);
+}
+const result = (0, child_process_1.spawnSync)(process.execPath, [commandPath, ...subcommandArgs], {
+    stdio: "inherit",
+});
+if (result.error) {
+    console.error(result.error.message);
+    process.exit(1);
+}
+if (result.signal) {
+    console.error(`Command terminated by signal: ${result.signal}`);
+    process.exit(1);
+}
+process.exit(result.status ?? 0);
+function readPackageVersion() {
+    const packagePath = path.resolve(__dirname, "../../package.json");
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(packagePath, "utf-8"));
+        if (typeof packageJson.version === "string" && packageJson.version) {
+            return packageJson.version;
+        }
+    }
+    catch {
+        // Fall through to a clear, stable value if package metadata is unavailable.
+    }
+    return "unknown";
+}
+//# sourceMappingURL=root.js.map

package/dist/cli/sql.d.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+/**
+ * frg-data-diff sql
+ *
+ * Reads a JSON diff file and writes a plain SQL script that can be reviewed
+ * and executed manually.
+ */
+export {};
+//# sourceMappingURL=sql.d.ts.map

package/dist/cli/sql.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * frg-data-diff sql
+ *
+ * Reads a JSON diff file and writes a plain SQL script that can be reviewed
+ * and executed manually.
+ */
+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 });
+const commander_1 = require("commander");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const load_config_1 = require("../config/load-config");
+const resolve_options_1 = require("../config/resolve-options");
+const diff_schema_1 = require("../diff/diff-schema");
+const generate_sql_1 = require("../sql/generate-sql");
+const prompts_1 = require("../shared/prompts");
+const program = new commander_1.Command();
+program
+    .name("frg-data-diff sql")
+    .description("Reads a JSON diff file and writes a SQL script for manual execution.")
+    .option("--input <file>", "Input diff file path")
+    .option("--output <file>", "Output SQL file path")
+    .option("--apply-inserts", "Include inserts in the SQL output")
+    .option("--no-apply-inserts", "Do not include inserts in the SQL output")
+    .option("--apply-updates", "Include updates in the SQL output")
+    .option("--no-apply-updates", "Do not include updates in the SQL output")
+    .option("--apply-deletes", "Include deletes in the SQL output")
+    .option("--no-apply-deletes", "Do not include deletes in the SQL output")
+    .option("--transaction", "Wrap the SQL in BEGIN/COMMIT")
+    .option("--no-transaction", "Do not wrap the SQL in BEGIN/COMMIT")
+    .option("--config <file>", "Path to config file", load_config_1.DEFAULT_CONFIG_FILENAME)
+    .option("--yes", "Skip interactive confirmation");
+program.parse(process.argv);
+const opts = program.opts();
+async function main() {
+    const configFilePath = path.resolve(opts["config"] || load_config_1.DEFAULT_CONFIG_FILENAME);
+    const configExists = fs.existsSync(configFilePath);
+    const config = configExists ? (0, load_config_1.loadConfig)(configFilePath) : undefined;
+    const rawApplyOptions = (0, resolve_options_1.resolveApplyOptions)(config?.apply, {
+        input: opts["input"],
+        applyInserts: normalizeOptionalBoolean(opts["applyInserts"]),
+        applyUpdates: normalizeOptionalBoolean(opts["applyUpdates"]),
+        applyDeletes: normalizeOptionalBoolean(opts["applyDeletes"]),
+        transaction: normalizeOptionalBoolean(opts["transaction"]),
+    });
+    const runtimeApplyOptions = (0, resolve_options_1.resolveRuntimeApplyOptions)(rawApplyOptions);
+    const input = runtimeApplyOptions.input;
+    const output = opts["output"]
+        ? path.resolve(opts["output"])
+        : path.resolve((0, generate_sql_1.buildSqlOutputPath)(input));
+    const applyInserts = runtimeApplyOptions.applyInserts;
+    const applyUpdates = runtimeApplyOptions.applyUpdates;
+    const applyDeletes = runtimeApplyOptions.applyDeletes;
+    const transaction = runtimeApplyOptions.transaction;
+    const inputPath = path.resolve(input);
+    const outputPath = output;
+    if (!fs.existsSync(inputPath)) {
+        console.error(`Error: Diff file not found: ${inputPath}`);
+        process.exit(1);
+    }
+    printResolvedPlan({
+        inputPath,
+        outputPath,
+        applyInserts,
+        applyUpdates,
+        applyDeletes,
+        transaction,
+    });
+    if (!opts["yes"]) {
+        const proceed = await (0, prompts_1.confirmProceed)();
+        if (!proceed) {
+            console.log("Aborted.");
+            process.exit(0);
+        }
+    }
+    let rawDiff;
+    try {
+        rawDiff = JSON.parse(fs.readFileSync(inputPath, "utf-8"));
+    }
+    catch (err) {
+        console.error(`Error reading diff file: ${inputPath}`);
+        if (err instanceof Error)
+            console.error(err.message);
+        process.exit(1);
+    }
+    const diff = (0, diff_schema_1.validateDiffJson)(rawDiff);
+    const result = (0, generate_sql_1.generateSqlScript)(diff, {
+        applyInserts,
+        applyUpdates,
+        applyDeletes,
+        transaction,
+    });
+    fs.writeFileSync(outputPath, result.sql, "utf-8");
+    console.log(`\nSQL written to: ${outputPath}`);
+    console.log("\nSummary:");
+    console.log(`  Inserts: ${result.summary.inserts}`);
+    console.log(`  Updates: ${result.summary.updates}`);
+    console.log(`  Deletes: ${result.summary.deletes}`);
+    console.log("\nReview the SQL carefully before executing it.");
+}
+function printResolvedPlan(args) {
+    console.log("\ntool:");
+    console.log("  frg-data-diff sql");
+    console.log(`\ninput: ${args.inputPath}`);
+    console.log(`output: ${args.outputPath}`);
+    console.log(`apply inserts: ${args.applyInserts}`);
+    console.log(`apply updates: ${args.applyUpdates}`);
+    console.log(`apply deletes: ${args.applyDeletes}`);
+    console.log(`transaction: ${args.transaction}`);
+}
+main().catch((err) => {
+    console.error("Fatal error:", err instanceof Error ? err.message : String(err));
+    process.exit(1);
+});
+function normalizeOptionalBoolean(value) {
+    if (value === true) {
+        return true;
+    }
+    if (value === false) {
+        return false;
+    }
+    return undefined;
+}
+//# sourceMappingURL=sql.js.map