frg-data-diff 2.0.0

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

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schemaDiffJsonSchema = void 0;
+exports.validateSchemaDiffJson = validateSchemaDiffJson;
+const zod_1 = require("zod");
+const schemaColumnDefinitionSchema = zod_1.z.object({
+    name: zod_1.z.string(),
+    type: zod_1.z.string(),
+    nullable: zod_1.z.boolean(),
+    default: zod_1.z.string().nullable(),
+    isGenerated: zod_1.z.boolean(),
+    generationExpression: zod_1.z.string().nullable(),
+    ordinalPosition: zod_1.z.number().int(),
+});
+const schemaColumnChangeSchema = zod_1.z.object({
+    column: zod_1.z.string(),
+    from: schemaColumnDefinitionSchema,
+    to: schemaColumnDefinitionSchema,
+});
+const schemaCreateTableSchema = zod_1.z.object({
+    columns: zod_1.z.array(schemaColumnDefinitionSchema),
+    primaryKey: zod_1.z.array(zod_1.z.string()),
+});
+const schemaPrimaryKeyChangeSchema = zod_1.z.object({
+    from: zod_1.z.array(zod_1.z.string()),
+    to: zod_1.z.array(zod_1.z.string()),
+    dropConstraintName: zod_1.z.string().nullable(),
+});
+const schemaTableDiffSchema = zod_1.z.object({
+    table: zod_1.z.string(),
+    schema: zod_1.z.string(),
+    sourceExists: zod_1.z.boolean(),
+    destExists: zod_1.z.boolean(),
+    createTable: schemaCreateTableSchema.nullable(),
+    dropTable: zod_1.z.boolean(),
+    addColumns: zod_1.z.array(schemaColumnDefinitionSchema),
+    alterColumns: zod_1.z.array(schemaColumnChangeSchema),
+    dropColumns: zod_1.z.array(schemaColumnDefinitionSchema),
+    primaryKeyChange: schemaPrimaryKeyChangeSchema.nullable(),
+});
+const schemaDiffSummarySchema = zod_1.z.object({
+    tablesCompared: zod_1.z.number().int(),
+    tablesToCreate: zod_1.z.number().int(),
+    tablesToDrop: zod_1.z.number().int(),
+    columnsToAdd: zod_1.z.number().int(),
+    columnsToAlter: zod_1.z.number().int(),
+    columnsToDrop: zod_1.z.number().int(),
+    primaryKeysToChange: zod_1.z.number().int(),
+});
+exports.schemaDiffJsonSchema = zod_1.z.object({
+    format: zod_1.z.literal("postgres-schema-diff-json/v1"),
+    generatedAt: zod_1.z.string(),
+    source: zod_1.z.object({ schema: zod_1.z.string() }),
+    dest: zod_1.z.object({ schema: zod_1.z.string() }),
+    options: zod_1.z.object({
+        tables: zod_1.z.array(zod_1.z.string()),
+        excludedTables: zod_1.z.array(zod_1.z.string()),
+    }),
+    tables: zod_1.z.array(schemaTableDiffSchema),
+    summary: schemaDiffSummarySchema,
+});
+function validateSchemaDiffJson(data) {
+    const result = exports.schemaDiffJsonSchema.safeParse(data);
+    if (!result.success) {
+        throw new Error("Invalid schema diff JSON format:\n" +
+            JSON.stringify(result.error.format(), null, 2));
+    }
+    return result.data;
+}
+//# sourceMappingURL=schema-diff-schema.js.map

package/dist/shared/env-values.d.ts

@@ -0,0 +1,11 @@
+export declare function isEnvReference(value: string): boolean;
+export declare function extractEnvVarName(value: string): string | null;
+export declare function formatEnvReferenceHelp(): string;
+export declare function resolveListValues(values: string[], label: string, env?: NodeJS.ProcessEnv): string[];
+export declare function resolveStringValue(value: string, label: string, env?: NodeJS.ProcessEnv): string;
+export declare function resolveBooleanValue(value: boolean | string, label: string, env?: NodeJS.ProcessEnv): boolean;
+export declare function resolveEnumValue<T extends string>(value: T | string, label: string, allowedValues: readonly T[], env?: NodeJS.ProcessEnv): T;
+export declare function resolvePortValue(value: number | string, label: string, env?: NodeJS.ProcessEnv): number;
+export declare function formatSecretValue(value: string): string;
+export declare function formatVisibleValue(rawValue: string, resolvedValue: string): string;
+//# sourceMappingURL=env-values.d.ts.map

package/dist/shared/env-values.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEnvReference = isEnvReference;
+exports.extractEnvVarName = extractEnvVarName;
+exports.formatEnvReferenceHelp = formatEnvReferenceHelp;
+exports.resolveListValues = resolveListValues;
+exports.resolveStringValue = resolveStringValue;
+exports.resolveBooleanValue = resolveBooleanValue;
+exports.resolveEnumValue = resolveEnumValue;
+exports.resolvePortValue = resolvePortValue;
+exports.formatSecretValue = formatSecretValue;
+exports.formatVisibleValue = formatVisibleValue;
+const ENV_REFERENCE_PATTERN = /^\$([A-Za-z_][A-Za-z0-9_]*)$/;
+function isEnvReference(value) {
+    return ENV_REFERENCE_PATTERN.test(value);
+}
+function extractEnvVarName(value) {
+    const match = value.match(ENV_REFERENCE_PATTERN);
+    return match ? match[1] : null;
+}
+function formatEnvReferenceHelp() {
+    return "$ENV_VAR";
+}
+function resolveListValues(values, label, env = process.env) {
+    const resolved = [];
+    for (const value of values) {
+        const envVarName = extractEnvVarName(value);
+        if (!envVarName) {
+            const trimmed = value.trim();
+            if (trimmed) {
+                resolved.push(trimmed);
+            }
+            continue;
+        }
+        const envValue = env[envVarName];
+        if (envValue === undefined || envValue === "") {
+            console.error(`Missing required environment variable for ${label}: ${envVarName}`);
+            process.exit(1);
+        }
+        resolved.push(...envValue
+            .split(",")
+            .map((item) => item.trim())
+            .filter(Boolean));
+    }
+    return resolved;
+}
+function resolveStringValue(value, label, env = process.env) {
+    const envVarName = extractEnvVarName(value);
+    if (!envVarName) {
+        return value;
+    }
+    const resolved = env[envVarName];
+    if (resolved === undefined || resolved === "") {
+        console.error(`Missing required environment variable for ${label}: ${envVarName}`);
+        process.exit(1);
+    }
+    return resolved;
+}
+function resolveBooleanValue(value, label, env = process.env) {
+    if (typeof value === "boolean") {
+        return value;
+    }
+    const resolved = resolveStringValue(value, label, env).trim().toLowerCase();
+    if (["y", "yes", "true", "1", "on"].includes(resolved)) {
+        return true;
+    }
+    if (["n", "no", "false", "0", "off"].includes(resolved)) {
+        return false;
+    }
+    console.error(`${label} must resolve to yes or no.`);
+    process.exit(1);
+}
+function resolveEnumValue(value, label, allowedValues, env = process.env) {
+    const resolved = resolveStringValue(value, label, env);
+    if (allowedValues.includes(resolved)) {
+        return resolved;
+    }
+    console.error(`${label} must resolve to one of: ${allowedValues.join(", ")}.`);
+    process.exit(1);
+}
+function resolvePortValue(value, label, env = process.env) {
+    const rawValue = typeof value === "number"
+        ? String(value)
+        : resolveStringValue(value, label, env);
+    const port = Number(rawValue);
+    if (Number.isInteger(port) && port >= 1 && port <= 65535) {
+        return port;
+    }
+    console.error(`${label} must resolve to an integer from 1 to 65535.`);
+    process.exit(1);
+}
+function formatSecretValue(value) {
+    return isEnvReference(value) ? value : "[literal value hidden]";
+}
+function formatVisibleValue(rawValue, resolvedValue) {
+    return isEnvReference(rawValue)
+        ? `${rawValue} -> ${resolvedValue}`
+        : rawValue;
+}
+//# sourceMappingURL=env-values.js.map

package/dist/shared/generator-wizard.d.ts

@@ -0,0 +1,10 @@
+import type { GeneratorOptionInput, ResolvedGeneratorOptions } from "../config/resolve-options";
+type PromptFn = (message: string) => Promise<string>;
+interface WizardDependencies {
+    env?: NodeJS.ProcessEnv;
+    envrcPath?: string;
+    onEnvrcWrite?: () => void;
+}
+export declare function promptForGeneratorOptions(defaults: ResolvedGeneratorOptions, promptFn?: PromptFn, dependencies?: WizardDependencies): Promise<GeneratorOptionInput>;
+export {};
+//# sourceMappingURL=generator-wizard.d.ts.map

package/dist/shared/generator-wizard.js

@@ -0,0 +1,337 @@
+"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.promptForGeneratorOptions = promptForGeneratorOptions;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const prompts_1 = require("./prompts");
+const env_values_1 = require("./env-values");
+const DEFAULT_ENVRC_PATH = ".envrc";
+async function promptForGeneratorOptions(defaults, promptFn, dependencies = {}) {
+    console.log("No parameters provided. Starting generator setup wizard.");
+    console.log(`Connection values can be entered as plain text or ${(0, env_values_1.formatEnvReferenceHelp)()}.`);
+    console.log(`Use ${(0, env_values_1.formatEnvReferenceHelp)()} to keep values out of the config file.`);
+    console.log(`Passwords can also be plain text, but ${(0, env_values_1.formatEnvReferenceHelp)()} is recommended.\n`);
+    const promptSession = promptFn ? undefined : createPromptSession();
+    const ask = promptFn ?? promptSession.prompt;
+    const env = dependencies.env ?? process.env;
+    const envrcPath = dependencies.envrcPath ?? DEFAULT_ENVRC_PATH;
+    const onEnvrcWrite = dependencies.onEnvrcWrite;
+    try {
+        const sourcePgHost = await promptConfigString("Source host", defaults.sourcePgHost, ask, env, envrcPath, {}, onEnvrcWrite);
+        const sourcePgPort = await promptPort("Source port", defaults.sourcePgPort, ask, env, envrcPath);
+        const sourcePgUser = await promptConfigString("Source user", defaults.sourcePgUser, ask, env, envrcPath, {}, onEnvrcWrite);
+        const sourcePgPassword = await promptConfigString("Source password ($ENV_VAR or plain text)", defaults.sourcePgPassword, ask, env, envrcPath, { secretDefault: true }, onEnvrcWrite);
+        const sourcePgSsl = await promptBoolean("Use SSL for source database", defaults.sourcePgSsl, ask, env, envrcPath, onEnvrcWrite);
+        const sourcePgDatabase = await promptConfigString("Source database", defaults.sourcePgDatabase, ask, env, envrcPath, {}, onEnvrcWrite);
+        console.log("");
+        const destPgHost = await promptConfigString("Destination host", defaults.destPgHost, ask, env, envrcPath, {}, onEnvrcWrite);
+        const destPgPort = await promptPort("Destination port", defaults.destPgPort, ask, env, envrcPath);
+        const destPgUser = await promptConfigString("Destination user", defaults.destPgUser, ask, env, envrcPath, {}, onEnvrcWrite);
+        const destPgPassword = await promptConfigString("Destination password ($ENV_VAR or plain text)", defaults.destPgPassword, ask, env, envrcPath, { secretDefault: true }, onEnvrcWrite);
+        const destPgSsl = await promptBoolean("Use SSL for destination database", defaults.destPgSsl, ask, env, envrcPath, onEnvrcWrite);
+        const destPgDatabase = await promptConfigString("Destination database", defaults.destPgDatabase, ask, env, envrcPath, {}, onEnvrcWrite);
+        console.log("");
+        const schema = await promptConfigString("Schema", defaults.schema, ask, env, envrcPath, {}, onEnvrcWrite);
+        const tables = await promptList('Tables to compare (comma-separated, "*" supported)', defaults.tables, ask, env, envrcPath, onEnvrcWrite);
+        const excludeTables = await promptOptionalList('Tables to exclude (comma-separated, "*" supported)', defaults.excludeTables, ask, env, envrcPath, onEnvrcWrite);
+        const ignoreColumns = await promptOptionalList("Columns to ignore (comma-separated)", defaults.ignoreColumns, ask, env, envrcPath, onEnvrcWrite);
+        const includeDeletes = await promptBoolean("Include deletes", defaults.includeDeletes, ask, env, envrcPath, onEnvrcWrite);
+        const skipMissingPk = await promptBoolean("Skip tables without primary keys", defaults.skipMissingPk, ask, env, envrcPath, onEnvrcWrite);
+        const output = await promptConfigString("Output file", defaults.output, ask, env, envrcPath, {}, onEnvrcWrite);
+        const generateSql = await promptBoolean("Generate SQL script after diff", defaults.generateSql ?? true, ask, env, envrcPath, onEnvrcWrite);
+        console.log("");
+        const schemaDiffTables = await promptList('Schema diff tables to compare (comma-separated, "*" supported)', defaults.schemaDiffTables, ask, env, envrcPath, onEnvrcWrite);
+        const schemaDiffExcludeTables = await promptOptionalList('Schema diff tables to exclude (comma-separated, "*" supported)', defaults.schemaDiffExcludeTables, ask, env, envrcPath, onEnvrcWrite);
+        const schemaDiffOutput = await promptConfigString("Schema diff output file", defaults.schemaDiffOutput, ask, env, envrcPath, {}, onEnvrcWrite);
+        console.log("");
+        const pgTriggersTables = await promptList('PostgreSQL triggers tables to compare (comma-separated, "*" supported)', defaults.pgTriggersTables, ask, env, envrcPath, onEnvrcWrite);
+        const pgTriggersExcludeTables = await promptOptionalList('PostgreSQL triggers tables to exclude (comma-separated, "*" supported)', defaults.pgTriggersExcludeTables, ask, env, envrcPath, onEnvrcWrite);
+        const pgTriggersOutput = await promptConfigString("PostgreSQL triggers output file", defaults.pgTriggersOutput, ask, env, envrcPath, {}, onEnvrcWrite);
+        const generatePgTriggers = await promptBoolean("Generate a PostgreSQL triggers and functions diff? (SQL script)", defaults.generatePgTriggers ?? true, ask, env, envrcPath, onEnvrcWrite);
+        console.log("");
+        const pretty = await promptBoolean("Pretty-print JSON", defaults.pretty, ask, env, envrcPath, onEnvrcWrite);
+        return {
+            sourcePgHost,
+            sourcePgPort,
+            sourcePgUser,
+            sourcePgPassword,
+            sourcePgSsl,
+            sourcePgDatabase,
+            destPgHost,
+            destPgPort,
+            destPgUser,
+            destPgPassword,
+            destPgSsl,
+            destPgDatabase,
+            schema,
+            tables,
+            excludeTables,
+            schemaDiffTables,
+            schemaDiffExcludeTables,
+            pgTriggersTables,
+            pgTriggersExcludeTables,
+            ignoreColumns,
+            includeDeletes,
+            skipMissingPk,
+            output,
+            schemaDiffOutput,
+            pgTriggersOutput,
+            pretty,
+            generateSql,
+            generatePgTriggers,
+        };
+    }
+    finally {
+        promptSession?.close();
+    }
+}
+async function promptRequired(label, defaultValue, promptFn) {
+    while (true) {
+        const answer = await promptFn(formatPrompt(label, defaultValue));
+        const value = answer || defaultValue;
+        if (value)
+            return value;
+        console.log(`${label} is required.`);
+    }
+}
+async function promptPort(label, defaultValue, promptFn, env, envrcPath) {
+    while (true) {
+        const displayedDefault = formatDefault(defaultValue);
+        const answer = await promptFn(formatPrompt(label, displayedDefault));
+        const value = (answer || displayedDefault).trim();
+        if ((0, env_values_1.isEnvReference)(value)) {
+            await ensureEnvReferenceValue(value, promptFn, env, envrcPath);
+            const resolvedPort = Number(env[(0, env_values_1.extractEnvVarName)(value)]);
+            if (Number.isInteger(resolvedPort) &&
+                resolvedPort >= 1 &&
+                resolvedPort <= 65535) {
+                return value;
+            }
+            console.log(`${label} must resolve to an integer from 1 to 65535.`);
+            continue;
+        }
+        const port = Number(value);
+        if (Number.isInteger(port) && port >= 1 && port <= 65535)
+            return port;
+        console.log(`${label} must be an integer from 1 to 65535.`);
+    }
+}
+async function promptConfigString(label, defaultValue, promptFn, env, envrcPath, options = {}, onEnvrcWrite) {
+    while (true) {
+        const displayedDefault = formatDefault(defaultValue, env, options);
+        const answer = await promptFn(formatPrompt(label, displayedDefault));
+        const value = answer || defaultValue;
+        if (!value) {
+            console.log(`${label} is required.`);
+            continue;
+        }
+        if (value.startsWith("$") && !(0, env_values_1.isEnvReference)(value)) {
+            console.log(`${label} must use ${(0, env_values_1.formatEnvReferenceHelp)()} when referencing an environment variable.`);
+            continue;
+        }
+        if ((0, env_values_1.isEnvReference)(value)) {
+            await ensureEnvReferenceValue(value, promptFn, env, envrcPath, onEnvrcWrite);
+        }
+        return value;
+    }
+}
+async function promptList(label, defaultValue, promptFn, env, envrcPath, onEnvrcWrite) {
+    while (true) {
+        const answer = await promptFn(formatPrompt(label, defaultValue.join(", ")));
+        const values = parseList(answer || defaultValue.join(","));
+        const listRefsValid = await ensureEnvReferencesForList(values, promptFn, env, envrcPath, label, onEnvrcWrite);
+        if (!listRefsValid) {
+            continue;
+        }
+        const resolved = (0, env_values_1.resolveListValues)(values, label, env);
+        if (resolved.length > 0)
+            return values;
+        console.log(`${label} requires at least one value.`);
+    }
+}
+async function promptOptionalList(label, defaultValue, promptFn, env, envrcPath, onEnvrcWrite) {
+    while (true) {
+        const promptLabel = defaultValue.length > 0 ? `${label} (type none to clear)` : label;
+        const answer = await promptFn(formatPrompt(promptLabel, defaultValue.join(", ")));
+        if (answer.trim().toLowerCase() === "none") {
+            return [];
+        }
+        const values = !answer && defaultValue.length > 0 ? defaultValue : parseList(answer);
+        const listRefsValid = await ensureEnvReferencesForList(values, promptFn, env, envrcPath, label, onEnvrcWrite);
+        if (!listRefsValid) {
+            continue;
+        }
+        (0, env_values_1.resolveListValues)(values, label, env);
+        return values;
+    }
+}
+async function promptBoolean(label, defaultValue, promptFn, env, envrcPath, onEnvrcWrite) {
+    let defaultText;
+    if (typeof defaultValue === "string") {
+        defaultText = defaultValue;
+    }
+    else {
+        defaultText = defaultValue ? "yes" : "no";
+    }
+    while (true) {
+        const answer = await promptFn(formatPrompt(`${label} (yes/no)`, defaultText));
+        const value = answer || defaultText;
+        if (value.startsWith("$") && !(0, env_values_1.isEnvReference)(value)) {
+            console.log(`${label} must use ${(0, env_values_1.formatEnvReferenceHelp)()} when referencing an environment variable.`);
+            continue;
+        }
+        if ((0, env_values_1.isEnvReference)(value)) {
+            await ensureEnvReferenceValue(value, promptFn, env, envrcPath, onEnvrcWrite);
+            assertValidBooleanReference(value, label, env);
+            return value;
+        }
+        const normalizedValue = value.toLowerCase();
+        if (["y", "yes", "true"].includes(normalizedValue))
+            return true;
+        if (["n", "no", "false"].includes(normalizedValue))
+            return false;
+        console.log(`${label} must be yes or no.`);
+    }
+}
+function formatPrompt(label, defaultValue) {
+    return defaultValue ? `${label} [${defaultValue}]: ` : `${label}: `;
+}
+function formatDefault(value, env = process.env, options = {}) {
+    if (typeof value === "number") {
+        return String(value);
+    }
+    if (!value) {
+        return "";
+    }
+    if (options.secretDefault && (0, env_values_1.isEnvReference)(value)) {
+        const envVarName = (0, env_values_1.extractEnvVarName)(value);
+        if (envVarName && env[envVarName] !== undefined && env[envVarName] !== "") {
+            return `${value} loaded`;
+        }
+        return `${value} not set`;
+    }
+    if (options.secretDefault && !(0, env_values_1.isEnvReference)(value)) {
+        return "existing literal hidden";
+    }
+    return value;
+}
+function parseList(value) {
+    return value
+        .split(",")
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function writeEnvrcValue(envrcPath, envVarName, value) {
+    const resolvedPath = path.resolve(envrcPath);
+    const line = `export ${envVarName}=${shellQuote(value)}`;
+    const existing = fs.existsSync(resolvedPath)
+        ? fs.readFileSync(resolvedPath, "utf-8")
+        : "";
+    const lines = existing ? existing.replace(/\n$/, "").split("\n") : [];
+    const assignmentPattern = new RegExp(`^(?:export\\s+)?${envVarName}=`);
+    const index = lines.findIndex((existingLine) => assignmentPattern.test(existingLine.trim()));
+    if (index >= 0) {
+        lines[index] = line;
+    }
+    else {
+        lines.push(line);
+    }
+    fs.writeFileSync(resolvedPath, `${lines.join("\n")}\n`, {
+        encoding: "utf-8",
+        mode: 0o600,
+    });
+}
+async function ensureEnvReferenceValue(envReference, promptFn, env, envrcPath, onEnvrcWrite) {
+    const envVarName = (0, env_values_1.extractEnvVarName)(envReference);
+    if (!envVarName) {
+        return;
+    }
+    if (env[envVarName] !== undefined && env[envVarName] !== "") {
+        return;
+    }
+    while (true) {
+        const value = await promptFn(`${envVarName} is not set. Enter value to store in ${envrcPath}: `);
+        if (!value) {
+            console.log("Value is required.");
+            continue;
+        }
+        env[envVarName] = value;
+        writeEnvrcValue(envrcPath, envVarName, value);
+        onEnvrcWrite?.();
+        console.log(`${envVarName} written to ${path.resolve(envrcPath)} and loaded for this run.`);
+        return;
+    }
+}
+async function ensureEnvReferencesForList(values, promptFn, env, envrcPath, label, onEnvrcWrite) {
+    for (const value of values) {
+        if (value.startsWith("$") && !(0, env_values_1.isEnvReference)(value)) {
+            console.log(`${label} must use ${(0, env_values_1.formatEnvReferenceHelp)()} when referencing an environment variable.`);
+            return false;
+        }
+        if ((0, env_values_1.isEnvReference)(value)) {
+            await ensureEnvReferenceValue(value, promptFn, env, envrcPath, onEnvrcWrite);
+        }
+    }
+    return true;
+}
+function assertValidBooleanReference(envReference, label, env) {
+    (0, env_values_1.resolveBooleanValue)(envReference, label, env);
+}
+function shellQuote(value) {
+    return `'${value.replace(/'/g, `'\\''`)}'`;
+}
+function createPromptSession() {
+    if (!process.stdin.isTTY) {
+        return {
+            prompt: prompts_1.prompt,
+            close: () => undefined,
+        };
+    }
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return {
+        prompt: (message) => new Promise((resolve) => {
+            rl.question(message, (answer) => {
+                resolve(answer.trim());
+            });
+        }),
+        close: () => rl.close(),
+    };
+}
+//# sourceMappingURL=generator-wizard.js.map

package/dist/shared/identifiers.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Safe identifier quoting for PostgreSQL.
+ * All table names, column names, and schema names MUST be quoted through these helpers.
+ */
+/**
+ * Quotes a PostgreSQL identifier (table name, column name, schema name).
+ * Doubles any embedded double-quote characters.
+ */
+export declare function quoteIdentifier(name: string): string;
+/**
+ * Quotes a schema-qualified table name.
+ */
+export declare function quoteQualifiedTable(schema: string, table: string): string;
+/**
+ * Validates that an identifier contains only safe characters.
+ * This is a defense-in-depth check — identifiers are always quoted,
+ * but this catches obvious injection attempts early.
+ */
+export declare function validateIdentifier(name: string, context: string): void;
+/**
+ * Validates an array of identifiers (e.g., column names).
+ */
+export declare function validateIdentifiers(names: string[], context: string): void;
+//# sourceMappingURL=identifiers.d.ts.map

package/dist/shared/identifiers.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Safe identifier quoting for PostgreSQL.
+ * All table names, column names, and schema names MUST be quoted through these helpers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quoteIdentifier = quoteIdentifier;
+exports.quoteQualifiedTable = quoteQualifiedTable;
+exports.validateIdentifier = validateIdentifier;
+exports.validateIdentifiers = validateIdentifiers;
+/**
+ * Quotes a PostgreSQL identifier (table name, column name, schema name).
+ * Doubles any embedded double-quote characters.
+ */
+function quoteIdentifier(name) {
+    return '"' + name.replace(/"/g, '""') + '"';
+}
+/**
+ * Quotes a schema-qualified table name.
+ */
+function quoteQualifiedTable(schema, table) {
+    return `${quoteIdentifier(schema)}.${quoteIdentifier(table)}`;
+}
+/**
+ * Validates that an identifier contains only safe characters.
+ * This is a defense-in-depth check — identifiers are always quoted,
+ * but this catches obvious injection attempts early.
+ */
+function validateIdentifier(name, context) {
+    if (typeof name !== "string" || name.length === 0) {
+        throw new Error(`Invalid identifier (${context}): must be a non-empty string`);
+    }
+    if (name.length > 63) {
+        throw new Error(`Invalid identifier (${context}): "${name}" exceeds PostgreSQL max identifier length of 63`);
+    }
+}
+/**
+ * Validates an array of identifiers (e.g., column names).
+ */
+function validateIdentifiers(names, context) {
+    for (const name of names) {
+        validateIdentifier(name, context);
+    }
+}
+//# sourceMappingURL=identifiers.js.map

package/dist/shared/prompts.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Prompts the user with the given message and waits for input.
+ * Returns the trimmed input string.
+ */
+export declare function prompt(message: string): Promise<string>;
+/**
+ * Asks the user to type "yes" to proceed.
+ * Returns true if the user typed exactly "yes", false otherwise.
+ */
+export declare function confirmProceed(message?: string, defaultYes?: boolean): Promise<boolean>;
+/**
+ * Asks the user whether to create a config file.
+ * Returns true if the user typed exactly "yes".
+ */
+export declare function confirmCreateConfig(): Promise<boolean>;
+/**
+ * Asks the user whether to update an existing config file with the current options.
+ * Returns true if the user typed exactly "yes".
+ */
+export declare function confirmUpdateConfig(): Promise<boolean>;
+/**
+ * Asks the user whether to run `direnv allow` in the current directory.
+ * Returns true if the user typed exactly "yes".
+ */
+export declare function confirmDirenvAllow(): Promise<boolean>;
+//# sourceMappingURL=prompts.d.ts.map