frg-data-diff 2.0.0 → 2.1.0

package/README.md

@@ -2,7 +2,7 @@
 
 > It compares row data between two PostgreSQL databases and safely applies changes.
 >
-> It also produces a review-only schema diff based on `information_schema`, with JSON/YAML artifacts plus SQL for manual execution.
+> It also produces review-only schema, trigger/function, and view SQL artifacts for manual execution.
 
 Safe PostgreSQL **data** diff and apply tooling, with companion PostgreSQL **schema** diff output for manual review. Compare data between two PostgreSQL databases and apply changes with strong safety guards.
 
@@ -23,6 +23,8 @@ npx frg-data-diff
 npx frg-data-diff generate
 npx frg-data-diff apply
 npx frg-data-diff sql
+npx frg-data-diff pg-triggers
+npx frg-data-diff pg-views
 ```
 
 ---
@@ -62,12 +64,30 @@ Reads a JSON diff file and writes a plain SQL script for manual review and execu
 npx frg-data-diff sql --input frg-data-diff.json --output frg-data-diff.sql
 ```
 
+### `frg-data-diff pg-triggers`
+
+Compares PostgreSQL triggers and functions and writes a SQL diff script.
+
+```bash
+npx frg-data-diff pg-triggers --output frg-triggers-diff.sql
+```
+
+### `frg-data-diff pg-views`
+
+Compares regular and materialized view definitions and writes a SQL diff script.
+
+```bash
+npx frg-data-diff pg-views --output frg-views-diff.sql
+```
+
 ---
 
 ## Configuration File: `.frg-data-diff.config.json`
 
 Commands look for this file in the current working directory.
 
+The config file is JSON with comments: `// line comments` and `/* block comments */` are accepted. Other JSON rules still apply, including no trailing commas.
+
 ### Committing the config file
 
 **Do commit** `.frg-data-diff.config.json` to version control.
@@ -86,11 +106,13 @@ Generator list fields also support `$ENV_VAR` entries:
 - `schemaDiffExcludeTables`
 - `pgTriggersTables`
 - `pgTriggersExcludeTables`
+- `pgViews`
+- `pgViewsExclude`
 - `ignoreColumns`
 
 When used in those list fields, the environment variable value is parsed as a comma-separated list at runtime.
 
-Data, schema diff, and PostgreSQL trigger table filters are independent. If a schema or trigger table/exclude field is omitted, it defaults to an empty list and does not inherit from `tables` or `excludeTables`.
+Data, schema diff, PostgreSQL trigger, and PostgreSQL view filters are independent. Schema and trigger include filters inherit `tables` when omitted. View include filters default to all views when omitted.
 
 In the interactive wizard, pressing Enter keeps the displayed default. For optional list fields, type `none` to clear the value; the config stores that explicit clear as an empty array.
 
@@ -121,6 +143,9 @@ In the interactive wizard, pressing Enter keeps the displayed default. For optio
     "pgTriggersTables": ["my_table"],
     "pgTriggersExcludeTables": [],
     "pgTriggersOutput": "frg-triggers-diff.sql",
+    "pgViews": ["*"],
+    "pgViewsExclude": [],
+    "pgViewsOutput": "frg-views-diff.sql",
     "ignoreColumns": ["created_at", "updated_at"],
     "includeDeletes": true,
     "skipMissingPk": false,
@@ -256,6 +281,13 @@ Key options:
 | `--table`                  | Table(s) or `*` patterns to include (repeatable)      |
 | `--exclude-table`          | Table(s) or `*` patterns to skip (repeatable)         |
 | `--ignore-column`          | Column(s) to ignore during comparison (repeatable)    |
+| `--pg-triggers-table`      | Table(s) for trigger/function diff                    |
+| `--pg-triggers-output`     | Output path for PostgreSQL trigger/function diff SQL  |
+| `--generate-pg-triggers`   | Generate PostgreSQL trigger/function diff SQL         |
+| `--pg-view`                | View(s) or `*` patterns for view DDL diff             |
+| `--pg-view-exclude`        | View(s) or `*` patterns to skip in view DDL diff      |
+| `--pg-views-output`        | Output path for PostgreSQL view diff SQL              |
+| `--generate-pg-views`      | Generate PostgreSQL view diff SQL from `generate`     |
 | `--include-deletes`        | Generate delete entries for rows only in dest         |
 | `--skip-missing-pk`        | Skip tables without a primary key instead of failing  |
 | `--output`                 | Output diff file path (default: `frg-data-diff.json`) |
@@ -372,6 +404,8 @@ export DIRECTUS_TABLES="directus_*, custom_table"
 export DIRECTUS_EXCLUDES="directus_activity, directus_sessions"
 export DIRECTUS_PG_TRIGGER_TABLES="directus_flows, directus_operations"
 export DIRECTUS_PG_TRIGGER_EXCLUDES="directus_sessions"
+export DIRECTUS_PG_VIEWS="directus_*_view, custom_view"
+export DIRECTUS_PG_VIEW_EXCLUDES="legacy_*"
 export DIRECTUS_IGNORED_COLUMNS="created_at, updated_at"
 ```
 
@@ -383,6 +417,9 @@ export DIRECTUS_IGNORED_COLUMNS="created_at, updated_at"
     "pgTriggersTables": ["$DIRECTUS_PG_TRIGGER_TABLES"],
     "pgTriggersExcludeTables": ["$DIRECTUS_PG_TRIGGER_EXCLUDES"],
     "pgTriggersOutput": "frg-triggers-diff.sql",
+    "pgViews": ["$DIRECTUS_PG_VIEWS"],
+    "pgViewsExclude": ["$DIRECTUS_PG_VIEW_EXCLUDES"],
+    "pgViewsOutput": "frg-views-diff.sql",
     "ignoreColumns": ["$DIRECTUS_IGNORED_COLUMNS"]
   }
 }
@@ -400,7 +437,7 @@ export DIRECTUS_IGNORED_COLUMNS="created_at, updated_at"
 - **dryRun defaults to true** — no mutations without `--execute`.
 - **Transaction by default** — all changes in a single transaction; rolled back on failure in `abort` mode.
 - **Generated columns are never written**.
-- **Schema is never mutated**.
+- **Data apply never mutates schema** — generated schema, trigger, and view SQL is review-only and must be executed manually.
 
 ---
 
@@ -479,6 +516,9 @@ For publishing Directus configuration data from development to production:
     "pgTriggersTables": ["directus_flows", "directus_operations"],
     "pgTriggersExcludeTables": [],
     "pgTriggersOutput": "frg-triggers-diff.sql",
+    "pgViews": ["directus_*_view"],
+    "pgViewsExclude": [],
+    "pgViewsOutput": "frg-views-diff.sql",
     "ignoreColumns": ["created_at", "updated_at"],
     "includeDeletes": true,
     "skipMissingPk": false,
@@ -546,7 +586,7 @@ npx frg-data-diff apply --execute --apply-deletes
 - Schema diff (table creation, column changes, index changes) — use a dedicated schema migration tool.
 - Cross-schema comparisons within a single call (one schema per run).
 - Tables without primary keys (use `--skip-missing-pk` to skip them).
-- Views, materialized views, foreign tables.
+- Foreign tables.
 - Streaming of very large tables — v1 loads each table into memory. For huge tables, process in smaller table batches.
 - PostgreSQL pseudo-types and internal-only types as table columns.
 - Multiple databases in a single run — run the tool once per database pair.
@@ -617,6 +657,7 @@ frg-data-diff sql --help
 4. **No schema migration**: This tool does not create tables, add columns, or change indexes.
 5. **Single schema per run**: All tables must be in the same schema.
 6. **Env var references use shell-style names**: `$ENV_VAR`, `$envVar`, and `$env_var` are all valid.
+7. **View SQL scope**: View diffs compare definitions from PostgreSQL catalog metadata. Ownership, grants, comments, and materialized-view indexes are not recreated.
 
 ---
 

package/dist/cli/generator.js

@@ -49,6 +49,7 @@ const resolve_options_1 = require("../config/resolve-options");
 const write_config_1 = require("../config/write-config");
 const connection_1 = require("../db/connection");
 const metadata_1 = require("../db/metadata");
+const pg_views_1 = require("../db/pg-views");
 const generate_diff_1 = require("../diff/generate-diff");
 const write_diff_yaml_1 = require("../diff/write-diff-yaml");
 const prompts_1 = require("../shared/prompts");
@@ -82,15 +83,20 @@ program
     .option("--schema-diff-exclude-table <table...>", "Table(s) to exclude from schema diff")
     .option("--pg-triggers-table <table...>", "Table(s) to include for PostgreSQL triggers diff")
     .option("--pg-triggers-exclude-table <table...>", "Table(s) to exclude from PostgreSQL triggers diff")
+    .option("--pg-view <view...>", "View(s) to include for PostgreSQL views diff")
+    .option("--pg-view-exclude <view...>", "View(s) to exclude from PostgreSQL views diff")
     .option("--ignore-column <column...>", "Column(s) to ignore during comparison")
     .option("--include-deletes", "Include deletes in the diff (rows in dest not in source)")
     .option("--skip-missing-pk", "Skip tables that have no primary key instead of failing")
     .option("--output <file>", "Output diff file path")
     .option("--schema-diff-output <file>", "Output schema diff file path")
     .option("--pg-triggers-output <file>", "Output PostgreSQL triggers diff file path")
+    .option("--pg-views-output <file>", "Output PostgreSQL views diff file path")
     .option("--pretty", "Pretty-print the output JSON")
     .option("--generate-pg-triggers", "Generate a PostgreSQL triggers and functions diff")
     .option("--no-generate-pg-triggers", "Do not generate a PostgreSQL triggers and functions diff")
+    .option("--generate-pg-views", "Generate a PostgreSQL views diff")
+    .option("--no-generate-pg-views", "Do not generate a PostgreSQL views diff")
     .option("--verbose", "Enable verbose logging")
     .option("--config <file>", "Path to config file", load_config_1.DEFAULT_CONFIG_FILENAME)
     .option("--wizard <value>", "Force the interactive wizard (use true or 1)")
@@ -136,14 +142,18 @@ async function main() {
         schemaDiffExcludeTables: opts["schemaDiffExcludeTable"],
         pgTriggersTables: opts["pgTriggersTable"],
         pgTriggersExcludeTables: opts["pgTriggersExcludeTable"],
+        pgViews: opts["pgView"],
+        pgViewsExclude: opts["pgViewExclude"],
         ignoreColumns: opts["ignoreColumn"],
         includeDeletes: opts["includeDeletes"] ? true : undefined,
         skipMissingPk: opts["skipMissingPk"] ? true : undefined,
         output: opts["output"],
         schemaDiffOutput: opts["schemaDiffOutput"],
         pgTriggersOutput: opts["pgTriggersOutput"],
+        pgViewsOutput: opts["pgViewsOutput"],
         pretty: opts["pretty"] ? true : undefined,
         generatePgTriggers: normalizeOptionalBoolean(opts["generatePgTriggers"]),
+        generatePgViews: normalizeOptionalBoolean(opts["generatePgViews"]),
         verbose: opts["verbose"] ? true : undefined,
     };
     // Remove undefined values
@@ -173,6 +183,14 @@ async function main() {
     const requestedPgTriggersExcludeTables = cleanCliArgs.pgTriggersExcludeTables === null
         ? null
         : [...resolved.pgTriggersExcludeTables];
+    const requestedPgViews = [...resolved.pgViews];
+    let requestedPgViewsExclude;
+    if (cleanCliArgs.pgViewsExclude === null) {
+        requestedPgViewsExclude = null;
+    }
+    else {
+        requestedPgViewsExclude = [...resolved.pgViewsExclude];
+    }
     const requestedIgnoreColumns = cleanCliArgs.ignoreColumns === null ? null : [...resolved.ignoreColumns];
     const runtimeBaseResolved = (0, resolve_options_1.resolveRuntimeGeneratorOptions)({
         ...resolved,
@@ -182,6 +200,8 @@ async function main() {
         schemaDiffExcludeTables: resolved.schemaDiffExcludeTables,
         pgTriggersTables: requestedPgTriggersTables,
         pgTriggersExcludeTables: resolved.pgTriggersExcludeTables,
+        pgViews: requestedPgViews,
+        pgViewsExclude: resolved.pgViewsExclude,
         ignoreColumns: resolved.ignoreColumns,
     });
     // Validate required values
@@ -215,6 +235,8 @@ async function main() {
         schemaDiffExcludeTables: requestedSchemaDiffExcludeTables,
         pgTriggersTables: requestedPgTriggersTables,
         pgTriggersExcludeTables: requestedPgTriggersExcludeTables,
+        pgViews: requestedPgViews,
+        pgViewsExclude: requestedPgViewsExclude,
         ignoreColumns: requestedIgnoreColumns,
     }, (0, resolve_options_1.resolveApplyOptions)(loadedConfig?.apply, {
         destPgHost: resolved.destPgHost,
@@ -228,6 +250,16 @@ async function main() {
         if (configExists) {
             const shouldUpdate = await (0, prompts_1.confirmUpdateConfig)();
             if (shouldUpdate) {
+                const date = new Date();
+                const yyyy = date.getFullYear();
+                const mm = String(date.getMonth() + 1).padStart(2, "0");
+                const dd = String(date.getDate()).padStart(2, "0");
+                const hh = String(date.getHours()).padStart(2, "0");
+                const min = String(date.getMinutes()).padStart(2, "0");
+                const ss = String(date.getSeconds()).padStart(2, "0");
+                const backupPath = `${configFilePath}~${yyyy}-${mm}-${dd}-${hh}${min}${ss}`;
+                fs.copyFileSync(configFilePath, backupPath);
+                console.log(`Backup of previous config saved to: ${backupPath}`);
                 (0, write_config_1.writeConfig)(configFilePath, configToWrite);
                 configWritten = true;
                 configUpdatedThisRun = true;
@@ -304,7 +336,8 @@ async function main() {
         const expandedTables = resolvedTablePatterns.data;
         const expandedSchemaDiffTables = resolvedTablePatterns.schema;
         const expandedPgTriggersTables = resolvedTablePatterns.pgTriggers;
-        console.log(`Resolved ${expandedTables.tables.length} data table(s), ${expandedSchemaDiffTables.tables.length} schema table(s), and ${expandedPgTriggersTables.tables.length} PostgreSQL trigger table(s).`);
+        const expandedPgViews = resolvedTablePatterns.pgViews;
+        console.log(`Resolved ${expandedTables.tables.length} data table(s), ${expandedSchemaDiffTables.tables.length} schema table(s), ${expandedPgTriggersTables.tables.length} PostgreSQL trigger table(s), and ${expandedPgViews.views.length} PostgreSQL view(s).`);
         const runtimeResolved = {
             ...runtimeBaseResolved,
             tables: expandedTables.tables,
@@ -313,6 +346,8 @@ async function main() {
             schemaDiffExcludeTables: expandedSchemaDiffTables.excludedTables,
             pgTriggersTables: expandedPgTriggersTables.tables,
             pgTriggersExcludeTables: expandedPgTriggersTables.excludedTables,
+            pgViews: expandedPgViews.views,
+            pgViewsExclude: expandedPgViews.excludedViews,
         };
         const logProgress = (message) => {
             console.log(message);
@@ -323,9 +358,9 @@ async function main() {
             }
             : undefined;
         // Print resolved plan
-        printResolvedPlan(resolved, runtimeResolved.tables, runtimeResolved.excludeTables, runtimeResolved.schemaDiffTables, runtimeResolved.schemaDiffExcludeTables, runtimeResolved.pgTriggersTables, runtimeResolved.pgTriggersExcludeTables, sourceConnection, destConnection);
+        printResolvedPlan(resolved, runtimeResolved.tables, runtimeResolved.excludeTables, runtimeResolved.schemaDiffTables, runtimeResolved.schemaDiffExcludeTables, runtimeResolved.pgTriggersTables, runtimeResolved.pgTriggersExcludeTables, runtimeResolved.pgViews, runtimeResolved.pgViewsExclude, sourceConnection, destConnection);
         console.log("Connecting to databases...");
-        console.log(`Comparing ${runtimeResolved.tables.length} data table(s), ${runtimeResolved.schemaDiffTables.length} schema table(s), and ${runtimeResolved.pgTriggersTables.length} PostgreSQL trigger table(s)...`);
+        console.log(`Comparing ${runtimeResolved.tables.length} data table(s), ${runtimeResolved.schemaDiffTables.length} schema table(s), ${runtimeResolved.pgTriggersTables.length} PostgreSQL trigger table(s), and ${runtimeResolved.pgViews.length} PostgreSQL view(s)...`);
         console.log("Starting data and schema diff generation...");
         const [diff, schemaDiff] = await Promise.all([
             (0, generate_diff_1.generateDiff)(sourcePool, destPool, {
@@ -356,6 +391,7 @@ async function main() {
         const schemaDiffYamlOutputPath = path.resolve((0, write_diff_yaml_1.buildYamlOutputPath)(runtimeResolved.schemaDiffOutput));
         const schemaDiffSqlOutputPath = path.resolve((0, generate_schema_sql_1.buildSchemaSqlOutputPath)(runtimeResolved.schemaDiffOutput));
         const pgTriggersOutputPath = path.resolve(runtimeResolved.pgTriggersOutput);
+        const pgViewsOutputPath = path.resolve(runtimeResolved.pgViewsOutput);
         console.log("Writing JSON and YAML diff artifacts...");
         const dataContent = runtimeResolved.pretty
             ? JSON.stringify(diff, null, 2) + "\n"
@@ -376,6 +412,7 @@ async function main() {
         fs.writeFileSync(schemaDiffSqlOutputPath, schemaSqlResult.sql, "utf-8");
         let sqlGenerated = false;
         let pgTriggersSqlGenerated = false;
+        let pgViewsSqlGenerated = false;
         console.log("\nData diff summary:");
         console.log(`  Tables compared: ${diff.summary.tablesCompared}`);
         console.log(`  Inserts: ${diff.summary.inserts}`);
@@ -471,6 +508,72 @@ async function main() {
                 pgTriggersSqlGenerated = true;
             }
         }
+        let shouldGeneratePgViews = false;
+        if (runtimeResolved.generatePgViews !== undefined) {
+            shouldGeneratePgViews = runtimeResolved.generatePgViews;
+        }
+        else if (shouldAskInteractiveQuestion(opts["yes"])) {
+            shouldGeneratePgViews = await (0, prompts_1.confirmProceed)("\nGenerate a PostgreSQL views diff? (SQL script) [yes]: ", true);
+        }
+        if (shouldGeneratePgViews) {
+            console.log("\nGenerating PostgreSQL views diff...");
+            const pgViewsArgs = [];
+            if (configWritten) {
+                pgViewsArgs.push("--config", path.relative(process.cwd(), configFilePath) ||
+                    load_config_1.DEFAULT_CONFIG_FILENAME);
+            }
+            else {
+                // Pass all resolved args down manually if no config is available.
+                // This is a rare edge case, usually we write the config.
+                pgViewsArgs.push("--source-pg-host", resolved.sourcePgHost);
+                pgViewsArgs.push("--source-pg-port", String(resolved.sourcePgPort));
+                pgViewsArgs.push("--source-pg-database", resolved.sourcePgDatabase);
+                pgViewsArgs.push("--source-pg-user", resolved.sourcePgUser);
+                if ((0, env_values_1.isEnvReference)(resolved.sourcePgPassword)) {
+                    pgViewsArgs.push("--source-pg-password-env", resolved.sourcePgPassword);
+                }
+                if (resolved.sourcePgSsl) {
+                    pgViewsArgs.push("--source-pg-ssl");
+                }
+                else {
+                    pgViewsArgs.push("--no-source-pg-ssl");
+                }
+                pgViewsArgs.push("--dest-pg-host", resolved.destPgHost);
+                pgViewsArgs.push("--dest-pg-port", String(resolved.destPgPort));
+                pgViewsArgs.push("--dest-pg-database", resolved.destPgDatabase);
+                pgViewsArgs.push("--dest-pg-user", resolved.destPgUser);
+                if ((0, env_values_1.isEnvReference)(resolved.destPgPassword)) {
+                    pgViewsArgs.push("--dest-pg-password-env", resolved.destPgPassword);
+                }
+                if (resolved.destPgSsl) {
+                    pgViewsArgs.push("--dest-pg-ssl");
+                }
+                else {
+                    pgViewsArgs.push("--no-dest-pg-ssl");
+                }
+                pgViewsArgs.push("--schema", resolved.schema);
+                for (const viewName of runtimeResolved.pgViews) {
+                    pgViewsArgs.push("--view", viewName);
+                }
+                for (const viewName of runtimeResolved.pgViewsExclude) {
+                    pgViewsArgs.push("--exclude-view", viewName);
+                }
+                pgViewsArgs.push("--output", runtimeResolved.pgViewsOutput);
+            }
+            if (runtimeResolved.verbose) {
+                pgViewsArgs.push("--verbose");
+            }
+            const pgViewsCommandPath = path.join(__dirname, "pg-views.js");
+            const res = (0, child_process_1.spawnSync)(process.execPath, [pgViewsCommandPath, ...pgViewsArgs], {
+                stdio: "inherit",
+            });
+            if (res.status !== 0) {
+                console.error("Warning: pg-views diff generation failed.");
+            }
+            else {
+                pgViewsSqlGenerated = true;
+            }
+        }
         console.log("\nReview the data diff and schema SQL carefully before applying anything.");
         if (!sqlGenerated) {
             console.log("\nGenerate SQL Diff:");
@@ -490,6 +593,9 @@ async function main() {
         if (pgTriggersSqlGenerated) {
             console.log(`PostgreSQL triggers SQL written to: ${pgTriggersOutputPath}`);
         }
+        if (pgViewsSqlGenerated) {
+            console.log(`PostgreSQL views SQL written to: ${pgViewsOutputPath}`);
+        }
         console.log("");
     }
     finally {
@@ -569,10 +675,13 @@ async function resolveGeneratorTablePatterns(sourcePool, destPool, resolved, log
         destClient = await runLoggedAsyncStep("connecting to destination database for table resolution", () => destPool.connect(), logProgress);
         const sourceTables = await listTablesWithProgress(sourceClient, resolved.schema, "source", logProgress);
         const destTables = await listTablesWithProgress(destClient, resolved.schema, "destination", logProgress);
+        const sourceViews = await listPgViewsWithProgress(sourceClient, resolved.schema, "source", logProgress);
+        const destViews = await listPgViewsWithProgress(destClient, resolved.schema, "destination", logProgress);
         const data = resolveTablePatternGroup("data", sourceTables, destTables, resolved.tables, resolved.excludeTables, "common", logProgress);
         const schema = resolveTablePatternGroup("schema diff", sourceTables, destTables, resolved.schemaDiffTables, resolved.schemaDiffExcludeTables, "either", logProgress);
         const pgTriggers = resolveTablePatternGroup("PostgreSQL trigger", sourceTables, destTables, resolved.pgTriggersTables, resolved.pgTriggersExcludeTables, "common", logProgress);
-        return { data, schema, pgTriggers };
+        const pgViews = resolveViewPatternGroup("PostgreSQL view", sourceViews, destViews, resolved.pgViews, resolved.pgViewsExclude, logProgress);
+        return { data, schema, pgTriggers, pgViews };
     }
     finally {
         if (destClient !== undefined) {
@@ -591,6 +700,12 @@ async function listTablesWithProgress(client, schema, databaseLabel, logProgress
     logProgress(`[table resolution] ${databaseLabel} table preview: ${formatStringList(tables)}`);
     return tables;
 }
+async function listPgViewsWithProgress(client, schema, databaseLabel, logProgress) {
+    const views = await runLoggedAsyncStep(`scanning ${databaseLabel} views in schema "${schema}"`, () => (0, pg_views_1.listPgViews)(client, schema), logProgress);
+    logProgress(`[view resolution] ${databaseLabel} database returned ${views.length} view(s).`);
+    logProgress(`[view resolution] ${databaseLabel} view preview: ${formatStringList(views)}`);
+    return views;
+}
 function resolveTablePatternGroup(label, sourceTables, destTables, includePatterns, excludePatterns, availability, logProgress) {
     const startedAt = Date.now();
     logProgress(`[table resolution] resolving ${label} patterns against ${formatAvailability(availability)}.`);
@@ -616,6 +731,25 @@ function resolveTablePatternGroup(label, sourceTables, destTables, includePatter
         throw error;
     }
 }
+function resolveViewPatternGroup(label, sourceViews, destViews, includePatterns, excludePatterns, logProgress) {
+    const startedAt = Date.now();
+    logProgress(`[view resolution] resolving ${label} patterns.`);
+    logProgress(`[view resolution] ${label} include patterns: ${formatStringList(includePatterns)}`);
+    logProgress(`[view resolution] ${label} exclude patterns: ${formatStringList(excludePatterns)}`);
+    try {
+        const result = (0, pg_views_1.resolvePgViewPatternsFromViewLists)(sourceViews, destViews, includePatterns, excludePatterns);
+        logProgress(`[view resolution] resolved ${label} patterns in ${formatDuration(Date.now() - startedAt)}.`);
+        logProgress(`[view resolution] ${label} views: ${formatStringList(result.views)}`);
+        if (result.excludedViews.length > 0) {
+            logProgress(`[view resolution] ${label} excluded views: ${formatStringList(result.excludedViews)}`);
+        }
+        return result;
+    }
+    catch (error) {
+        console.error(`[view resolution] failed to resolve ${label} patterns after ${formatDuration(Date.now() - startedAt)}.`);
+        throw error;
+    }
+}
 async function runLoggedAsyncStep(label, action, logProgress) {
     const startedAt = Date.now();
     logProgress(`[table resolution] ${label}...`);
@@ -676,7 +810,7 @@ function shellEscapeArg(value) {
     }
     return `'${value.replace(/'/g, `'\\''`)}'`;
 }
-function printResolvedPlan(resolved, expandedTables, expandedExcludeTables, expandedSchemaDiffTables, expandedSchemaDiffExcludeTables, expandedPgTriggersTables, expandedPgTriggersExcludeTables, sourceConnection, destConnection) {
+function printResolvedPlan(resolved, expandedTables, expandedExcludeTables, expandedSchemaDiffTables, expandedSchemaDiffExcludeTables, expandedPgTriggersTables, expandedPgTriggersExcludeTables, expandedPgViews, expandedPgViewsExclude, sourceConnection, destConnection) {
     console.log("\ntool:");
     console.log("  frg-data-diff generate");
     console.log("\nsource:");
@@ -741,10 +875,22 @@ function printResolvedPlan(resolved, expandedTables, expandedExcludeTables, expa
         console.log("expanded pg triggers exclude tables: " +
             expandedPgTriggersExcludeTables.join(", "));
     }
+    console.log("pg views output: " + resolved.pgViewsOutput);
+    console.log("pg views: " + resolved.pgViews.join(", "));
+    if (expandedPgViews.join(",") !== resolved.pgViews.join(",")) {
+        console.log("expanded pg views: " + expandedPgViews.join(", "));
+    }
+    if (resolved.pgViewsExclude.length > 0) {
+        console.log("pg views exclude: " + resolved.pgViewsExclude.join(", "));
+    }
+    if (expandedPgViewsExclude.join(",") !== resolved.pgViewsExclude.join(",")) {
+        console.log("expanded pg views exclude: " + expandedPgViewsExclude.join(", "));
+    }
     console.log("include deletes: " + resolved.includeDeletes);
     console.log("pretty: " + resolved.pretty);
     console.log("generate sql: " + (resolved.generateSql ?? "interactive"));
     console.log("generate pg triggers: " + (resolved.generatePgTriggers ?? "interactive"));
+    console.log("generate pg views: " + (resolved.generatePgViews ?? "interactive"));
 }
 function hasAnyGeneratorArgs(argv) {
     const argKeys = [
@@ -770,14 +916,19 @@ function hasAnyGeneratorArgs(argv) {
         "--schema-diff-exclude-table",
         "--pg-triggers-table",
         "--pg-triggers-exclude-table",
+        "--pg-view",
+        "--pg-view-exclude",
         "--include-deletes",
         "--skip-missing-pk",
         "--output",
         "--schema-diff-output",
         "--pg-triggers-output",
+        "--pg-views-output",
         "--pretty",
         "--generate-pg-triggers",
         "--no-generate-pg-triggers",
+        "--generate-pg-views",
+        "--no-generate-pg-views",
         "--verbose",
         "--config",
         "--wizard",

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

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

package/dist/cli/pg-views.js

@@ -0,0 +1,195 @@
+"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_views_diff_1 = require("../diff/pg-views-diff");
+const program = new commander_1.Command();
+program
+    .name("frg-data-diff pg-views")
+    .description("Compare PostgreSQL view definitions and write a SQL diff script.")
+    .option("--source-pg-host <host>", "Source database host")
+    .option("--source-pg-port <port>", "Source database port", (value) => parseInt(value, 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", (value) => parseInt(value, 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("--view <view...>", "View(s) to include")
+    .option("--exclude-view <view...>", "View(s) to exclude")
+    .option("--output <file>", "Output diff file path", "frg-views-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;
+    }
+    let verbose;
+    if (opts["verbose"]) {
+        verbose = true;
+    }
+    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"],
+        pgViews: opts["view"],
+        pgViewsExclude: opts["excludeView"],
+        pgViewsOutput: opts["output"],
+        verbose,
+    };
+    const cleanCliArgs = Object.fromEntries(Object.entries(cliArgs).filter(([, value]) => value !== 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],
+        pgViews: [...resolved.pgViews],
+        pgViewsExclude: [...resolved.pgViewsExclude],
+        ignoreColumns: [...resolved.ignoreColumns],
+    });
+    console.log("frg-data-diff: generate pg-views");
+    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-views diff...");
+        let onVerboseProgress;
+        if (runtimeResolved.verbose) {
+            onVerboseProgress = (message) => {
+                console.log(message);
+            };
+        }
+        const diffOptions = {
+            schema: runtimeResolved.schema,
+            views: runtimeResolved.pgViews,
+            excludeViews: runtimeResolved.pgViewsExclude,
+            verbose: runtimeResolved.verbose,
+            onProgress: (message) => {
+                console.log(message);
+            },
+            onVerboseProgress,
+        };
+        const sql = await (0, pg_views_diff_1.generatePgViewsDiffSql)(sourcePool, destPool, diffOptions);
+        const output = runtimeResolved.pgViewsOutput;
+        fs.writeFileSync(output, sql, "utf-8");
+        console.log(`Wrote views diff SQL to ${output}`);
+    }
+    catch (error) {
+        console.error("Failed to generate pg-views 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-views.js.map