frg-data-diff 2.0.0

package/dist/schema-diff/generate-schema-diff.js

@@ -0,0 +1,355 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateSchemaDiff = generateSchemaDiff;
+const metadata_1 = require("../db/metadata");
+const identifiers_1 = require("../shared/identifiers");
+async function generateSchemaDiff(sourcePool, destPool, options) {
+    const sourceClient = await sourcePool.connect();
+    const destClient = await destPool.connect();
+    const tableDiffs = [];
+    const summary = {
+        tablesCompared: 0,
+        tablesToCreate: 0,
+        tablesToDrop: 0,
+        columnsToAdd: 0,
+        columnsToAlter: 0,
+        columnsToDrop: 0,
+        primaryKeysToChange: 0,
+    };
+    try {
+        const [sourceTables, destTables] = await Promise.all([
+            (0, metadata_1.listTables)(sourceClient, options.schema),
+            (0, metadata_1.listTables)(destClient, options.schema),
+        ]);
+        const sourceTableSet = new Set(sourceTables);
+        const destTableSet = new Set(destTables);
+        for (const [tableIndex, table] of options.tables.entries()) {
+            const progressLabel = formatSchemaProgressLabel(tableIndex + 1, options.tables.length, options.schema, table);
+            if (options.excludeTables.includes(table)) {
+                reportVerboseProgress(options, `${progressLabel}: skipping excluded schema diff table`);
+                continue;
+            }
+            (0, identifiers_1.validateIdentifier)(table, "schema diff table name");
+            summary.tablesCompared++;
+            reportProgress(options.onProgress, `${progressLabel}: loading table metadata`);
+            const sourceExists = sourceTableSet.has(table);
+            const destExists = destTableSet.has(table);
+            reportVerboseProgress(options, `${progressLabel}: source exists ${sourceExists}, destination exists ${destExists}`);
+            const [sourceMeta, destMeta] = await Promise.all([
+                sourceExists
+                    ? (0, metadata_1.fetchTableMetadata)(sourceClient, options.schema, table)
+                    : Promise.resolve(undefined),
+                destExists
+                    ? (0, metadata_1.fetchTableMetadata)(destClient, options.schema, table)
+                    : Promise.resolve(undefined),
+            ]);
+            const tableDiff = buildSchemaTableDiff(options.schema, table, sourceMeta, destMeta);
+            reportProgress(options.onProgress, `${progressLabel}: ${summarizeSchemaTableDiff(tableDiff)}`);
+            if (!tableDiff) {
+                continue;
+            }
+            if (tableDiff.createTable) {
+                summary.tablesToCreate++;
+            }
+            if (tableDiff.dropTable) {
+                summary.tablesToDrop++;
+            }
+            summary.columnsToAdd += tableDiff.addColumns.length;
+            summary.columnsToAlter += tableDiff.alterColumns.length;
+            summary.columnsToDrop += tableDiff.dropColumns.length;
+            if (tableDiff.primaryKeyChange) {
+                summary.primaryKeysToChange++;
+            }
+            tableDiffs.push(tableDiff);
+        }
+    }
+    finally {
+        sourceClient.release();
+        destClient.release();
+    }
+    return {
+        format: "postgres-schema-diff-json/v1",
+        generatedAt: new Date().toISOString(),
+        source: { schema: options.schema },
+        dest: { schema: options.schema },
+        options: {
+            tables: options.tables,
+            excludedTables: options.excludeTables,
+        },
+        tables: tableDiffs,
+        summary,
+    };
+}
+function buildSchemaTableDiff(schema, table, sourceMeta, destMeta) {
+    if (sourceMeta && !destMeta) {
+        return {
+            table,
+            schema,
+            sourceExists: true,
+            destExists: false,
+            createTable: {
+                columns: sourceMeta.columns.map(buildSchemaColumnDefinition),
+                primaryKey: [...sourceMeta.primaryKey],
+            },
+            dropTable: false,
+            addColumns: [],
+            alterColumns: [],
+            dropColumns: [],
+            primaryKeyChange: null,
+        };
+    }
+    if (!sourceMeta && destMeta) {
+        return {
+            table,
+            schema,
+            sourceExists: false,
+            destExists: true,
+            createTable: null,
+            dropTable: true,
+            addColumns: [],
+            alterColumns: [],
+            dropColumns: [],
+            primaryKeyChange: null,
+        };
+    }
+    if (!sourceMeta || !destMeta) {
+        return null;
+    }
+    const sourceColumns = new Map(sourceMeta.columns.map((column) => [column.columnName, column]));
+    const destColumns = new Map(destMeta.columns.map((column) => [column.columnName, column]));
+    const addColumns = sourceMeta.columns
+        .filter((column) => !destColumns.has(column.columnName))
+        .map(buildSchemaColumnDefinition);
+    const dropColumns = destMeta.columns
+        .filter((column) => !sourceColumns.has(column.columnName))
+        .map(buildSchemaColumnDefinition);
+    const alterColumns = [];
+    for (const sourceColumn of sourceMeta.columns) {
+        const destColumn = destColumns.get(sourceColumn.columnName);
+        if (!destColumn) {
+            continue;
+        }
+        const from = buildSchemaColumnDefinition(destColumn);
+        const to = buildSchemaColumnDefinition(sourceColumn);
+        if (!schemaColumnsAreEqual(from, to)) {
+            alterColumns.push({
+                column: sourceColumn.columnName,
+                from,
+                to,
+            });
+        }
+    }
+    const primaryKeyChange = buildPrimaryKeyChange(sourceMeta, destMeta);
+    const hasChanges = addColumns.length > 0 ||
+        alterColumns.length > 0 ||
+        dropColumns.length > 0 ||
+        primaryKeyChange !== null;
+    if (!hasChanges) {
+        return null;
+    }
+    return {
+        table,
+        schema,
+        sourceExists: true,
+        destExists: true,
+        createTable: null,
+        dropTable: false,
+        addColumns,
+        alterColumns,
+        dropColumns,
+        primaryKeyChange,
+    };
+}
+function buildPrimaryKeyChange(sourceMeta, destMeta) {
+    if (arraysEqual(sourceMeta.primaryKey, destMeta.primaryKey)) {
+        return null;
+    }
+    (0, identifiers_1.validateIdentifiers)(sourceMeta.primaryKey, "source primary key column");
+    (0, identifiers_1.validateIdentifiers)(destMeta.primaryKey, "destination primary key column");
+    return {
+        from: [...destMeta.primaryKey],
+        to: [...sourceMeta.primaryKey],
+        dropConstraintName: destMeta.primaryKeyConstraintName,
+    };
+}
+function buildSchemaColumnDefinition(column) {
+    return {
+        name: column.columnName,
+        type: buildColumnTypeSql(column),
+        nullable: column.isNullable,
+        default: normalizeColumnDefault(column),
+        isGenerated: column.isGenerated,
+        generationExpression: column.generationExpression,
+        ordinalPosition: column.ordinalPosition,
+    };
+}
+function normalizeColumnDefault(column) {
+    if (column.isGenerated) {
+        return null;
+    }
+    return column.columnDefault;
+}
+function formatSchemaProgressLabel(tablePosition, totalTables, schema, table) {
+    return `[schema ${tablePosition}/${totalTables}] ${schema}.${table}`;
+}
+function summarizeSchemaTableDiff(tableDiff) {
+    if (!tableDiff) {
+        return "no schema changes";
+    }
+    const changeDescriptions = [];
+    if (tableDiff.createTable) {
+        changeDescriptions.push("create table");
+    }
+    if (tableDiff.dropTable) {
+        changeDescriptions.push("drop table");
+    }
+    if (tableDiff.addColumns.length > 0) {
+        changeDescriptions.push(`${tableDiff.addColumns.length} column(s) to add`);
+    }
+    if (tableDiff.alterColumns.length > 0) {
+        changeDescriptions.push(`${tableDiff.alterColumns.length} column(s) to alter`);
+    }
+    if (tableDiff.dropColumns.length > 0) {
+        changeDescriptions.push(`${tableDiff.dropColumns.length} column(s) to drop`);
+    }
+    if (tableDiff.primaryKeyChange) {
+        changeDescriptions.push("primary key change");
+    }
+    return changeDescriptions.join(", ");
+}
+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);
+}
+function buildColumnTypeSql(column) {
+    if (column.domainName) {
+        return qualifyTypeName(column.domainSchema, column.domainName);
+    }
+    if (column.dataType === "ARRAY") {
+        const elementType = buildArrayElementTypeSql(column);
+        return `${elementType}[]`;
+    }
+    if (column.dataType === "character varying") {
+        return column.characterMaximumLength
+            ? `character varying(${column.characterMaximumLength})`
+            : "character varying";
+    }
+    if (column.dataType === "character") {
+        return column.characterMaximumLength
+            ? `character(${column.characterMaximumLength})`
+            : "character";
+    }
+    if (column.dataType === "numeric") {
+        if (column.numericPrecision !== null && column.numericScale !== null) {
+            return `numeric(${column.numericPrecision}, ${column.numericScale})`;
+        }
+        if (column.numericPrecision !== null) {
+            return `numeric(${column.numericPrecision})`;
+        }
+        return "numeric";
+    }
+    if (column.dataType === "time without time zone") {
+        return withOptionalPrecision("time", column.datetimePrecision);
+    }
+    if (column.dataType === "time with time zone") {
+        return withOptionalPrecision("time with time zone", column.datetimePrecision);
+    }
+    if (column.dataType === "timestamp without time zone") {
+        return withOptionalPrecision("timestamp", column.datetimePrecision);
+    }
+    if (column.dataType === "timestamp with time zone") {
+        return withOptionalPrecision("timestamp with time zone", column.datetimePrecision);
+    }
+    if (column.dataType === "interval") {
+        let typeSql = "interval";
+        if (column.intervalType) {
+            typeSql += ` ${column.intervalType}`;
+        }
+        if (column.intervalPrecision !== null) {
+            typeSql += `(${column.intervalPrecision})`;
+        }
+        return typeSql;
+    }
+    if (column.dataType === "USER-DEFINED") {
+        return qualifyTypeName(column.udtSchema, column.udtName);
+    }
+    return column.dataType;
+}
+function buildArrayElementTypeSql(column) {
+    const elementTypeName = column.udtName.startsWith("_")
+        ? column.udtName.slice(1)
+        : column.udtName;
+    if (column.udtSchema !== "pg_catalog") {
+        return qualifyTypeName(column.udtSchema, elementTypeName);
+    }
+    return mapPgCatalogTypeName(elementTypeName);
+}
+function qualifyTypeName(schema, typeName) {
+    (0, identifiers_1.validateIdentifier)(typeName, "type name");
+    if (!schema || schema === "pg_catalog") {
+        return (0, identifiers_1.quoteIdentifier)(typeName);
+    }
+    (0, identifiers_1.validateIdentifier)(schema, "type schema name");
+    return `${(0, identifiers_1.quoteIdentifier)(schema)}.${(0, identifiers_1.quoteIdentifier)(typeName)}`;
+}
+function withOptionalPrecision(typeName, precision) {
+    if (precision === null) {
+        return typeName;
+    }
+    return `${typeName}(${precision})`;
+}
+function mapPgCatalogTypeName(typeName) {
+    switch (typeName) {
+        case "int2":
+            return "smallint";
+        case "int4":
+            return "integer";
+        case "int8":
+            return "bigint";
+        case "float4":
+            return "real";
+        case "float8":
+            return "double precision";
+        case "bool":
+            return "boolean";
+        case "varchar":
+            return "character varying";
+        case "bpchar":
+            return "character";
+        case "timestamptz":
+            return "timestamp with time zone";
+        case "timestamp":
+            return "timestamp";
+        case "timetz":
+            return "time with time zone";
+        case "time":
+            return "time";
+        default:
+            return (0, identifiers_1.quoteIdentifier)(typeName);
+    }
+}
+function schemaColumnsAreEqual(left, right) {
+    return (left.type === right.type &&
+        left.nullable === right.nullable &&
+        left.default === right.default &&
+        left.isGenerated === right.isGenerated &&
+        left.generationExpression === right.generationExpression);
+}
+function arraysEqual(left, right) {
+    if (left.length !== right.length) {
+        return false;
+    }
+    return left.every((value, index) => value === right[index]);
+}
+//# sourceMappingURL=generate-schema-diff.js.map

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

@@ -0,0 +1,20 @@
+import { type SchemaDiffJson } from "./schema-diff-schema";
+export interface GenerateSchemaSqlOptions {
+    transaction: boolean;
+    includeDrops: boolean;
+    onProgress?: (message: string) => void;
+}
+export interface GeneratedSchemaSqlResult {
+    sql: string;
+    summary: {
+        tablesToCreate: number;
+        tablesToDrop: number;
+        columnsToAdd: number;
+        columnsToAlter: number;
+        columnsToDrop: number;
+        primaryKeysToChange: number;
+    };
+}
+export declare function buildSchemaSqlOutputPath(inputPath: string): string;
+export declare function generateSchemaSqlScript(diff: SchemaDiffJson, options: GenerateSchemaSqlOptions): GeneratedSchemaSqlResult;
+//# sourceMappingURL=generate-schema-sql.d.ts.map

package/dist/schema-diff/generate-schema-sql.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildSchemaSqlOutputPath = buildSchemaSqlOutputPath;
+exports.generateSchemaSqlScript = generateSchemaSqlScript;
+const identifiers_1 = require("../shared/identifiers");
+function buildSchemaSqlOutputPath(inputPath) {
+    return inputPath.endsWith(".json")
+        ? inputPath.replace(/\.json$/i, ".sql")
+        : `${inputPath}.sql`;
+}
+function generateSchemaSqlScript(diff, options) {
+    const lines = [];
+    const summary = {
+        tablesToCreate: 0,
+        tablesToDrop: 0,
+        columnsToAdd: 0,
+        columnsToAlter: 0,
+        columnsToDrop: 0,
+        primaryKeysToChange: 0,
+    };
+    lines.push("-- Generated by frg-data-diff");
+    lines.push("-- Review this schema SQL carefully before executing it.");
+    lines.push(`-- Schema 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 schema SQL for ${diff.tables.length} table diff(s)...`);
+    for (const [tableIndex, tableDiff] of diff.tables.entries()) {
+        const progressLabel = `[schema-sql ${tableIndex + 1}/${diff.tables.length}] ${tableDiff.schema}.${tableDiff.table}`;
+        reportProgress(options.onProgress, `${progressLabel}: ${summarizeSchemaSqlWork(tableDiff, options)}`);
+        const statements = buildTableStatements(tableDiff, options, summary);
+        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 buildTableStatements(tableDiff, options, summary) {
+    (0, identifiers_1.validateIdentifier)(tableDiff.schema, "schema name");
+    (0, identifiers_1.validateIdentifier)(tableDiff.table, "table name");
+    const qualifiedTable = (0, identifiers_1.quoteQualifiedTable)(tableDiff.schema, tableDiff.table);
+    const statements = [];
+    if (tableDiff.createTable) {
+        statements.push(buildCreateTableStatement(tableDiff.schema, tableDiff.table, tableDiff.createTable.columns, tableDiff.createTable.primaryKey));
+        summary.tablesToCreate++;
+        return statements;
+    }
+    if (tableDiff.dropTable) {
+        if (options.includeDrops) {
+            statements.push(`DROP TABLE IF EXISTS ${qualifiedTable};`);
+            summary.tablesToDrop++;
+        }
+        return statements;
+    }
+    if (tableDiff.primaryKeyChange &&
+        tableDiff.primaryKeyChange.from.length > 0) {
+        const constraintName = tableDiff.primaryKeyChange.dropConstraintName ??
+            `${tableDiff.table}_pkey`;
+        (0, identifiers_1.validateIdentifier)(constraintName, "primary key constraint name");
+        statements.push(`ALTER TABLE ${qualifiedTable} DROP CONSTRAINT IF EXISTS ${(0, identifiers_1.quoteIdentifier)(constraintName)};`);
+        summary.primaryKeysToChange++;
+    }
+    for (const column of tableDiff.addColumns) {
+        statements.push(`ALTER TABLE ${qualifiedTable} ADD COLUMN ${buildColumnDefinitionSql(column)};`);
+        summary.columnsToAdd++;
+    }
+    for (const columnChange of tableDiff.alterColumns) {
+        statements.push(...buildAlterColumnStatements(qualifiedTable, columnChange));
+        summary.columnsToAlter++;
+    }
+    if (options.includeDrops) {
+        for (const column of tableDiff.dropColumns) {
+            (0, identifiers_1.validateIdentifier)(column.name, "drop column name");
+            statements.push(`ALTER TABLE ${qualifiedTable} DROP COLUMN ${(0, identifiers_1.quoteIdentifier)(column.name)};`);
+            summary.columnsToDrop++;
+        }
+    }
+    if (tableDiff.primaryKeyChange && tableDiff.primaryKeyChange.to.length > 0) {
+        (0, identifiers_1.validateIdentifiers)(tableDiff.primaryKeyChange.to, "primary key column");
+        statements.push(`ALTER TABLE ${qualifiedTable} ADD PRIMARY KEY (${tableDiff.primaryKeyChange.to.map(identifiers_1.quoteIdentifier).join(", ")});`);
+        if (tableDiff.primaryKeyChange.from.length === 0) {
+            summary.primaryKeysToChange++;
+        }
+    }
+    return statements;
+}
+function buildCreateTableStatement(schema, table, columns, primaryKey) {
+    (0, identifiers_1.validateIdentifier)(schema, "schema name");
+    (0, identifiers_1.validateIdentifier)(table, "table name");
+    (0, identifiers_1.validateIdentifiers)(columns.map((column) => column.name), "create column");
+    (0, identifiers_1.validateIdentifiers)(primaryKey, "primary key column");
+    const lines = columns.map((column) => `  ${buildColumnDefinitionSql(column)}`);
+    if (primaryKey.length > 0) {
+        lines.push(`  PRIMARY KEY (${primaryKey.map(identifiers_1.quoteIdentifier).join(", ")})`);
+    }
+    return `CREATE TABLE ${(0, identifiers_1.quoteQualifiedTable)(schema, table)} (\n${lines.join(",\n")}\n);`;
+}
+function buildColumnDefinitionSql(column) {
+    (0, identifiers_1.validateIdentifier)(column.name, "column name");
+    let definition = `${(0, identifiers_1.quoteIdentifier)(column.name)} ${column.type}`;
+    if (column.isGenerated && column.generationExpression) {
+        definition += ` GENERATED ALWAYS AS (${column.generationExpression}) STORED`;
+        return definition;
+    }
+    if (column.default !== null) {
+        definition += ` DEFAULT ${column.default}`;
+    }
+    if (!column.nullable) {
+        definition += " NOT NULL";
+    }
+    return definition;
+}
+function buildAlterColumnStatements(qualifiedTable, columnChange) {
+    const columnName = (0, identifiers_1.quoteIdentifier)(columnChange.column);
+    const statements = [];
+    if (columnChange.from.isGenerated !== columnChange.to.isGenerated ||
+        columnChange.from.generationExpression !==
+            columnChange.to.generationExpression) {
+        statements.push(`ALTER TABLE ${qualifiedTable} DROP COLUMN ${columnName};`);
+        statements.push(`ALTER TABLE ${qualifiedTable} ADD COLUMN ${buildColumnDefinitionSql(columnChange.to)};`);
+        return statements;
+    }
+    if (columnChange.from.type !== columnChange.to.type) {
+        statements.push(`ALTER TABLE ${qualifiedTable} ALTER COLUMN ${columnName} TYPE ${columnChange.to.type};`);
+    }
+    if (columnChange.from.default !== columnChange.to.default) {
+        if (columnChange.to.default === null) {
+            statements.push(`ALTER TABLE ${qualifiedTable} ALTER COLUMN ${columnName} DROP DEFAULT;`);
+        }
+        else {
+            statements.push(`ALTER TABLE ${qualifiedTable} ALTER COLUMN ${columnName} SET DEFAULT ${columnChange.to.default};`);
+        }
+    }
+    if (columnChange.from.nullable !== columnChange.to.nullable) {
+        statements.push(columnChange.to.nullable
+            ? `ALTER TABLE ${qualifiedTable} ALTER COLUMN ${columnName} DROP NOT NULL;`
+            : `ALTER TABLE ${qualifiedTable} ALTER COLUMN ${columnName} SET NOT NULL;`);
+    }
+    return statements;
+}
+function summarizeSchemaSqlWork(tableDiff, options) {
+    const changeDescriptions = [];
+    if (tableDiff.createTable) {
+        changeDescriptions.push("create table");
+    }
+    if (tableDiff.dropTable) {
+        changeDescriptions.push(options.includeDrops ? "drop table" : "drop table skipped");
+    }
+    if (tableDiff.addColumns.length > 0) {
+        changeDescriptions.push(`${tableDiff.addColumns.length} column(s) to add`);
+    }
+    if (tableDiff.alterColumns.length > 0) {
+        changeDescriptions.push(`${tableDiff.alterColumns.length} column(s) to alter`);
+    }
+    if (tableDiff.dropColumns.length > 0) {
+        changeDescriptions.push(options.includeDrops
+            ? `${tableDiff.dropColumns.length} column(s) to drop`
+            : `${tableDiff.dropColumns.length} column drop(s) skipped`);
+    }
+    if (tableDiff.primaryKeyChange) {
+        changeDescriptions.push("primary key change");
+    }
+    return changeDescriptions.join(", ");
+}
+function reportProgress(callback, message) {
+    if (callback) {
+        callback(message);
+    }
+}
+//# sourceMappingURL=generate-schema-sql.js.map