frg-data-diff 2.0.0

package/dist/config/resolve-options.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveGeneratorOptions = resolveGeneratorOptions;
+exports.resolveApplyOptions = resolveApplyOptions;
+exports.resolveRuntimeGeneratorOptions = resolveRuntimeGeneratorOptions;
+exports.resolveRuntimeApplyOptions = resolveRuntimeApplyOptions;
+const env_values_1 = require("../shared/env-values");
+/**
+ * Merges generator CLI args on top of config values.
+ * CLI args take precedence over config values.
+ */
+function resolveGeneratorOptions(config, cliArgs) {
+    const defaults = {
+        schema: "public",
+        tables: [],
+        excludeTables: [],
+        schemaDiffTables: [],
+        schemaDiffExcludeTables: [],
+        pgTriggersTables: [],
+        pgTriggersExcludeTables: [],
+        ignoreColumns: [],
+        tablesWhereDataFilters: {},
+        includeDeletes: true,
+        skipMissingPk: true,
+        output: "frg-data-diff.json",
+        schemaDiffOutput: "frg-schema-diff.json",
+        pgTriggersOutput: "frg-triggers-diff.sql",
+        pretty: true,
+        verbose: false,
+    };
+    const tables = cliArgs.tables ?? config?.tables ?? defaults.tables;
+    const excludeTables = resolveOptionalListOption(cliArgs.excludeTables, config?.excludeTables, defaults.excludeTables);
+    const schemaDiffTables = resolveInheritedTableListOption(cliArgs.schemaDiffTables, config?.schemaDiffTables, tables);
+    const schemaDiffExcludeTables = resolveOptionalListOption(cliArgs.schemaDiffExcludeTables, config?.schemaDiffExcludeTables, excludeTables);
+    const pgTriggersTables = resolveInheritedTableListOption(cliArgs.pgTriggersTables, config?.pgTriggersTables, tables);
+    const pgTriggersExcludeTables = resolveOptionalListOption(cliArgs.pgTriggersExcludeTables, config?.pgTriggersExcludeTables, excludeTables);
+    const ignoreColumns = resolveOptionalListOption(cliArgs.ignoreColumns, config?.ignoreColumns, defaults.ignoreColumns);
+    return {
+        sourcePgHost: cliArgs.sourcePgHost ?? config?.sourcePgHost ?? "",
+        sourcePgPort: cliArgs.sourcePgPort ?? config?.sourcePgPort ?? 5432,
+        sourcePgDatabase: cliArgs.sourcePgDatabase ?? config?.sourcePgDatabase ?? "",
+        sourcePgUser: cliArgs.sourcePgUser ?? config?.sourcePgUser ?? "",
+        sourcePgPassword: cliArgs.sourcePgPassword ?? config?.sourcePgPassword ?? "",
+        sourcePgSsl: cliArgs.sourcePgSsl ?? config?.sourcePgSsl ?? false,
+        destPgHost: cliArgs.destPgHost ?? config?.destPgHost ?? "",
+        destPgPort: cliArgs.destPgPort ?? config?.destPgPort ?? 5432,
+        destPgDatabase: cliArgs.destPgDatabase ?? config?.destPgDatabase ?? "",
+        destPgUser: cliArgs.destPgUser ?? config?.destPgUser ?? "",
+        destPgPassword: cliArgs.destPgPassword ?? config?.destPgPassword ?? "",
+        destPgSsl: cliArgs.destPgSsl ?? config?.destPgSsl ?? false,
+        schema: cliArgs.schema ?? config?.schema ?? defaults.schema,
+        tables,
+        excludeTables,
+        schemaDiffTables,
+        schemaDiffExcludeTables,
+        pgTriggersTables,
+        pgTriggersExcludeTables,
+        ignoreColumns,
+        tablesWhereDataFilters: cliArgs.tablesWhereDataFilters ??
+            config?.tablesWhereDataFilters ??
+            defaults.tablesWhereDataFilters,
+        includeDeletes: cliArgs.includeDeletes ??
+            config?.includeDeletes ??
+            defaults.includeDeletes,
+        skipMissingPk: cliArgs.skipMissingPk ?? config?.skipMissingPk ?? defaults.skipMissingPk,
+        output: cliArgs.output ?? config?.output ?? defaults.output,
+        schemaDiffOutput: cliArgs.schemaDiffOutput ??
+            config?.schemaDiffOutput ??
+            defaults.schemaDiffOutput,
+        pgTriggersOutput: cliArgs.pgTriggersOutput ??
+            config?.pgTriggersOutput ??
+            defaults.pgTriggersOutput,
+        pretty: cliArgs.pretty ?? config?.pretty ?? defaults.pretty,
+        generateSql: cliArgs.generateSql ?? config?.generateSql,
+        generatePgTriggers: cliArgs.generatePgTriggers ?? config?.generatePgTriggers,
+        verbose: cliArgs.verbose ?? defaults.verbose,
+    };
+}
+function resolveOptionalListOption(cliValue, configValue, fallback) {
+    if (cliValue !== undefined) {
+        return cliValue ?? [];
+    }
+    if (configValue !== undefined) {
+        return configValue ?? [];
+    }
+    return fallback;
+}
+function resolveInheritedTableListOption(cliValue, configValue, fallback) {
+    if (cliValue !== undefined && cliValue.length > 0) {
+        return cliValue;
+    }
+    if (configValue !== undefined && configValue.length > 0) {
+        return configValue;
+    }
+    return fallback;
+}
+/**
+ * Merges apply CLI args on top of config values.
+ * CLI args take precedence over config values.
+ */
+function resolveApplyOptions(config, cliArgs) {
+    const defaults = {
+        input: "frg-data-diff.json",
+        dryRun: true,
+        applyInserts: true,
+        applyUpdates: true,
+        applyDeletes: false,
+        conflictMode: "abort",
+        insertMode: "strict",
+        transaction: true,
+        verbose: false,
+    };
+    return {
+        destPgHost: cliArgs.destPgHost ?? config?.destPgHost ?? "",
+        destPgPort: cliArgs.destPgPort ?? config?.destPgPort ?? 5432,
+        destPgDatabase: cliArgs.destPgDatabase ?? config?.destPgDatabase ?? "",
+        destPgUser: cliArgs.destPgUser ?? config?.destPgUser ?? "",
+        destPgPassword: cliArgs.destPgPassword ?? config?.destPgPassword ?? "",
+        destPgSsl: cliArgs.destPgSsl ?? config?.destPgSsl ?? false,
+        input: cliArgs.input ?? config?.input ?? defaults.input,
+        dryRun: cliArgs.dryRun ?? config?.dryRun ?? defaults.dryRun,
+        applyInserts: cliArgs.applyInserts ?? config?.applyInserts ?? defaults.applyInserts,
+        applyUpdates: cliArgs.applyUpdates ?? config?.applyUpdates ?? defaults.applyUpdates,
+        applyDeletes: cliArgs.applyDeletes ?? config?.applyDeletes ?? defaults.applyDeletes,
+        conflictMode: cliArgs.conflictMode ?? config?.conflictMode ?? defaults.conflictMode,
+        insertMode: cliArgs.insertMode ?? config?.insertMode ?? defaults.insertMode,
+        transaction: cliArgs.transaction ?? config?.transaction ?? defaults.transaction,
+        verbose: cliArgs.verbose ?? defaults.verbose,
+    };
+}
+function resolveRuntimeGeneratorOptions(options) {
+    let generateSql;
+    if (options.generateSql !== undefined) {
+        generateSql = (0, env_values_1.resolveBooleanValue)(options.generateSql, "generate sql");
+    }
+    let generatePgTriggers;
+    if (options.generatePgTriggers !== undefined) {
+        generatePgTriggers = (0, env_values_1.resolveBooleanValue)(options.generatePgTriggers, "generate pg triggers");
+    }
+    return {
+        ...options,
+        schema: (0, env_values_1.resolveStringValue)(options.schema, "schema"),
+        tables: (0, env_values_1.resolveListValues)(options.tables, "tables"),
+        excludeTables: (0, env_values_1.resolveListValues)(options.excludeTables, "exclude tables"),
+        schemaDiffTables: (0, env_values_1.resolveListValues)(options.schemaDiffTables, "schema diff tables"),
+        schemaDiffExcludeTables: (0, env_values_1.resolveListValues)(options.schemaDiffExcludeTables, "schema diff exclude tables"),
+        pgTriggersTables: (0, env_values_1.resolveListValues)(options.pgTriggersTables, "pg triggers tables"),
+        pgTriggersExcludeTables: (0, env_values_1.resolveListValues)(options.pgTriggersExcludeTables, "pg triggers exclude tables"),
+        ignoreColumns: (0, env_values_1.resolveListValues)(options.ignoreColumns, "ignored columns"),
+        sourcePgSsl: (0, env_values_1.resolveBooleanValue)(options.sourcePgSsl, "source ssl"),
+        destPgSsl: (0, env_values_1.resolveBooleanValue)(options.destPgSsl, "destination ssl"),
+        includeDeletes: (0, env_values_1.resolveBooleanValue)(options.includeDeletes, "include deletes"),
+        skipMissingPk: (0, env_values_1.resolveBooleanValue)(options.skipMissingPk, "skip missing primary keys"),
+        output: (0, env_values_1.resolveStringValue)(options.output, "output file"),
+        schemaDiffOutput: (0, env_values_1.resolveStringValue)(options.schemaDiffOutput, "schema diff output file"),
+        pgTriggersOutput: (0, env_values_1.resolveStringValue)(options.pgTriggersOutput, "pg triggers output file"),
+        pretty: (0, env_values_1.resolveBooleanValue)(options.pretty, "pretty-print json"),
+        generateSql,
+        generatePgTriggers,
+    };
+}
+function resolveRuntimeApplyOptions(options) {
+    return {
+        ...options,
+        destPgSsl: (0, env_values_1.resolveBooleanValue)(options.destPgSsl, "destination ssl"),
+        input: (0, env_values_1.resolveStringValue)(options.input, "input file"),
+        dryRun: (0, env_values_1.resolveBooleanValue)(options.dryRun, "dry-run"),
+        applyInserts: (0, env_values_1.resolveBooleanValue)(options.applyInserts, "apply inserts"),
+        applyUpdates: (0, env_values_1.resolveBooleanValue)(options.applyUpdates, "apply updates"),
+        applyDeletes: (0, env_values_1.resolveBooleanValue)(options.applyDeletes, "apply deletes"),
+        conflictMode: (0, env_values_1.resolveEnumValue)(options.conflictMode, "conflict mode", [
+            "abort",
+            "skip",
+            "overwrite",
+        ]),
+        insertMode: (0, env_values_1.resolveEnumValue)(options.insertMode, "insert mode", [
+            "strict",
+            "upsert",
+        ]),
+        transaction: (0, env_values_1.resolveBooleanValue)(options.transaction, "transaction"),
+    };
+}
+//# sourceMappingURL=resolve-options.js.map

package/dist/config/write-config.d.ts

@@ -0,0 +1,18 @@
+import { type ResolvedGeneratorOptions, type ResolvedApplyOptions, type OptionalListInput } from "./resolve-options";
+type WritableGeneratorOptions = Omit<ResolvedGeneratorOptions, "excludeTables" | "schemaDiffExcludeTables" | "pgTriggersExcludeTables" | "ignoreColumns"> & {
+    excludeTables: OptionalListInput;
+    schemaDiffExcludeTables: OptionalListInput;
+    pgTriggersExcludeTables: OptionalListInput;
+    ignoreColumns: OptionalListInput;
+};
+/**
+ * Builds a config object from resolved generator and apply options.
+ * Values may be plain text or $ENV_VAR references, depending on user input.
+ */
+export declare function buildConfigFile(generatorOptions: WritableGeneratorOptions, applyOptions: ResolvedApplyOptions): object;
+/**
+ * Writes the config object to the given path as formatted JSON.
+ */
+export declare function writeConfig(configPath: string, config: object): void;
+export {};
+//# sourceMappingURL=write-config.d.ts.map

package/dist/config/write-config.js

@@ -0,0 +1,103 @@
+"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.buildConfigFile = buildConfigFile;
+exports.writeConfig = writeConfig;
+const fs = __importStar(require("fs"));
+/**
+ * Builds a config object from resolved generator and apply options.
+ * Values may be plain text or $ENV_VAR references, depending on user input.
+ */
+function buildConfigFile(generatorOptions, applyOptions) {
+    const generator = {
+        sourcePgHost: generatorOptions.sourcePgHost,
+        sourcePgPort: generatorOptions.sourcePgPort,
+        sourcePgDatabase: generatorOptions.sourcePgDatabase,
+        sourcePgUser: generatorOptions.sourcePgUser,
+        sourcePgPassword: generatorOptions.sourcePgPassword,
+        sourcePgSsl: generatorOptions.sourcePgSsl,
+        destPgHost: generatorOptions.destPgHost,
+        destPgPort: generatorOptions.destPgPort,
+        destPgDatabase: generatorOptions.destPgDatabase,
+        destPgUser: generatorOptions.destPgUser,
+        destPgPassword: generatorOptions.destPgPassword,
+        destPgSsl: generatorOptions.destPgSsl,
+        schema: generatorOptions.schema,
+        tables: generatorOptions.tables,
+        tablesWhereDataFilters: generatorOptions.tablesWhereDataFilters ?? {},
+        excludeTables: generatorOptions.excludeTables ?? [],
+        schemaDiffTables: generatorOptions.schemaDiffTables,
+        schemaDiffExcludeTables: generatorOptions.schemaDiffExcludeTables ?? [],
+        pgTriggersTables: generatorOptions.pgTriggersTables,
+        pgTriggersExcludeTables: generatorOptions.pgTriggersExcludeTables ?? [],
+        ignoreColumns: generatorOptions.ignoreColumns ?? [],
+        includeDeletes: generatorOptions.includeDeletes,
+        skipMissingPk: generatorOptions.skipMissingPk,
+        output: generatorOptions.output,
+        schemaDiffOutput: generatorOptions.schemaDiffOutput,
+        pgTriggersOutput: generatorOptions.pgTriggersOutput,
+        pretty: generatorOptions.pretty,
+        generateSql: generatorOptions.generateSql,
+        generatePgTriggers: generatorOptions.generatePgTriggers,
+    };
+    return {
+        format: "frg-data-diff-config/v1",
+        generator,
+        apply: {
+            destPgHost: applyOptions.destPgHost,
+            destPgPort: applyOptions.destPgPort,
+            destPgDatabase: applyOptions.destPgDatabase,
+            destPgUser: applyOptions.destPgUser,
+            destPgPassword: applyOptions.destPgPassword,
+            destPgSsl: applyOptions.destPgSsl,
+            input: applyOptions.input,
+            dryRun: applyOptions.dryRun,
+            applyInserts: applyOptions.applyInserts,
+            applyUpdates: applyOptions.applyUpdates,
+            applyDeletes: applyOptions.applyDeletes,
+            conflictMode: applyOptions.conflictMode,
+            insertMode: applyOptions.insertMode,
+            transaction: applyOptions.transaction,
+        },
+    };
+}
+/**
+ * Writes the config object to the given path as formatted JSON.
+ */
+function writeConfig(configPath, config) {
+    const content = JSON.stringify(config, null, 2) + "\n";
+    fs.writeFileSync(configPath, content, "utf-8");
+}
+//# sourceMappingURL=write-config.js.map

package/dist/db/connection.d.ts

@@ -0,0 +1,28 @@
+import { Pool, type PoolConfig } from "pg";
+export declare const DEFAULT_CONNECTION_TIMEOUT_MS = 30000;
+export interface PgConnectionParams {
+    host: string;
+    port: number | string;
+    database: string;
+    user: string;
+    password: string;
+    ssl: boolean | string;
+}
+export interface ResolvedPgConnectionParams {
+    host: string;
+    port: number;
+    database: string;
+    user: string;
+    password: string;
+    ssl: boolean;
+}
+export declare function resolveConnectionParams(params: PgConnectionParams, labels: {
+    host: string;
+    port: string;
+    database: string;
+    user: string;
+    password: string;
+}, env?: NodeJS.ProcessEnv): ResolvedPgConnectionParams;
+export declare function createPool(params: ResolvedPgConnectionParams): Pool;
+export declare function buildPoolConfig(params: ResolvedPgConnectionParams): PoolConfig;
+//# sourceMappingURL=connection.d.ts.map

package/dist/db/connection.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CONNECTION_TIMEOUT_MS = void 0;
+exports.resolveConnectionParams = resolveConnectionParams;
+exports.createPool = createPool;
+exports.buildPoolConfig = buildPoolConfig;
+const pg_1 = require("pg");
+const env_values_1 = require("../shared/env-values");
+exports.DEFAULT_CONNECTION_TIMEOUT_MS = 30000;
+function resolveConnectionParams(params, labels, env = process.env) {
+    return {
+        host: (0, env_values_1.resolveStringValue)(params.host, labels.host, env),
+        port: (0, env_values_1.resolvePortValue)(params.port, labels.port, env),
+        database: (0, env_values_1.resolveStringValue)(params.database, labels.database, env),
+        user: (0, env_values_1.resolveStringValue)(params.user, labels.user, env),
+        password: (0, env_values_1.resolveStringValue)(params.password, labels.password, env),
+        ssl: (0, env_values_1.resolveBooleanValue)(params.ssl, `${labels.host} ssl`, env),
+    };
+}
+function createPool(params) {
+    return new pg_1.Pool(buildPoolConfig(params));
+}
+function buildPoolConfig(params) {
+    return {
+        host: params.host,
+        port: params.port,
+        database: params.database,
+        user: params.user,
+        password: params.password,
+        ssl: params.ssl ? { rejectUnauthorized: false } : undefined,
+        connectionTimeoutMillis: exports.DEFAULT_CONNECTION_TIMEOUT_MS,
+    };
+}
+//# sourceMappingURL=connection.js.map

package/dist/db/metadata.d.ts

@@ -0,0 +1,70 @@
+import { type Pool, type PoolClient } from "pg";
+export interface ColumnInfo {
+    columnName: string;
+    dataType: string;
+    udtSchema: string;
+    udtName: string;
+    isNullable: boolean;
+    isGenerated: boolean;
+    generationExpression: string | null;
+    columnDefault: string | null;
+    characterMaximumLength: number | null;
+    numericPrecision: number | null;
+    numericScale: number | null;
+    datetimePrecision: number | null;
+    intervalType: string | null;
+    intervalPrecision: number | null;
+    domainSchema: string | null;
+    domainName: string | null;
+    ordinalPosition: number;
+}
+export interface TableMetadata {
+    schema: string;
+    table: string;
+    primaryKey: string[];
+    primaryKeyConstraintName: string | null;
+    columns: ColumnInfo[];
+    /** Column names that are not generated (safe to read/write) */
+    normalColumns: string[];
+    hasPrimaryKey: boolean;
+}
+/**
+ * Fetches full metadata for a table: columns, primary key, generated columns.
+ */
+export declare function fetchTableMetadata(client: PoolClient, schema: string, table: string): Promise<TableMetadata>;
+/**
+ * Lists all base tables in the given schema.
+ */
+export declare function listTables(client: PoolClient, schema: string): Promise<string[]>;
+/**
+ * Verifies that all requested tables exist in the database.
+ * Returns the list of tables that were found.
+ */
+export declare function verifyTablesExist(pool: Pool, schema: string, tables: string[]): Promise<{
+    found: string[];
+    missing: string[];
+}>;
+export interface ResolvedTablePatterns {
+    tables: string[];
+    excludedTables: string[];
+}
+interface ResolveTablePatternOptions {
+    availability?: "common" | "either";
+}
+/**
+ * Resolves include/exclude table patterns against tables that exist in both databases.
+ * Supports "*" as a wildcard within a table name pattern.
+ */
+export declare function resolveTablePatternsFromTableLists(sourceTables: string[], destTables: string[], includePatterns: string[], excludePatterns: string[], options?: ResolveTablePatternOptions): ResolvedTablePatterns;
+/**
+ * Lists tables in both databases and resolves include/exclude patterns.
+ */
+export declare function resolveTablePatterns(sourcePool: Pool, destPool: Pool, schema: string, includePatterns: string[], excludePatterns: string[]): Promise<ResolvedTablePatterns>;
+export declare function resolveSchemaTablePatterns(sourcePool: Pool, destPool: Pool, schema: string, includePatterns: string[], excludePatterns: string[]): Promise<ResolvedTablePatterns>;
+/**
+ * Fetches a map of column name -> data_type for the given table.
+ * Used by the apply tool to build type-correct WHERE clauses for guards.
+ */
+export declare function fetchColumnTypeMap(client: PoolClient, schema: string, table: string): Promise<Record<string, string>>;
+export {};
+//# sourceMappingURL=metadata.d.ts.map

package/dist/db/metadata.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchTableMetadata = fetchTableMetadata;
+exports.listTables = listTables;
+exports.verifyTablesExist = verifyTablesExist;
+exports.resolveTablePatternsFromTableLists = resolveTablePatternsFromTableLists;
+exports.resolveTablePatterns = resolveTablePatterns;
+exports.resolveSchemaTablePatterns = resolveSchemaTablePatterns;
+exports.fetchColumnTypeMap = fetchColumnTypeMap;
+/**
+ * Fetches primary key column names for the given table.
+ */
+async function fetchPrimaryKey(client, schema, table) {
+    const result = await client.query(`
+    SELECT tc.constraint_name, kcu.column_name, kcu.ordinal_position AS key_seq
+    FROM information_schema.table_constraints tc
+    JOIN information_schema.key_column_usage kcu
+      ON tc.constraint_name = kcu.constraint_name
+      AND tc.table_schema = kcu.table_schema
+      AND tc.table_name = kcu.table_name
+    WHERE tc.constraint_type = 'PRIMARY KEY'
+      AND tc.table_schema = $1
+      AND tc.table_name = $2
+    ORDER BY kcu.ordinal_position
+    `, [schema, table]);
+    return {
+        columns: result.rows.map((r) => r.column_name),
+        constraintName: result.rows[0]?.constraint_name ?? null,
+    };
+}
+/**
+ * Fetches column information for the given table.
+ * Includes generated columns so they can be excluded from comparisons.
+ */
+async function fetchColumns(client, schema, table) {
+    const result = await client.query(`
+    SELECT
+      column_name,
+      data_type,
+      udt_schema,
+      udt_name,
+      is_nullable,
+      is_generated,
+      generation_expression,
+      column_default,
+      character_maximum_length,
+      numeric_precision,
+      numeric_scale,
+      datetime_precision,
+      interval_type,
+      interval_precision,
+      domain_schema,
+      domain_name,
+      ordinal_position
+    FROM information_schema.columns
+    WHERE table_schema = $1
+      AND table_name = $2
+    ORDER BY ordinal_position
+    `, [schema, table]);
+    return result.rows.map((r) => ({
+        columnName: r.column_name,
+        dataType: r.data_type,
+        udtSchema: r.udt_schema,
+        udtName: r.udt_name,
+        isNullable: r.is_nullable === "YES",
+        isGenerated: r.is_generated === "ALWAYS",
+        generationExpression: r.generation_expression,
+        columnDefault: r.column_default,
+        characterMaximumLength: r.character_maximum_length,
+        numericPrecision: r.numeric_precision,
+        numericScale: r.numeric_scale,
+        datetimePrecision: r.datetime_precision,
+        intervalType: r.interval_type,
+        intervalPrecision: r.interval_precision,
+        domainSchema: r.domain_schema,
+        domainName: r.domain_name,
+        ordinalPosition: r.ordinal_position,
+    }));
+}
+/**
+ * Fetches full metadata for a table: columns, primary key, generated columns.
+ */
+async function fetchTableMetadata(client, schema, table) {
+    const [primaryKey, columns] = await Promise.all([
+        fetchPrimaryKey(client, schema, table),
+        fetchColumns(client, schema, table),
+    ]);
+    const normalColumns = columns
+        .filter((c) => !c.isGenerated)
+        .map((c) => c.columnName);
+    return {
+        schema,
+        table,
+        primaryKey: primaryKey.columns,
+        primaryKeyConstraintName: primaryKey.constraintName,
+        columns,
+        normalColumns,
+        hasPrimaryKey: primaryKey.columns.length > 0,
+    };
+}
+/**
+ * Lists all base tables in the given schema.
+ */
+async function listTables(client, schema) {
+    const result = await client.query(`
+    SELECT table_name
+    FROM information_schema.tables
+    WHERE table_schema = $1
+      AND table_type = 'BASE TABLE'
+    ORDER BY table_name
+    `, [schema]);
+    return result.rows.map((r) => r.table_name);
+}
+/**
+ * Verifies that all requested tables exist in the database.
+ * Returns the list of tables that were found.
+ */
+async function verifyTablesExist(pool, schema, tables) {
+    const client = await pool.connect();
+    try {
+        const existing = await listTables(client, schema);
+        const existingSet = new Set(existing);
+        const found = tables.filter((t) => existingSet.has(t));
+        const missing = tables.filter((t) => !existingSet.has(t));
+        return { found, missing };
+    }
+    finally {
+        client.release();
+    }
+}
+/**
+ * Resolves include/exclude table patterns against tables that exist in both databases.
+ * Supports "*" as a wildcard within a table name pattern.
+ */
+function resolveTablePatternsFromTableLists(sourceTables, destTables, includePatterns, excludePatterns, options = {}) {
+    const availability = options.availability ?? "common";
+    const sourceSet = new Set(sourceTables);
+    const destSet = new Set(destTables);
+    const availableTables = availability === "either"
+        ? Array.from(new Set([...sourceTables, ...destTables])).sort()
+        : sourceTables.filter((table) => destSet.has(table));
+    const resolvedTables = [];
+    for (const pattern of includePatterns) {
+        const matches = resolvePattern(pattern, availableTables);
+        if (matches.length > 0) {
+            for (const match of matches) {
+                if (!resolvedTables.includes(match)) {
+                    resolvedTables.push(match);
+                }
+            }
+            continue;
+        }
+        if (!hasWildcard(pattern)) {
+            const missingFrom = [];
+            if (!sourceSet.has(pattern))
+                missingFrom.push("source");
+            if (!destSet.has(pattern))
+                missingFrom.push("destination");
+            throw new Error(`Table "${pattern}" was not found in the ${missingFrom.join(" and ")} database.`);
+        }
+        if (availability === "either") {
+            throw new Error(`Table pattern "${pattern}" matched no tables present in either database.`);
+        }
+        throw new Error(`Table pattern "${pattern}" matched no tables present in both databases.`);
+    }
+    const excludedTables = Array.from(new Set(excludePatterns.flatMap((pattern) => resolvePattern(pattern, resolvedTables))));
+    const tables = resolvedTables.filter((table) => !excludedTables.includes(table));
+    if (tables.length === 0) {
+        throw new Error("No tables remain after applying include and exclude table patterns.");
+    }
+    return { tables, excludedTables };
+}
+/**
+ * Lists tables in both databases and resolves include/exclude patterns.
+ */
+async function resolveTablePatterns(sourcePool, destPool, schema, includePatterns, excludePatterns) {
+    const [sourceClient, destClient] = await Promise.all([
+        sourcePool.connect(),
+        destPool.connect(),
+    ]);
+    try {
+        const [sourceTables, destTables] = await Promise.all([
+            listTables(sourceClient, schema),
+            listTables(destClient, schema),
+        ]);
+        return resolveTablePatternsFromTableLists(sourceTables, destTables, includePatterns, excludePatterns);
+    }
+    finally {
+        sourceClient.release();
+        destClient.release();
+    }
+}
+async function resolveSchemaTablePatterns(sourcePool, destPool, schema, includePatterns, excludePatterns) {
+    const [sourceClient, destClient] = await Promise.all([
+        sourcePool.connect(),
+        destPool.connect(),
+    ]);
+    try {
+        const [sourceTables, destTables] = await Promise.all([
+            listTables(sourceClient, schema),
+            listTables(destClient, schema),
+        ]);
+        return resolveTablePatternsFromTableLists(sourceTables, destTables, includePatterns, excludePatterns, {
+            availability: "either",
+        });
+    }
+    finally {
+        sourceClient.release();
+        destClient.release();
+    }
+}
+/**
+ * Fetches a map of column name -> data_type for the given table.
+ * Used by the apply tool to build type-correct WHERE clauses for guards.
+ */
+async function fetchColumnTypeMap(client, schema, table) {
+    const columns = await fetchColumns(client, schema, table);
+    const map = {};
+    for (const col of columns) {
+        map[col.columnName] = col.dataType;
+    }
+    return map;
+}
+function resolvePattern(pattern, availableTables) {
+    if (!hasWildcard(pattern)) {
+        return availableTables.includes(pattern) ? [pattern] : [];
+    }
+    const matcher = buildWildcardRegex(pattern);
+    return availableTables.filter((table) => matcher.test(table));
+}
+function hasWildcard(pattern) {
+    return pattern.includes("*");
+}
+function buildWildcardRegex(pattern) {
+    const escaped = pattern.replace(/[|\\{}()[\]^$+?.]/g, "\\$&");
+    return new RegExp(`^${escaped.replace(/\*/g, ".*")}$`);
+}
+//# sourceMappingURL=metadata.js.map