frg-data-diff 2.0.0

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

@@ -0,0 +1,380 @@
+import { z } from "zod";
+declare const changeValueSchema: z.ZodObject<{
+    from: z.ZodUnknown;
+    to: z.ZodUnknown;
+}, "strip", z.ZodTypeAny, {
+    from?: unknown;
+    to?: unknown;
+}, {
+    from?: unknown;
+    to?: unknown;
+}>;
+declare const updateRecordSchema: z.ZodObject<{
+    pk: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    changes: z.ZodRecord<z.ZodString, z.ZodObject<{
+        from: z.ZodUnknown;
+        to: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        from?: unknown;
+        to?: unknown;
+    }, {
+        from?: unknown;
+        to?: unknown;
+    }>>;
+    guard: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    pk: Record<string, unknown>;
+    changes: Record<string, {
+        from?: unknown;
+        to?: unknown;
+    }>;
+    guard: Record<string, unknown>;
+}, {
+    pk: Record<string, unknown>;
+    changes: Record<string, {
+        from?: unknown;
+        to?: unknown;
+    }>;
+    guard: Record<string, unknown>;
+}>;
+declare const insertRecordSchema: z.ZodObject<{
+    row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    row: Record<string, unknown>;
+}, {
+    row: Record<string, unknown>;
+}>;
+declare const deleteRecordSchema: z.ZodObject<{
+    pk: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    guard: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, "strip", z.ZodTypeAny, {
+    pk: Record<string, unknown>;
+    guard: Record<string, unknown>;
+}, {
+    pk: Record<string, unknown>;
+    guard: Record<string, unknown>;
+}>;
+declare const tableDiffSchema: z.ZodObject<{
+    schema: z.ZodString;
+    table: z.ZodString;
+    primaryKey: z.ZodArray<z.ZodString, "many">;
+    columnTypes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    updates: z.ZodArray<z.ZodObject<{
+        pk: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        changes: z.ZodRecord<z.ZodString, z.ZodObject<{
+            from: z.ZodUnknown;
+            to: z.ZodUnknown;
+        }, "strip", z.ZodTypeAny, {
+            from?: unknown;
+            to?: unknown;
+        }, {
+            from?: unknown;
+            to?: unknown;
+        }>>;
+        guard: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        pk: Record<string, unknown>;
+        changes: Record<string, {
+            from?: unknown;
+            to?: unknown;
+        }>;
+        guard: Record<string, unknown>;
+    }, {
+        pk: Record<string, unknown>;
+        changes: Record<string, {
+            from?: unknown;
+            to?: unknown;
+        }>;
+        guard: Record<string, unknown>;
+    }>, "many">;
+    inserts: z.ZodArray<z.ZodObject<{
+        row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        row: Record<string, unknown>;
+    }, {
+        row: Record<string, unknown>;
+    }>, "many">;
+    deletes: z.ZodArray<z.ZodObject<{
+        pk: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        guard: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        pk: Record<string, unknown>;
+        guard: Record<string, unknown>;
+    }, {
+        pk: Record<string, unknown>;
+        guard: Record<string, unknown>;
+    }>, "many">;
+}, "strip", z.ZodTypeAny, {
+    schema: string;
+    table: string;
+    primaryKey: string[];
+    updates: {
+        pk: Record<string, unknown>;
+        changes: Record<string, {
+            from?: unknown;
+            to?: unknown;
+        }>;
+        guard: Record<string, unknown>;
+    }[];
+    inserts: {
+        row: Record<string, unknown>;
+    }[];
+    deletes: {
+        pk: Record<string, unknown>;
+        guard: Record<string, unknown>;
+    }[];
+    columnTypes?: Record<string, string> | undefined;
+}, {
+    schema: string;
+    table: string;
+    primaryKey: string[];
+    updates: {
+        pk: Record<string, unknown>;
+        changes: Record<string, {
+            from?: unknown;
+            to?: unknown;
+        }>;
+        guard: Record<string, unknown>;
+    }[];
+    inserts: {
+        row: Record<string, unknown>;
+    }[];
+    deletes: {
+        pk: Record<string, unknown>;
+        guard: Record<string, unknown>;
+    }[];
+    columnTypes?: Record<string, string> | undefined;
+}>;
+export declare const diffJsonSchema: z.ZodObject<{
+    format: z.ZodLiteral<"postgres-data-diff-json/v1">;
+    generatedAt: z.ZodString;
+    source: z.ZodObject<{
+        schema: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        schema: string;
+    }, {
+        schema: string;
+    }>;
+    dest: z.ZodObject<{
+        schema: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        schema: string;
+    }, {
+        schema: string;
+    }>;
+    options: z.ZodObject<{
+        includeDeletes: z.ZodBoolean;
+        ignoredColumns: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        includeDeletes: boolean;
+        ignoredColumns: string[];
+    }, {
+        includeDeletes: boolean;
+        ignoredColumns: string[];
+    }>;
+    tables: z.ZodArray<z.ZodObject<{
+        schema: z.ZodString;
+        table: z.ZodString;
+        primaryKey: z.ZodArray<z.ZodString, "many">;
+        columnTypes: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+        updates: z.ZodArray<z.ZodObject<{
+            pk: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            changes: z.ZodRecord<z.ZodString, z.ZodObject<{
+                from: z.ZodUnknown;
+                to: z.ZodUnknown;
+            }, "strip", z.ZodTypeAny, {
+                from?: unknown;
+                to?: unknown;
+            }, {
+                from?: unknown;
+                to?: unknown;
+            }>>;
+            guard: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            pk: Record<string, unknown>;
+            changes: Record<string, {
+                from?: unknown;
+                to?: unknown;
+            }>;
+            guard: Record<string, unknown>;
+        }, {
+            pk: Record<string, unknown>;
+            changes: Record<string, {
+                from?: unknown;
+                to?: unknown;
+            }>;
+            guard: Record<string, unknown>;
+        }>, "many">;
+        inserts: z.ZodArray<z.ZodObject<{
+            row: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            row: Record<string, unknown>;
+        }, {
+            row: Record<string, unknown>;
+        }>, "many">;
+        deletes: z.ZodArray<z.ZodObject<{
+            pk: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+            guard: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        }, "strip", z.ZodTypeAny, {
+            pk: Record<string, unknown>;
+            guard: Record<string, unknown>;
+        }, {
+            pk: Record<string, unknown>;
+            guard: Record<string, unknown>;
+        }>, "many">;
+    }, "strip", z.ZodTypeAny, {
+        schema: string;
+        table: string;
+        primaryKey: string[];
+        updates: {
+            pk: Record<string, unknown>;
+            changes: Record<string, {
+                from?: unknown;
+                to?: unknown;
+            }>;
+            guard: Record<string, unknown>;
+        }[];
+        inserts: {
+            row: Record<string, unknown>;
+        }[];
+        deletes: {
+            pk: Record<string, unknown>;
+            guard: Record<string, unknown>;
+        }[];
+        columnTypes?: Record<string, string> | undefined;
+    }, {
+        schema: string;
+        table: string;
+        primaryKey: string[];
+        updates: {
+            pk: Record<string, unknown>;
+            changes: Record<string, {
+                from?: unknown;
+                to?: unknown;
+            }>;
+            guard: Record<string, unknown>;
+        }[];
+        inserts: {
+            row: Record<string, unknown>;
+        }[];
+        deletes: {
+            pk: Record<string, unknown>;
+            guard: Record<string, unknown>;
+        }[];
+        columnTypes?: Record<string, string> | undefined;
+    }>, "many">;
+    summary: z.ZodObject<{
+        tablesCompared: z.ZodNumber;
+        updates: z.ZodNumber;
+        inserts: z.ZodNumber;
+        deletes: z.ZodNumber;
+        skippedTables: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        updates: number;
+        inserts: number;
+        deletes: number;
+        tablesCompared: number;
+        skippedTables: string[];
+    }, {
+        updates: number;
+        inserts: number;
+        deletes: number;
+        tablesCompared: number;
+        skippedTables: string[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    options: {
+        includeDeletes: boolean;
+        ignoredColumns: string[];
+    };
+    format: "postgres-data-diff-json/v1";
+    generatedAt: string;
+    source: {
+        schema: string;
+    };
+    dest: {
+        schema: string;
+    };
+    tables: {
+        schema: string;
+        table: string;
+        primaryKey: string[];
+        updates: {
+            pk: Record<string, unknown>;
+            changes: Record<string, {
+                from?: unknown;
+                to?: unknown;
+            }>;
+            guard: Record<string, unknown>;
+        }[];
+        inserts: {
+            row: Record<string, unknown>;
+        }[];
+        deletes: {
+            pk: Record<string, unknown>;
+            guard: Record<string, unknown>;
+        }[];
+        columnTypes?: Record<string, string> | undefined;
+    }[];
+    summary: {
+        updates: number;
+        inserts: number;
+        deletes: number;
+        tablesCompared: number;
+        skippedTables: string[];
+    };
+}, {
+    options: {
+        includeDeletes: boolean;
+        ignoredColumns: string[];
+    };
+    format: "postgres-data-diff-json/v1";
+    generatedAt: string;
+    source: {
+        schema: string;
+    };
+    dest: {
+        schema: string;
+    };
+    tables: {
+        schema: string;
+        table: string;
+        primaryKey: string[];
+        updates: {
+            pk: Record<string, unknown>;
+            changes: Record<string, {
+                from?: unknown;
+                to?: unknown;
+            }>;
+            guard: Record<string, unknown>;
+        }[];
+        inserts: {
+            row: Record<string, unknown>;
+        }[];
+        deletes: {
+            pk: Record<string, unknown>;
+            guard: Record<string, unknown>;
+        }[];
+        columnTypes?: Record<string, string> | undefined;
+    }[];
+    summary: {
+        updates: number;
+        inserts: number;
+        deletes: number;
+        tablesCompared: number;
+        skippedTables: string[];
+    };
+}>;
+export type DiffJson = z.infer<typeof diffJsonSchema>;
+export type TableDiff = z.infer<typeof tableDiffSchema>;
+export type UpdateRecord = z.infer<typeof updateRecordSchema>;
+export type InsertRecord = z.infer<typeof insertRecordSchema>;
+export type DeleteRecord = z.infer<typeof deleteRecordSchema>;
+export type ChangeValue = z.infer<typeof changeValueSchema>;
+/**
+ * Validates a diff JSON object against the schema.
+ * Throws if invalid.
+ */
+export declare function validateDiffJson(data: unknown): DiffJson;
+export {};
+//# sourceMappingURL=diff-schema.d.ts.map

package/dist/diff/diff-schema.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.diffJsonSchema = void 0;
+exports.validateDiffJson = validateDiffJson;
+const zod_1 = require("zod");
+// Individual diff change record
+const changeValueSchema = zod_1.z.object({
+    from: zod_1.z.unknown(),
+    to: zod_1.z.unknown(),
+});
+const updateRecordSchema = zod_1.z.object({
+    pk: zod_1.z.record(zod_1.z.unknown()),
+    changes: zod_1.z.record(changeValueSchema),
+    guard: zod_1.z.record(zod_1.z.unknown()),
+});
+const insertRecordSchema = zod_1.z.object({
+    row: zod_1.z.record(zod_1.z.unknown()),
+});
+const deleteRecordSchema = zod_1.z.object({
+    pk: zod_1.z.record(zod_1.z.unknown()),
+    guard: zod_1.z.record(zod_1.z.unknown()),
+});
+const tableDiffSchema = zod_1.z.object({
+    schema: zod_1.z.string(),
+    table: zod_1.z.string(),
+    primaryKey: zod_1.z.array(zod_1.z.string()),
+    columnTypes: zod_1.z.record(zod_1.z.string()).optional(),
+    updates: zod_1.z.array(updateRecordSchema),
+    inserts: zod_1.z.array(insertRecordSchema),
+    deletes: zod_1.z.array(deleteRecordSchema),
+});
+const diffOptionsSchema = zod_1.z.object({
+    includeDeletes: zod_1.z.boolean(),
+    ignoredColumns: zod_1.z.array(zod_1.z.string()),
+});
+const diffSourceDestSchema = zod_1.z.object({
+    schema: zod_1.z.string(),
+});
+const diffSummarySchema = zod_1.z.object({
+    tablesCompared: zod_1.z.number().int(),
+    updates: zod_1.z.number().int(),
+    inserts: zod_1.z.number().int(),
+    deletes: zod_1.z.number().int(),
+    skippedTables: zod_1.z.array(zod_1.z.string()),
+});
+exports.diffJsonSchema = zod_1.z.object({
+    format: zod_1.z.literal("postgres-data-diff-json/v1"),
+    generatedAt: zod_1.z.string(),
+    source: diffSourceDestSchema,
+    dest: diffSourceDestSchema,
+    options: diffOptionsSchema,
+    tables: zod_1.z.array(tableDiffSchema),
+    summary: diffSummarySchema,
+});
+/**
+ * Validates a diff JSON object against the schema.
+ * Throws if invalid.
+ */
+function validateDiffJson(data) {
+    const result = exports.diffJsonSchema.safeParse(data);
+    if (!result.success) {
+        throw new Error("Invalid diff JSON format:\n" +
+            JSON.stringify(result.error.format(), null, 2));
+    }
+    return result.data;
+}
+//# sourceMappingURL=diff-schema.js.map

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

@@ -0,0 +1,20 @@
+import { Pool } from "pg";
+import { type DiffJson } from "./diff-schema";
+export interface GenerateDiffOptions {
+    schema: string;
+    tables: string[];
+    excludeTables: string[];
+    ignoreColumns: string[];
+    tablesWhereDataFilters?: Record<string, string>;
+    includeDeletes: boolean;
+    skipMissingPk: boolean;
+    verbose: boolean;
+    onProgress?: (message: string) => void;
+    onVerboseProgress?: (message: string) => void;
+}
+/**
+ * Generates a full diff between source and dest databases.
+ * Compares tables row by row using primary key matching.
+ */
+export declare function generateDiff(sourcePool: Pool, destPool: Pool, options: GenerateDiffOptions): Promise<DiffJson>;
+//# sourceMappingURL=generate-diff.d.ts.map

package/dist/diff/generate-diff.js

@@ -0,0 +1,224 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDiff = generateDiff;
+const metadata_1 = require("../db/metadata");
+const sql_1 = require("../db/sql");
+const serialize_value_1 = require("./serialize-value");
+const identifiers_1 = require("../shared/identifiers");
+/**
+ * Generates a full diff between source and dest databases.
+ * Compares tables row by row using primary key matching.
+ */
+async function generateDiff(sourcePool, destPool, options) {
+    const sourceClient = await sourcePool.connect();
+    const destClient = await destPool.connect();
+    const tableDiffs = [];
+    const skippedTables = [];
+    let totalUpdates = 0;
+    let totalInserts = 0;
+    let totalDeletes = 0;
+    try {
+        for (const [tableIndex, table] of options.tables.entries()) {
+            const progressLabel = formatTableProgressLabel(tableIndex + 1, options.tables.length, options.schema, table);
+            if (options.excludeTables.includes(table)) {
+                reportVerboseProgress(options, `${progressLabel}: skipping excluded table`);
+                continue;
+            }
+            (0, identifiers_1.validateIdentifier)(table, "table name");
+            reportProgress(options.onProgress, `${progressLabel}: loading table metadata`);
+            // Fetch metadata from both source and dest
+            const [sourceMeta, destMeta] = await Promise.all([
+                (0, metadata_1.fetchTableMetadata)(sourceClient, options.schema, table),
+                (0, metadata_1.fetchTableMetadata)(destClient, options.schema, table),
+            ]);
+            // Primary key check
+            if (!sourceMeta.hasPrimaryKey) {
+                if (options.skipMissingPk) {
+                    console.warn(`Skipping table without primary key: ${options.schema}.${table}`);
+                    skippedTables.push(table);
+                    continue;
+                }
+                else {
+                    throw new Error(`Table ${options.schema}.${table} has no primary key. ` +
+                        `Use --skip-missing-pk to skip tables without primary keys.`);
+                }
+            }
+            // Find common columns (present in both source and dest, not generated, not ignored)
+            const sourceColSet = new Set(sourceMeta.normalColumns);
+            const destColSet = new Set(destMeta.normalColumns);
+            const commonColumns = sourceMeta.normalColumns.filter((c) => destColSet.has(c) && !options.ignoreColumns.includes(c));
+            const pkColumns = sourceMeta.primaryKey;
+            // Build a map of column name -> data type for type-aware serialization
+            const colTypeMap = buildColTypeMap(sourceMeta.columns);
+            // Ensure pk columns are always fetched even if ignored
+            const fetchColumns = [...new Set([...pkColumns, ...commonColumns])];
+            reportVerboseProgress(options, `${progressLabel}: using primary key ${pkColumns.join(", ")} and ${commonColumns.length} comparable column(s)`);
+            // Fetch all rows from source and dest
+            const whereDataFilter = options.tablesWhereDataFilters?.[table];
+            reportProgress(options.onProgress, `${progressLabel}: fetching source and destination rows`);
+            const sourceRowsPromise = (0, sql_1.fetchRowsBatched)(sourceClient, options.schema, table, fetchColumns, pkColumns, undefined, whereDataFilter, (progress) => {
+                reportVerboseProgress(options, `${progressLabel}: source batch ${progress.batchNumber} fetched ${progress.batchRows} row(s), ${progress.fetchedRows} total`);
+            });
+            const destRowsPromise = (0, sql_1.fetchRowsBatched)(destClient, options.schema, table, fetchColumns, pkColumns, undefined, whereDataFilter, (progress) => {
+                reportVerboseProgress(options, `${progressLabel}: destination batch ${progress.batchNumber} fetched ${progress.batchRows} row(s), ${progress.fetchedRows} total`);
+            });
+            const [sourceRows, destRows] = await Promise.all([
+                sourceRowsPromise,
+                destRowsPromise,
+            ]);
+            reportProgress(options.onProgress, `${progressLabel}: fetched ${sourceRows.length} source row(s) and ${destRows.length} destination row(s)`);
+            reportProgress(options.onProgress, `${progressLabel}: comparing row sets`);
+            // Index dest rows by PK
+            const destByPk = new Map();
+            for (const row of destRows) {
+                const pk = buildPkKey(pkColumns, row, colTypeMap);
+                destByPk.set(pk, row);
+            }
+            const updates = [];
+            const inserts = [];
+            const deletes = [];
+            // Compare source rows against dest
+            const seenPkKeys = new Set();
+            for (const sourceRow of sourceRows) {
+                const pkKey = buildPkKey(pkColumns, sourceRow, colTypeMap);
+                seenPkKeys.add(pkKey);
+                const pkValues = extractPkValues(pkColumns, sourceRow);
+                const destRow = destByPk.get(pkKey);
+                if (!destRow) {
+                    // Row exists in source but not in dest -> INSERT
+                    const serializedRow = {};
+                    for (const col of fetchColumns) {
+                        serializedRow[col] = (0, serialize_value_1.serializeValue)(sourceRow[col], colTypeMap[col]);
+                    }
+                    inserts.push({ row: serializedRow });
+                }
+                else {
+                    // Row exists in both -> check for changes
+                    const changes = {};
+                    const compareColumns = commonColumns.filter((c) => !pkColumns.includes(c));
+                    for (const col of compareColumns) {
+                        const srcVal = (0, serialize_value_1.serializeValue)(sourceRow[col], colTypeMap[col]);
+                        const dstVal = (0, serialize_value_1.serializeValue)(destRow[col], colTypeMap[col]);
+                        if (!(0, serialize_value_1.valuesAreEqual)(srcVal, dstVal)) {
+                            changes[col] = { from: dstVal, to: srcVal };
+                        }
+                    }
+                    if (Object.keys(changes).length > 0) {
+                        const serializedPk = {};
+                        for (const col of pkColumns) {
+                            serializedPk[col] = (0, serialize_value_1.serializeValue)(pkValues[col], colTypeMap[col]);
+                        }
+                        const guard = {};
+                        for (const col of fetchColumns) {
+                            guard[col] = (0, serialize_value_1.serializeValue)(destRow[col], colTypeMap[col]);
+                        }
+                        updates.push({ pk: serializedPk, changes, guard });
+                    }
+                }
+            }
+            // Find deletes: rows in dest that are not in source
+            if (options.includeDeletes) {
+                for (const destRow of destRows) {
+                    const pkKey = buildPkKey(pkColumns, destRow, colTypeMap);
+                    if (!seenPkKeys.has(pkKey)) {
+                        const pkValues = extractPkValues(pkColumns, destRow);
+                        const serializedPk = {};
+                        for (const col of pkColumns) {
+                            serializedPk[col] = (0, serialize_value_1.serializeValue)(pkValues[col], colTypeMap[col]);
+                        }
+                        // Build guard from all non-ignored, non-generated columns
+                        const guard = {};
+                        for (const col of fetchColumns) {
+                            guard[col] = (0, serialize_value_1.serializeValue)(destRow[col], colTypeMap[col]);
+                        }
+                        deletes.push({ pk: serializedPk, guard });
+                    }
+                }
+            }
+            if (updates.length > 0 || inserts.length > 0 || deletes.length > 0) {
+                tableDiffs.push({
+                    table,
+                    schema: options.schema,
+                    primaryKey: pkColumns,
+                    columnTypes: colTypeMap,
+                    updates,
+                    inserts,
+                    deletes,
+                });
+            }
+            totalUpdates += updates.length;
+            totalInserts += inserts.length;
+            totalDeletes += deletes.length;
+            reportProgress(options.onProgress, `${progressLabel}: completed with ${inserts.length} insert(s), ${updates.length} update(s), ${deletes.length} delete(s)`);
+        }
+    }
+    finally {
+        sourceClient.release();
+        destClient.release();
+    }
+    return {
+        format: "postgres-data-diff-json/v1",
+        generatedAt: new Date().toISOString(),
+        source: { schema: options.schema },
+        dest: { schema: options.schema },
+        options: {
+            includeDeletes: options.includeDeletes,
+            ignoredColumns: options.ignoreColumns,
+        },
+        tables: tableDiffs,
+        summary: {
+            tablesCompared: options.tables.length - skippedTables.length,
+            updates: totalUpdates,
+            inserts: totalInserts,
+            deletes: totalDeletes,
+            skippedTables,
+        },
+    };
+}
+/**
+ * Builds a string key from primary key column values.
+ */
+function buildPkKey(pkColumns, row, colTypeMap) {
+    return pkColumns
+        .map((col) => JSON.stringify((0, serialize_value_1.serializeValue)(row[col], colTypeMap[col])))
+        .join("|||");
+}
+/**
+ * Builds a map from column name to data type for type-aware serialization.
+ */
+function buildColTypeMap(columns) {
+    const map = {};
+    for (const col of columns) {
+        map[col.columnName] = col.dataType;
+    }
+    return map;
+}
+/**
+ * Extracts primary key values from a row.
+ */
+function extractPkValues(pkColumns, row) {
+    const result = {};
+    for (const col of pkColumns) {
+        result[col] = row[col];
+    }
+    return result;
+}
+function formatTableProgressLabel(tablePosition, totalTables, schema, table) {
+    return `[data ${tablePosition}/${totalTables}] ${schema}.${table}`;
+}
+function reportProgress(callback, message) {
+    if (callback) {
+        callback(message);
+    }
+}
+function reportVerboseProgress(options, message) {
+    if (!options.verbose) {
+        return;
+    }
+    if (options.onVerboseProgress) {
+        options.onVerboseProgress(message);
+        return;
+    }
+    console.log(message);
+}
+//# sourceMappingURL=generate-diff.js.map

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

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