pgpm 5.19.1 → 5.21.0

package/commands/import.js

@@ -0,0 +1,235 @@
+"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 import_1 = require("@pgpmjs/import");
+const logger_1 = require("@pgpmjs/logger");
+const transform_1 = require("@pgpmjs/transform");
+const inquirerer_1 = require("inquirerer");
+const path = __importStar(require("path"));
+const emit_package_1 = require("../utils/emit-package");
+const module_projections_1 = require("../utils/module-projections");
+const log = new logger_1.Logger('import');
+const importUsageText = `
+Import Command:
+
+  pgpm import <dump.sql | dir-of-sql-files> --pkg <module-name> [OPTIONS]
+
+  pgpm-itize an arbitrary SQL dump (e.g. pg_dump --schema-only output): parse
+  it, classify every statement, and emit a complete deployable pgpm module —
+  module dir, pgpm.plan, and deploy/revert/verify trees with spec-derived
+  change paths, graph-derived requires, and generated revert/verify scripts.
+
+  Directory inputs concatenate their .sql files in sorted (lexicographic)
+  filename order.
+
+  Dump handling:
+  - pg_dump preamble noise (SET ..., SELECT set_config(...), psql backslash
+    commands) is skipped; COMMENT ON and GRANT statements are kept, attached
+    to their host object's change.
+  - CREATE EXTENSION statements become .control requires (pgpm owns
+    extension creation at deploy time).
+  - COPY ... FROM stdin blocks and INSERTs are skipped with a warning unless
+    --with-data is passed, which emits them as seed fixture changes (COPY
+    data is converted to INSERTs).
+  - Statements that classify to no object land in a misc/statements change
+    with a warning — never dropped silently.
+
+Options:
+  --help, -h              Show this help message
+  --pkg <name>            Module name for the generated package (required)
+  --granularity <level>   Granularity dial: atomic | object | consolidated
+                          (default: object)
+  --change-granularity <level>
+                          Change-level distribution: alteration | object | single
+                          (default: object)
+  --naming <style>        Change path naming style: directory | flat (default: directory)
+  --out <dir>             Output base directory (default: current directory);
+                          the module is written to <out>/<pkg>
+  --with-data             Import COPY/INSERT data as seed fixture changes
+  --partition <file>      Partition config (JSON: rules/defaultPackage/splitRiders)
+                          splitting the import into multiple pgpm packages with
+                          derived cross-package requires
+  --write                 Allow overwriting an existing module directory
+  --emit-sql <file|->      Also project the imported module into a single linear
+                          SQL script (- for stdout). Requires a single output
+                          package (not supported with --partition).
+  --emit-bundle <file>     Also project the imported module into a
+                          content-addressed .bundle.tar.gz. Same single-package
+                          requirement as --emit-sql.
+  --cwd <directory>       Working directory (default: current directory)
+  --dry-run               Print the resulting plan/paths without writing
+
+The imported module is the canonical artifact; --emit-sql and --emit-bundle are
+pure projections of it (the same machinery pgpm package and pgpm diff use).
+
+Examples:
+  pgpm import dump.sql --pkg my-app
+  pgpm import dump.sql --pkg my-app --granularity consolidated --naming flat
+  pgpm import ./sql-files --pkg my-app --out ./packages --with-data
+  pgpm import dump.sql --pkg my-app --partition partition.json
+  pgpm import dump.sql --pkg my-app --emit-sql my-app.sql
+`;
+const NAMING_STYLES = ['directory', 'flat'];
+exports.default = async (argv, prompter, _options) => {
+    if (argv.help || argv.h) {
+        console.log(importUsageText);
+        process.exit(0);
+    }
+    const cwd = argv.cwd || process.cwd();
+    const input = argv._?.filter(Boolean)[0];
+    if (!input) {
+        await (0, inquirerer_1.cliExitWithError)('Missing input: pgpm import <dump.sql | dir-of-sql-files> --pkg <name>');
+    }
+    const pkgName = argv.pkg;
+    if (!pkgName || typeof pkgName !== 'string') {
+        await (0, inquirerer_1.cliExitWithError)('--pkg <module-name> is required.');
+    }
+    const granularityRaw = argv.granularity ?? 'object';
+    if (!(0, transform_1.isExportGranularity)(granularityRaw)) {
+        await (0, inquirerer_1.cliExitWithError)(`Invalid --granularity "${granularityRaw}". Expected one of: ${transform_1.EXPORT_GRANULARITIES.join(', ')}.`);
+    }
+    const granularity = granularityRaw;
+    const changeGranularityRaw = argv['change-granularity'] ?? argv.changeGranularity ?? 'object';
+    if (!(0, transform_1.isChangeGranularity)(changeGranularityRaw)) {
+        await (0, inquirerer_1.cliExitWithError)(`Invalid --change-granularity "${changeGranularityRaw}". Expected one of: ${transform_1.CHANGE_GRANULARITIES.join(', ')}.`);
+    }
+    const changeGranularity = changeGranularityRaw;
+    const namingRaw = argv.naming ?? 'directory';
+    if (!NAMING_STYLES.includes(namingRaw)) {
+        await (0, inquirerer_1.cliExitWithError)(`Invalid --naming "${namingRaw}". Expected one of: ${NAMING_STYLES.join(', ')}.`);
+    }
+    const naming = namingRaw;
+    let partition;
+    if (typeof argv.partition === 'string' && argv.partition) {
+        try {
+            partition = (0, transform_1.parsePartitionConfig)(path.resolve(cwd, argv.partition));
+        }
+        catch (err) {
+            await (0, inquirerer_1.cliExitWithError)(err instanceof Error ? err.message : String(err));
+        }
+    }
+    const outBase = typeof argv.out === 'string' && argv.out ? path.resolve(cwd, argv.out) : path.resolve(cwd);
+    const withData = Boolean(argv['with-data'] ?? argv.withData);
+    const write = Boolean(argv.write);
+    const dryRun = Boolean(argv['dry-run'] ?? argv.dryRun);
+    const emit = (0, module_projections_1.parseEmitProjectionTargets)(argv, cwd);
+    const emitRequested = (0, module_projections_1.hasEmitProjection)(emit);
+    const sqlToStdout = emit.emitSql === module_projections_1.STDOUT_TARGET;
+    if (emitRequested && dryRun) {
+        await (0, inquirerer_1.cliExitWithError)('--emit-sql/--emit-bundle cannot be combined with --dry-run.');
+    }
+    let source;
+    try {
+        source = (0, import_1.loadDumpSource)(path.resolve(cwd, input));
+    }
+    catch (err) {
+        await (0, inquirerer_1.cliExitWithError)(err instanceof Error ? err.message : String(err));
+        return;
+    }
+    if (source.files.length > 1 && !sqlToStdout) {
+        log.info(`concatenated ${source.files.length} .sql files in sorted order`);
+    }
+    for (const warning of (0, import_1.dumpCompatibilityWarnings)(source)) {
+        console.warn(`\nWARNING: ${warning}\n`);
+    }
+    const result = await (0, import_1.importDumpRows)(source, { granularity, changeGranularity, naming, withData });
+    let packages;
+    if (partition) {
+        try {
+            const partitioned = await (0, transform_1.partitionExportRows)(result.rows, partition);
+            result.warnings.push(...partitioned.warnings.map(w => `partition: ${w}`));
+            packages = partitioned.packages.map(pkg => ({
+                name: pkg.name,
+                requires: [...result.controlRequires, ...pkg.requires],
+                rows: (0, import_1.linkTextualDeps)(pkg.rows)
+            }));
+        }
+        catch (err) {
+            if (err instanceof transform_1.PartitionCycleError) {
+                await (0, inquirerer_1.cliExitWithError)(`Partition failed: ${err.message}`);
+                return;
+            }
+            throw err;
+        }
+    }
+    else {
+        packages = [{ name: pkgName, requires: result.controlRequires, rows: result.rows }];
+    }
+    for (const warning of result.warnings) {
+        console.warn(`import: ${warning}`);
+    }
+    if (dryRun) {
+        for (const pkg of packages) {
+            console.log(`package ${pkg.name} -> ${path.join(outBase, pkg.name)}`);
+            if (pkg.requires.length) {
+                console.log(`  requires: ${pkg.requires.join(', ')}`);
+            }
+            for (const row of pkg.rows) {
+                const deps = row.deps?.length ? ` [${row.deps.join(' ')}]` : '';
+                console.log(`  ${row.deploy}${deps}`);
+            }
+        }
+    }
+    else {
+        if (emitRequested && packages.length !== 1) {
+            await (0, inquirerer_1.cliExitWithError)('--emit-sql/--emit-bundle require a single output package; a --partition import emits multiple packages.');
+        }
+        for (const pkg of packages) {
+            const guard = (0, emit_package_1.checkOverwrite)(path.join(outBase, pkg.name), source.files[0], write);
+            if (guard) {
+                await (0, inquirerer_1.cliExitWithError)(guard);
+            }
+        }
+        let firstDir;
+        for (const pkg of packages) {
+            const dir = (0, emit_package_1.writePackage)(outBase, pkg);
+            firstDir ??= dir;
+            if (!sqlToStdout) {
+                log.success(`wrote ${pkg.rows.length} changes to ${dir}`);
+            }
+        }
+        if (emitRequested && firstDir) {
+            await (0, module_projections_1.projectModule)(firstDir, emit, sqlToStdout ? undefined : msg => log.success(msg));
+        }
+    }
+    const { summary } = result;
+    if (!sqlToStdout) {
+        log.success(`import: ${summary.statements} statement(s) -> ${summary.changes} change(s), ` +
+            `${summary.skippedPreamble} preamble skipped, ${summary.skippedData} data skipped, ` +
+            `${summary.misc} in misc, ${result.warnings.length} warning(s)`);
+    }
+    prompter.close();
+    return argv;
+};

package/commands/init/boilerplate.js

@@ -6,9 +6,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveInitTemplateRepo = resolveInitTemplateRepo;
 exports.persistBoilerplateSource = persistBoilerplateSource;
 exports.readBoilerplateSource = readBoilerplateSource;
+const core_1 = require("@pgpmjs/core");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const core_1 = require("@pgpmjs/core");
 /**
  * Resolve the template repo for an `init` invocation from its flags.
  *

package/commands/init/index.js

@@ -4,13 +4,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createInitUsageText = void 0;
-const child_process_1 = require("child_process");
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
 const core_1 = require("@pgpmjs/core");
 const env_1 = require("@pgpmjs/env");
 const types_1 = require("@pgpmjs/types");
+const child_process_1 = require("child_process");
+const fs_1 = __importDefault(require("fs"));
 const inquirerer_1 = require("inquirerer");
+const path_1 = __importDefault(require("path"));
 const utils_1 = require("../../utils");
 const boilerplate_1 = require("./boilerplate");
 const DEFAULT_MOTD = `

package/commands/package.js

@@ -118,7 +118,6 @@ exports.default = async (argv, prompter, _options) => {
     const project = new core_1.PgpmPackage(cwd);
     project.ensureModule();
     const info = project.getModuleInfo();
-    info.version;
     await (0, core_1.writePackage)({
         version: info.version,
         extension: true,

package/commands/slice.js

@@ -3,8 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("@pgpmjs/core");
 const slice_1 = require("@pgpmjs/slice");
 const types_1 = require("@pgpmjs/types");
-const path_1 = require("path");
 const fs_1 = require("fs");
+const path_1 = require("path");
 const sliceUsageText = `
 Slice Command:
 

package/commands/test-packages.js

@@ -7,8 +7,8 @@ const core_1 = require("@pgpmjs/core");
 const env_1 = require("@pgpmjs/env");
 const logger_1 = require("@pgpmjs/logger");
 const path_1 = __importDefault(require("path"));
-const pg_env_1 = require("pg-env");
 const pg_cache_1 = require("pg-cache");
+const pg_env_1 = require("pg-env");
 const log = new logger_1.Logger('test-packages');
 // ANSI color codes
 const RED = '\x1b[0;31m';

package/commands/transform.d.ts

@@ -0,0 +1,13 @@
+import { PartitionedPackageRows } from '@pgpmjs/transform';
+import { CLIOptions, Inquirerer, ParsedArgs } from 'inquirerer';
+export { checkOverwrite } from '../utils/emit-package';
+/**
+ * Resolve the base directory package dir(s) are created in. Without --out,
+ * packages are written as siblings of the source module — a plain transform
+ * of `my-mod` at granularity `object` lands in `../my-mod-object`.
+ */
+export declare const resolveOutBase: (modulePath: string, out?: string) => string;
+/** Order partition packages so prerequisites come before dependents. */
+export declare const orderPackages: (packages: PartitionedPackageRows[]) => PartitionedPackageRows[];
+declare const _default: (argv: Partial<ParsedArgs>, prompter: Inquirerer, _options: CLIOptions) => Promise<Partial<ParsedArgs>>;
+export default _default;

package/commands/transform.js

@@ -0,0 +1,317 @@
+"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.orderPackages = exports.resolveOutBase = exports.checkOverwrite = void 0;
+const core_1 = require("@pgpmjs/core");
+const logger_1 = require("@pgpmjs/logger");
+const transform_1 = require("@pgpmjs/transform");
+const fs = __importStar(require("fs"));
+const inquirerer_1 = require("inquirerer");
+const path = __importStar(require("path"));
+const pg_env_1 = require("pg-env");
+const emit_package_1 = require("../utils/emit-package");
+const module_projections_1 = require("../utils/module-projections");
+const scratch_db_1 = require("../utils/scratch-db");
+var emit_package_2 = require("../utils/emit-package");
+Object.defineProperty(exports, "checkOverwrite", { enumerable: true, get: function () { return emit_package_2.checkOverwrite; } });
+const log = new logger_1.Logger('transform');
+const transformUsageText = `
+Transform Command:
+
+  pgpm transform --granularity <atomic|object|consolidated> [OPTIONS]
+
+  Re-dial an existing pgpm module (or every module in a workspace) through the
+  dials pipeline: flatten the deploy scripts in plan order, re-project them at
+  the requested granularity with spec-derived change paths, graph-derived
+  requires, and generated revert/verify scripts.
+
+Options:
+  --help, -h              Show this help message
+  --granularity <level>   Target granularity: atomic | object | consolidated (required)
+  --change-granularity <level>
+                          Change-level distribution: alteration | object | single
+                          (default: object). With alteration, every ADD COLUMN /
+                          ADD CONSTRAINT becomes its own change with its own
+                          deploy/revert/verify and requires. With single, the
+                          whole module becomes one change.
+  --partition <file>      Partition config (JSON: rules/defaultPackage/splitRiders)
+                          splitting the module into multiple pgpm packages with
+                          derived cross-package requires.
+  --naming <style>        Change path naming style: directory | flat (default: directory)
+  --cwd <directory>       Module or workspace directory (default: current directory)
+  --out <dir>             Output directory (default: sibling <module>-<granularity>)
+  --write                 Allow writing over an existing/module directory
+  --emit-sql <file|->      Also project the transformed module into a single
+                          linear SQL script (- for stdout). Requires a single
+                          output package (no workspace/partition fan-out).
+  --emit-bundle <file>     Also project the transformed module into a
+                          content-addressed .bundle.tar.gz. Same single-package
+                          requirement as --emit-sql.
+  --check                 Deploy original and transformed output into scratch
+                          databases and assert the catalogs are equivalent
+  --dry-run               Print the resulting plan/paths without writing
+
+The transformed module is the canonical artifact; --emit-sql and --emit-bundle
+are pure projections of it (the same machinery pgpm package and pgpm diff use).
+
+Examples:
+  pgpm transform --granularity object
+  pgpm transform --granularity atomic --naming flat --out ./out
+  pgpm transform --granularity object --partition partition.json --check
+  pgpm transform --granularity consolidated --emit-sql migration.sql
+  pgpm transform --granularity atomic --change-granularity alteration
+`;
+const NAMING_STYLES = ['directory', 'flat'];
+/**
+ * Resolve the base directory package dir(s) are created in. Without --out,
+ * packages are written as siblings of the source module — a plain transform
+ * of `my-mod` at granularity `object` lands in `../my-mod-object`.
+ */
+const resolveOutBase = (modulePath, out) => {
+    if (out)
+        return path.resolve(out);
+    return path.dirname(modulePath);
+};
+exports.resolveOutBase = resolveOutBase;
+/** Order partition packages so prerequisites come before dependents. */
+const orderPackages = (packages) => {
+    const byName = new Map(packages.map(pkg => [pkg.name, pkg]));
+    const ordered = [];
+    const seen = new Set();
+    const visit = (pkg) => {
+        if (seen.has(pkg.name))
+            return;
+        seen.add(pkg.name);
+        for (const req of pkg.requires) {
+            const dep = byName.get(req);
+            if (dep)
+                visit(dep);
+        }
+        ordered.push(pkg);
+    };
+    for (const pkg of packages)
+        visit(pkg);
+    return ordered;
+};
+exports.orderPackages = orderPackages;
+const readControlRequires = (modulePath, name) => {
+    const controlPath = path.join(modulePath, `${name}.control`);
+    if (!fs.existsSync(controlPath))
+        return [];
+    const match = fs.readFileSync(controlPath, 'utf-8').match(/^requires\s*=\s*'([^']*)'\s*$/m);
+    if (!match)
+        return [];
+    return match[1].split(',').map(s => s.trim()).filter(Boolean);
+};
+const deployModules = async (config, modulePaths) => {
+    const client = new core_1.PgpmMigrate(config);
+    for (const modulePath of modulePaths) {
+        const result = await client.deploy({ modulePath });
+        if (result.failed) {
+            throw new Error(`deploy failed at change ${result.failed} (module ${modulePath})`);
+        }
+    }
+};
+/**
+ * Prove the transform is structurally lossless: deploy the original module and
+ * the transformed package(s) into two scratch databases and compare catalogs.
+ */
+const runCheck = async (transformed) => {
+    const config = (0, pg_env_1.getPgEnvOptions)();
+    const stamp = Date.now();
+    const names = [`pgpm_transform_check_a_${stamp}`, `pgpm_transform_check_b_${stamp}`];
+    return (0, scratch_db_1.withScratchDatabases)(config, names, async ([cfgOriginal, cfgTransformed]) => {
+        await deployModules(cfgOriginal, [transformed.modulePath]);
+        const orderedDirs = (0, exports.orderPackages)(transformed.packages).map(pkg => path.join(transformed.outBase, pkg.name));
+        await deployModules(cfgTransformed, orderedDirs);
+        return (0, scratch_db_1.catalogDifferences)(cfgOriginal, cfgTransformed);
+    });
+};
+const transformModule = async (modulePath, granularity, changeGranularity, naming, partition, out) => {
+    const source = (0, transform_1.loadModuleSource)(modulePath);
+    const warnings = [...source.warnings];
+    const rows = source.changes.map(change => ({
+        name: change.name,
+        deploy: change.name,
+        deps: change.dependencies,
+        content: change.deploy
+    }));
+    const restructured = await (0, transform_1.restructureExportRows)(rows, granularity, { naming, changeGranularity });
+    warnings.push(...restructured.warnings.map(w => `restructure (${granularity}): ${w}`));
+    const outBase = (0, exports.resolveOutBase)(modulePath, out);
+    let packages;
+    if (partition) {
+        const result = await (0, transform_1.partitionExportRows)(restructured.rows, partition);
+        warnings.push(...result.warnings.map(w => `partition: ${w}`));
+        packages = result.packages;
+    }
+    else {
+        // Distinct package name so the output can live beside the source module
+        // in the same workspace without colliding.
+        packages = [{ name: `${source.name}-${granularity}`, requires: [], rows: restructured.rows }];
+    }
+    return { modulePath, name: source.name, outBase, packages, warnings };
+};
+const printDryRun = (transformed) => {
+    console.log(`module ${transformed.name} (${transformed.modulePath})`);
+    for (const pkg of transformed.packages) {
+        console.log(`  package ${pkg.name} -> ${path.join(transformed.outBase, pkg.name)}`);
+        for (const row of pkg.rows) {
+            const deps = row.deps?.length ? ` [${row.deps.join(' ')}]` : '';
+            console.log(`    ${row.deploy}${deps}`);
+        }
+    }
+};
+exports.default = async (argv, prompter, _options) => {
+    if (argv.help || argv.h) {
+        console.log(transformUsageText);
+        process.exit(0);
+    }
+    const granularityRaw = argv.granularity;
+    if (granularityRaw === undefined) {
+        await (0, inquirerer_1.cliExitWithError)(`--granularity is required. Expected one of: ${transform_1.EXPORT_GRANULARITIES.join(', ')}.`);
+    }
+    if (!(0, transform_1.isExportGranularity)(granularityRaw)) {
+        await (0, inquirerer_1.cliExitWithError)(`Invalid --granularity "${granularityRaw}". Expected one of: ${transform_1.EXPORT_GRANULARITIES.join(', ')}.`);
+    }
+    const granularity = granularityRaw;
+    const changeGranularityRaw = argv['change-granularity'] ?? argv.changeGranularity ?? 'object';
+    if (!(0, transform_1.isChangeGranularity)(changeGranularityRaw)) {
+        await (0, inquirerer_1.cliExitWithError)(`Invalid --change-granularity "${changeGranularityRaw}". Expected one of: ${transform_1.CHANGE_GRANULARITIES.join(', ')}.`);
+    }
+    const changeGranularity = changeGranularityRaw;
+    const namingRaw = argv.naming ?? 'directory';
+    if (!NAMING_STYLES.includes(namingRaw)) {
+        await (0, inquirerer_1.cliExitWithError)(`Invalid --naming "${namingRaw}". Expected one of: ${NAMING_STYLES.join(', ')}.`);
+    }
+    const naming = namingRaw;
+    const cwd = argv.cwd || process.cwd();
+    let partition;
+    if (typeof argv.partition === 'string' && argv.partition) {
+        try {
+            partition = (0, transform_1.parsePartitionConfig)(path.resolve(cwd, argv.partition));
+        }
+        catch (err) {
+            await (0, inquirerer_1.cliExitWithError)(err instanceof Error ? err.message : String(err));
+        }
+    }
+    const out = typeof argv.out === 'string' && argv.out ? path.resolve(cwd, argv.out) : undefined;
+    const write = Boolean(argv.write);
+    const check = Boolean(argv.check);
+    const dryRun = Boolean(argv['dry-run'] ?? argv.dryRun);
+    const emit = (0, module_projections_1.parseEmitProjectionTargets)(argv, cwd);
+    const emitRequested = (0, module_projections_1.hasEmitProjection)(emit);
+    const sqlToStdout = emit.emitSql === module_projections_1.STDOUT_TARGET;
+    const pkg = new core_1.PgpmPackage(path.resolve(cwd));
+    let modulePaths;
+    if (pkg.isInModule()) {
+        modulePaths = [pkg.modulePath];
+    }
+    else if (pkg.workspacePath) {
+        const moduleMap = pkg.getModuleMap();
+        modulePaths = Object.values(moduleMap).map(mod => path.resolve(pkg.workspacePath, mod.path));
+        if (modulePaths.length === 0) {
+            await (0, inquirerer_1.cliExitWithError)('No modules found in workspace.');
+        }
+        if (out && modulePaths.length > 1) {
+            await (0, inquirerer_1.cliExitWithError)('--out is not supported when transforming a multi-module workspace.');
+        }
+    }
+    else {
+        await (0, inquirerer_1.cliExitWithError)('Not inside a pgpm module or workspace (pass --cwd <dir>).');
+        return;
+    }
+    if (emitRequested && modulePaths.length > 1) {
+        await (0, inquirerer_1.cliExitWithError)('--emit-sql/--emit-bundle target a single module; they are not supported when transforming a multi-module workspace.');
+    }
+    if (emitRequested && dryRun) {
+        await (0, inquirerer_1.cliExitWithError)('--emit-sql/--emit-bundle cannot be combined with --dry-run.');
+    }
+    for (const modulePath of modulePaths) {
+        let transformed;
+        try {
+            transformed = await transformModule(modulePath, granularity, changeGranularity, naming, partition, out);
+        }
+        catch (err) {
+            if (err instanceof transform_1.PartitionCycleError) {
+                await (0, inquirerer_1.cliExitWithError)(`Partition failed: ${err.message}`);
+                return;
+            }
+            throw err;
+        }
+        for (const warning of transformed.warnings) {
+            console.warn(`transform: ${warning}`);
+        }
+        if (dryRun) {
+            printDryRun(transformed);
+            continue;
+        }
+        for (const pkgRows of transformed.packages) {
+            const targetDir = path.join(transformed.outBase, pkgRows.name);
+            const guard = (0, emit_package_1.checkOverwrite)(targetDir, modulePath, write);
+            if (guard) {
+                await (0, inquirerer_1.cliExitWithError)(guard);
+            }
+        }
+        if (emitRequested && transformed.packages.length !== 1) {
+            await (0, inquirerer_1.cliExitWithError)('--emit-sql/--emit-bundle require a single output package; a --partition transform emits multiple packages.');
+        }
+        const sourceRequires = readControlRequires(modulePath, transformed.name);
+        let firstDir;
+        for (const pkgRows of transformed.packages) {
+            const dir = (0, emit_package_1.writePackage)(transformed.outBase, pkgRows, sourceRequires);
+            firstDir ??= dir;
+            if (!sqlToStdout) {
+                log.success(`wrote ${pkgRows.rows.length} changes to ${dir}`);
+            }
+        }
+        if (emitRequested && firstDir) {
+            await (0, module_projections_1.projectModule)(firstDir, emit, sqlToStdout ? undefined : msg => log.success(msg));
+        }
+        if (check) {
+            log.info('running --check: deploying original and transformed output to scratch databases...');
+            const diffs = await runCheck(transformed);
+            if (diffs.length) {
+                console.error(`--check failed: catalogs differ (${diffs.length} differences):`);
+                for (const diff of diffs)
+                    console.error(`  ${diff}`);
+                await (0, inquirerer_1.cliExitWithError)('Transform is not structurally lossless.');
+            }
+            log.success('--check passed: catalogs are structurally equivalent.');
+        }
+    }
+    prompter.close();
+    return argv;
+};

package/commands/update.js

@@ -2,8 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const utils_1 = require("@inquirerer/utils");
 const logger_1 = require("@pgpmjs/logger");
-const inquirerer_1 = require("inquirerer");
 const child_process_1 = require("child_process");
+const inquirerer_1 = require("inquirerer");
 const npm_version_1 = require("../utils/npm-version");
 const log = new logger_1.Logger('update');
 const updateUsageText = `