frg-data-diff 2.0.0

package/dist/diff/pg-triggers-diff.js

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generatePgTriggersDiffSql = generatePgTriggersDiffSql;
+const metadata_1 = require("../db/metadata");
+const pg_triggers_1 = require("../db/pg-triggers");
+async function generatePgTriggersDiffSql(sourcePool, destPool, options) {
+    reportProgress(options.onProgress, "PostgreSQL triggers: resolving requested table patterns");
+    const { tables } = await (0, metadata_1.resolveTablePatterns)(sourcePool, destPool, options.schema, options.tables, options.excludeTables);
+    reportProgress(options.onProgress, `PostgreSQL triggers: comparing ${tables.length} table(s)`);
+    const sourceClient = await sourcePool.connect();
+    const destClient = await destPool.connect();
+    let sql = `-- PostgreSQL Triggers and Functions Diff\n`;
+    sql += `-- Generated automatically\n\n`;
+    try {
+        reportProgress(options.onProgress, "PostgreSQL triggers: fetching trigger and function definitions from source");
+        const sourceData = await (0, pg_triggers_1.fetchTriggersAndFunctionsForTables)(sourceClient, options.schema, tables, {
+            onTableStart: (table, tablePosition, totalTables) => {
+                reportProgress(options.onProgress, `[pg-triggers source ${tablePosition}/${totalTables}] ${options.schema}.${table}: fetching definitions`);
+            },
+        });
+        reportProgress(options.onProgress, "PostgreSQL triggers: fetching trigger and function definitions from destination");
+        const destData = await (0, pg_triggers_1.fetchTriggersAndFunctionsForTables)(destClient, options.schema, tables, {
+            onTableStart: (table, tablePosition, totalTables) => {
+                reportProgress(options.onProgress, `[pg-triggers dest ${tablePosition}/${totalTables}] ${options.schema}.${table}: fetching definitions`);
+            },
+        });
+        const sourceTablesMap = new Map(sourceData.map((d) => [d.table, d]));
+        const destTablesMap = new Map(destData.map((d) => [d.table, d]));
+        const allAddedFunctions = [];
+        const allDroppedFunctions = [];
+        const allAddedTriggers = [];
+        const allDroppedTriggers = [];
+        const sourceFunctionsMap = new Map();
+        const destFunctionsMap = new Map();
+        reportProgress(options.onProgress, "PostgreSQL triggers: indexing function definitions");
+        for (const data of sourceData) {
+            for (const fn of data.functions) {
+                sourceFunctionsMap.set(`${fn.functionSchema}.${fn.functionName}`, fn);
+            }
+        }
+        for (const data of destData) {
+            for (const fn of data.functions) {
+                destFunctionsMap.set(`${fn.functionSchema}.${fn.functionName}`, fn);
+            }
+        }
+        // Determine function diffs globally across the requested tables
+        for (const [key, sourceFn] of sourceFunctionsMap) {
+            const destFn = destFunctionsMap.get(key);
+            if (!destFn ||
+                destFn.functionDefinition !== sourceFn.functionDefinition) {
+                allAddedFunctions.push(sourceFn);
+            }
+        }
+        for (const [key, destFn] of destFunctionsMap) {
+            const sourceFn = sourceFunctionsMap.get(key);
+            if (!sourceFn) {
+                allDroppedFunctions.push(destFn);
+            }
+        }
+        reportProgress(options.onProgress, `PostgreSQL functions: ${allAddedFunctions.length} function(s) to create or replace, ${allDroppedFunctions.length} function(s) to drop`);
+        // Determine trigger diffs per table
+        for (const [tableIndex, table] of tables.entries()) {
+            const progressLabel = formatPgTriggersProgressLabel(tableIndex + 1, tables.length, options.schema, table);
+            const sourceMeta = sourceTablesMap.get(table);
+            const destMeta = destTablesMap.get(table);
+            const sourceTriggersMap = new Map(sourceMeta?.triggers.map((t) => [t.triggerName, t]) ?? []);
+            const destTriggersMap = new Map(destMeta?.triggers.map((t) => [t.triggerName, t]) ?? []);
+            let addedTriggersForTable = 0;
+            let droppedTriggersForTable = 0;
+            reportProgress(options.onProgress, `${progressLabel}: comparing triggers`);
+            for (const [triggerName, sourceTrigger] of sourceTriggersMap) {
+                const destTrigger = destTriggersMap.get(triggerName);
+                if (!destTrigger ||
+                    destTrigger.triggerDefinition !== sourceTrigger.triggerDefinition) {
+                    if (destTrigger) {
+                        allDroppedTriggers.push({ table, triggerName });
+                        droppedTriggersForTable++;
+                    }
+                    allAddedTriggers.push(sourceTrigger);
+                    addedTriggersForTable++;
+                }
+            }
+            for (const [triggerName] of destTriggersMap) {
+                if (!sourceTriggersMap.has(triggerName)) {
+                    allDroppedTriggers.push({ table, triggerName });
+                    droppedTriggersForTable++;
+                }
+            }
+            reportProgress(options.onProgress, `${progressLabel}: ${addedTriggersForTable} trigger(s) to create or replace, ${droppedTriggersForTable} trigger(s) to drop`);
+        }
+        // Generate SQL
+        if (allDroppedTriggers.length === 0 &&
+            allDroppedFunctions.length === 0 &&
+            allAddedFunctions.length === 0 &&
+            allAddedTriggers.length === 0) {
+            reportProgress(options.onProgress, "PostgreSQL triggers: no differences found");
+            sql += `-- No differences found.\n`;
+            return sql;
+        }
+        reportProgress(options.onProgress, "PostgreSQL triggers: generating SQL script");
+        // We must drop triggers before dropping functions, otherwise it's a dependency violation
+        if (allDroppedTriggers.length > 0) {
+            sql += `-- Drop removed or modified triggers\n`;
+            for (const drop of allDroppedTriggers) {
+                sql += `DROP TRIGGER IF EXISTS "${drop.triggerName}" ON "${options.schema}"."${drop.table}";\n`;
+            }
+            sql += `\n`;
+        }
+        if (allDroppedFunctions.length > 0) {
+            sql += `-- Drop removed functions\n`;
+            for (const drop of allDroppedFunctions) {
+                sql += `DROP FUNCTION IF EXISTS "${drop.functionSchema}"."${drop.functionName}"();\n`;
+            }
+            sql += `\n`;
+        }
+        if (allAddedFunctions.length > 0) {
+            sql += `-- Create or replace functions\n`;
+            for (const fn of allAddedFunctions) {
+                let def = fn.functionDefinition.trim();
+                if (def.toUpperCase().startsWith("CREATE FUNCTION")) {
+                    def =
+                        "CREATE OR REPLACE FUNCTION" +
+                            def.substring("CREATE FUNCTION".length);
+                }
+                if (!def.endsWith(";")) {
+                    def += ";";
+                }
+                sql += `${def}\n\n`;
+            }
+        }
+        if (allAddedTriggers.length > 0) {
+            sql += `-- Create new or modified triggers\n`;
+            for (const trg of allAddedTriggers) {
+                let def = trg.triggerDefinition.trim();
+                if (def.toUpperCase().startsWith("CREATE TRIGGER")) {
+                    def =
+                        "CREATE OR REPLACE TRIGGER" +
+                            def.substring("CREATE TRIGGER".length);
+                }
+                if (!def.endsWith(";")) {
+                    def += ";";
+                }
+                sql += `${def}\n\n`;
+            }
+        }
+    }
+    finally {
+        sourceClient.release();
+        destClient.release();
+    }
+    return sql;
+}
+function formatPgTriggersProgressLabel(tablePosition, totalTables, schema, table) {
+    return `[pg-triggers ${tablePosition}/${totalTables}] ${schema}.${table}`;
+}
+function reportProgress(callback, message) {
+    if (callback) {
+        callback(message);
+    }
+}
+//# sourceMappingURL=pg-triggers-diff.js.map

package/dist/diff/serialize-value.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Value serialization utilities for converting PostgreSQL values to/from
+ * JSON-compatible representations in the diff file.
+ */
+/**
+ * Serializes a PostgreSQL value for storage in the diff JSON file.
+ * - Buffer (bytea) -> {$type:'bytea', $value: base64}
+ * - pg geometric types (point, circle, lseg, line, box, path) -> string literals
+ * - Date -> ISO 8601 string
+ * - BigInt -> string (to preserve precision)
+ * - null/undefined -> null
+ * - Objects/arrays -> recursively serialized
+ * - Everything else -> as-is
+ *
+ * @param value - The value to serialize
+ * @param dataType - Optional PostgreSQL data type name to guide serialization of ambiguous types
+ */
+export declare function serializeValue(value: unknown, dataType?: string): unknown;
+/**
+ * Deserializes a value from the diff JSON back to the form expected by pg.
+ * - {$type: 'bytea', $value: '<base64>'} -> Buffer
+ * - everything else -> as-is
+ */
+export declare function deserializeValue(value: unknown): unknown;
+/**
+ * Compares two serialized values for equality.
+ * - null vs null is equal
+ * - JSON objects are compared structurally (key order does not matter)
+ * - Arrays are compared element-wise
+ * - Primitives use strict equality
+ *
+ * This is used for jsonb structural comparison and general value comparison.
+ */
+export declare function valuesAreEqual(a: unknown, b: unknown): boolean;
+//# sourceMappingURL=serialize-value.d.ts.map

package/dist/diff/serialize-value.js

@@ -0,0 +1,242 @@
+"use strict";
+/**
+ * Value serialization utilities for converting PostgreSQL values to/from
+ * JSON-compatible representations in the diff file.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeValue = serializeValue;
+exports.deserializeValue = deserializeValue;
+exports.valuesAreEqual = valuesAreEqual;
+/**
+ * Serializes a PostgreSQL value for storage in the diff JSON file.
+ * - Buffer (bytea) -> {$type:'bytea', $value: base64}
+ * - pg geometric types (point, circle, lseg, line, box, path) -> string literals
+ * - Date -> ISO 8601 string
+ * - BigInt -> string (to preserve precision)
+ * - null/undefined -> null
+ * - Objects/arrays -> recursively serialized
+ * - Everything else -> as-is
+ *
+ * @param value - The value to serialize
+ * @param dataType - Optional PostgreSQL data type name to guide serialization of ambiguous types
+ */
+function serializeValue(value, dataType) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (Buffer.isBuffer(value)) {
+        // Encode bytea as base64 with a type tag
+        return { $type: "bytea", $value: value.toString("base64") };
+    }
+    if (value instanceof Date) {
+        return serializeDateValue(value, dataType);
+    }
+    if (typeof value === "bigint") {
+        return value.toString();
+    }
+    // pg returns numeric/decimal as strings - preserve as-is
+    if (typeof value === "string" ||
+        typeof value === "number" ||
+        typeof value === "boolean") {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((v) => serializeValue(v));
+    }
+    if (typeof value === "object") {
+        // Handle pg geometric types which are returned as plain objects.
+        // Use dataType to distinguish from jsonb objects that happen to have the same shape.
+        if (dataType) {
+            const geoStr = serializeGeometricValue(dataType, value);
+            if (geoStr !== null)
+                return geoStr;
+            // Serialize pg interval objects (returned as {years, months, days, hours, minutes, seconds, milliseconds})
+            // as PostgreSQL interval literal strings so they can be passed back as parameters.
+            if (dataType === "interval") {
+                return serializeIntervalValue(value);
+            }
+        }
+        // Serialize plain objects (jsonb, json, unknown objects)
+        return JSON.parse(JSON.stringify(value, (_k, v) => {
+            if (typeof v === "bigint")
+                return v.toString();
+            return v;
+        }));
+    }
+    return value;
+}
+function serializeDateValue(value, dataType) {
+    if (dataType === "date") {
+        return [
+            value.getFullYear(),
+            pad2(value.getMonth() + 1),
+            pad2(value.getDate()),
+        ].join("-");
+    }
+    if (dataType === "timestamp without time zone") {
+        const milliseconds = value.getMilliseconds();
+        const fractional = milliseconds > 0 ? `.${String(milliseconds).padStart(3, "0")}` : "";
+        return (`${value.getFullYear()}-${pad2(value.getMonth() + 1)}-${pad2(value.getDate())} ` +
+            `${pad2(value.getHours())}:${pad2(value.getMinutes())}:${pad2(value.getSeconds())}${fractional}`);
+    }
+    return value.toISOString();
+}
+function pad2(value) {
+    return String(value).padStart(2, "0");
+}
+/**
+ * Attempts to serialize a known PostgreSQL geometric type to its string literal form.
+ * Returns null if the dataType is not a known geometric type.
+ *
+ * PostgreSQL accepts these string forms as input for geometric types:
+ *  point:   (x,y)
+ *  circle:  <(x,y),r>
+ *  lseg:    ((x1,y1),(x2,y2))
+ *  box:     ((x1,y1),(x2,y2))
+ *  line:    {a,b,c}
+ *  path:    ((x1,y1),...) for closed, (x1,y1,...) for open
+ */
+function serializeGeometricValue(dataType, obj) {
+    switch (dataType) {
+        case "point":
+            if ("x" in obj && "y" in obj) {
+                return `(${obj["x"]},${obj["y"]})`;
+            }
+            return null;
+        case "circle":
+            if ("x" in obj && "y" in obj && "radius" in obj) {
+                return `<(${obj["x"]},${obj["y"]}),${obj["radius"]}>`;
+            }
+            return null;
+        case "lseg":
+        case "box":
+            if ("x1" in obj && "y1" in obj && "x2" in obj && "y2" in obj) {
+                return `((${obj["x1"]},${obj["y1"]}),(${obj["x2"]},${obj["y2"]}))`;
+            }
+            return null;
+        case "line":
+            if ("a" in obj && "b" in obj && "c" in obj) {
+                return `{${obj["a"]},${obj["b"]},${obj["c"]}}`;
+            }
+            return null;
+        case "path":
+            if ("points" in obj && Array.isArray(obj["points"])) {
+                const points = obj["points"]
+                    .map((p) => `(${p.x},${p.y})`)
+                    .join(",");
+                const closed = obj["closed"];
+                return closed ? `(${points})` : `[${points}]`;
+            }
+            return null;
+        case "polygon":
+            if (Array.isArray(obj)) {
+                // polygon is returned as an array of {x,y} points by pg
+                return null; // handled above as Array case
+            }
+            return null;
+        default:
+            return null;
+    }
+}
+/**
+ * Serializes a pg interval object to a PostgreSQL interval literal string.
+ * pg returns interval values as { years?, months?, days?, hours?, minutes?, seconds?, milliseconds? }.
+ */
+function serializeIntervalValue(obj) {
+    const parts = [];
+    const years = Number(obj["years"] ?? 0);
+    const months = Number(obj["months"] ?? 0);
+    const days = Number(obj["days"] ?? 0);
+    const hours = Number(obj["hours"] ?? 0);
+    const minutes = Number(obj["minutes"] ?? 0);
+    const seconds = Number(obj["seconds"] ?? 0);
+    const ms = Number(obj["milliseconds"] ?? 0);
+    if (years)
+        parts.push(`${years} year${Math.abs(years) !== 1 ? "s" : ""}`);
+    if (months)
+        parts.push(`${months} month${Math.abs(months) !== 1 ? "s" : ""}`);
+    if (days)
+        parts.push(`${days} day${Math.abs(days) !== 1 ? "s" : ""}`);
+    const totalSeconds = seconds + ms / 1000;
+    if (hours || minutes || totalSeconds) {
+        const h = String(Math.abs(hours)).padStart(2, "0");
+        const m = String(Math.abs(minutes)).padStart(2, "0");
+        const s = Math.abs(totalSeconds)
+            .toFixed(totalSeconds % 1 !== 0 ? 6 : 0)
+            .padStart(2, "0");
+        const sign = hours < 0 ||
+            (hours === 0 && minutes < 0) ||
+            (hours === 0 && minutes === 0 && totalSeconds < 0)
+            ? "-"
+            : "";
+        parts.push(`${sign}${h}:${m}:${s}`);
+    }
+    return parts.length > 0 ? parts.join(" ") : "0";
+}
+/**
+ * Deserializes a value from the diff JSON back to the form expected by pg.
+ * - {$type: 'bytea', $value: '<base64>'} -> Buffer
+ * - everything else -> as-is
+ */
+function deserializeValue(value) {
+    if (value === null || value === undefined) {
+        return null;
+    }
+    if (typeof value === "object" &&
+        !Array.isArray(value) &&
+        value["$type"] === "bytea") {
+        const b64 = value["$value"];
+        return Buffer.from(b64, "base64");
+    }
+    if (Array.isArray(value)) {
+        return value.map(deserializeValue);
+    }
+    return value;
+}
+/**
+ * Compares two serialized values for equality.
+ * - null vs null is equal
+ * - JSON objects are compared structurally (key order does not matter)
+ * - Arrays are compared element-wise
+ * - Primitives use strict equality
+ *
+ * This is used for jsonb structural comparison and general value comparison.
+ */
+function valuesAreEqual(a, b) {
+    if (a === b)
+        return true;
+    if (a === null && b === null)
+        return true;
+    if (a === null || b === null)
+        return false;
+    // Compare Buffer-encoded bytea
+    if (typeof a === "object" &&
+        typeof b === "object" &&
+        a["$type"] === "bytea" &&
+        b["$type"] === "bytea") {
+        return (a["$value"] ===
+            b["$value"]);
+    }
+    if (Array.isArray(a) && Array.isArray(b)) {
+        if (a.length !== b.length)
+            return false;
+        return a.every((v, i) => valuesAreEqual(v, b[i]));
+    }
+    if (typeof a === "object" &&
+        typeof b === "object" &&
+        !Array.isArray(a) &&
+        !Array.isArray(b)) {
+        // Structural comparison for JSON/JSONB objects
+        const aKeys = Object.keys(a).sort();
+        const bKeys = Object.keys(b).sort();
+        if (aKeys.length !== bKeys.length)
+            return false;
+        if (!aKeys.every((k, i) => k === bKeys[i]))
+            return false;
+        return aKeys.every((k) => valuesAreEqual(a[k], b[k]));
+    }
+    // Fall back to string comparison for numeric precision
+    // pg returns numeric as strings
+    return String(a) === String(b);
+}
+//# sourceMappingURL=serialize-value.js.map

package/dist/diff/write-diff-yaml.d.ts

@@ -0,0 +1,3 @@
+export declare function buildYamlOutputPath(jsonOutputPath: string): string;
+export declare function writeYamlFile(filePath: string, data: unknown): void;
+//# sourceMappingURL=write-diff-yaml.d.ts.map

package/dist/diff/write-diff-yaml.js

@@ -0,0 +1,48 @@
+"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.buildYamlOutputPath = buildYamlOutputPath;
+exports.writeYamlFile = writeYamlFile;
+const fs = __importStar(require("fs"));
+const yaml_1 = require("yaml");
+function buildYamlOutputPath(jsonOutputPath) {
+    return jsonOutputPath.endsWith(".json")
+        ? jsonOutputPath.replace(/\.json$/i, ".yaml")
+        : `${jsonOutputPath}.yaml`;
+}
+function writeYamlFile(filePath, data) {
+    fs.writeFileSync(filePath, (0, yaml_1.stringify)(data), "utf-8");
+}
+//# sourceMappingURL=write-diff-yaml.js.map

package/dist/schema-diff/generate-schema-diff.d.ts

@@ -0,0 +1,12 @@
+import { Pool } from "pg";
+import { type SchemaDiffJson } from "./schema-diff-schema";
+export interface GenerateSchemaDiffOptions {
+    schema: string;
+    tables: string[];
+    excludeTables: string[];
+    verbose: boolean;
+    onProgress?: (message: string) => void;
+    onVerboseProgress?: (message: string) => void;
+}
+export declare function generateSchemaDiff(sourcePool: Pool, destPool: Pool, options: GenerateSchemaDiffOptions): Promise<SchemaDiffJson>;
+//# sourceMappingURL=generate-schema-diff.d.ts.map