pgpm 5.19.1 → 5.20.0

package/esm/commands/dump.js

@@ -1,10 +1,10 @@
 import { Logger } from '@pgpmjs/logger';
-import { getPgEnvOptions, getSpawnEnvWithPg } from 'pg-env';
-import { getPgPool } from 'pg-cache';
+import { QuoteUtils } from '@pgsql/quotes';
 import { spawn } from 'child_process';
 import fs from 'fs';
 import path from 'path';
-import { QuoteUtils } from '@pgsql/quotes';
+import { getPgPool } from 'pg-cache';
+import { getPgEnvOptions, getSpawnEnvWithPg } from 'pg-env';
 import { getTargetDatabase } from '../utils';
 const log = new Logger('dump');
 const dumpUsageText = `

package/esm/commands/export.js

@@ -1,6 +1,7 @@
 import { PgpmPackage } from '@pgpmjs/core';
-import { exportMigrations, exportGraphQL, GraphQLClient, graphqlRowToPostgresRow, isExportGranularity, EXPORT_GRANULARITIES } from '@pgpmjs/export';
 import { getEnvOptions } from '@pgpmjs/env';
+import { exportGraphQL, exportMigrations, GraphQLClient, graphqlRowToPostgresRow } from '@pgpmjs/export';
+import { EXPORT_GRANULARITIES, isExportGranularity, parsePartitionConfig } from '@pgpmjs/transform';
 import { getGitConfigInfo } from '@pgpmjs/types';
 import { resolve } from 'path';
 import { getPgPool } from 'pg-cache';
@@ -28,12 +29,16 @@ Options:
                           Change paths are derived from the naming spec and
                           requires from the statement graph. When omitted,
                           sql_actions rows are exported unchanged.
+  --partition <file>      Partition config (JSON: rules/defaultPackage/splitRiders)
+                          splitting the exported database module into multiple
+                          pgpm packages with derived cross-package requires.
   --cwd <directory>       Working directory (default: current directory)
 
 Examples:
   pgpm export              Export migrations from selected database (SQL mode)
   pgpm export --exclude-categories security,permissions,auth,memberships
   pgpm export --granularity consolidated
+  pgpm export --granularity object --partition partition.json
   pgpm export --graphql-endpoint 'http://[::1]:3002/graphql' --migrate-endpoint 'http://[::1]:3000/graphql' --migrate-host db_migrate.localhost:3000
 `;
 export default async (argv, prompter, _options) => {
@@ -65,6 +70,18 @@ export default async (argv, prompter, _options) => {
         return;
     }
     const granularity = granularityRaw;
+    const partitionRaw = argv.partition;
+    let partition;
+    if (typeof partitionRaw === 'string' && partitionRaw) {
+        try {
+            partition = parsePartitionConfig(resolve(cwd, partitionRaw));
+        }
+        catch (err) {
+            console.error(err instanceof Error ? err.message : String(err));
+            prompter.close();
+            return;
+        }
+    }
     if (graphqlEndpoint) {
         // =========================================================================
         // GraphQL export mode
@@ -162,7 +179,8 @@ export default async (argv, prompter, _options) => {
             argv,
             username,
             excludeCategories,
-            granularity
+            granularity,
+            partition
         });
     }
     else {
@@ -283,7 +301,8 @@ export default async (argv, prompter, _options) => {
             argv,
             username,
             excludeCategories,
-            granularity
+            granularity,
+            partition
         });
     }
     prompter.close();

package/esm/commands/import.js

@@ -0,0 +1,163 @@
+import { dumpCompatibilityWarnings, importDumpRows, linkTextualDeps, loadDumpSource } from '@pgpmjs/import';
+import { Logger } from '@pgpmjs/logger';
+import { EXPORT_GRANULARITIES, isExportGranularity, parsePartitionConfig, PartitionCycleError, partitionExportRows } from '@pgpmjs/transform';
+import { cliExitWithError } from 'inquirerer';
+import * as path from 'path';
+import { checkOverwrite, writePackage } from '../utils/emit-package';
+const log = new 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)
+  --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
+  --cwd <directory>       Working directory (default: current directory)
+  --dry-run               Print the resulting plan/paths without writing
+
+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
+`;
+const NAMING_STYLES = ['directory', 'flat'];
+export 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 cliExitWithError('Missing input: pgpm import <dump.sql | dir-of-sql-files> --pkg <name>');
+    }
+    const pkgName = argv.pkg;
+    if (!pkgName || typeof pkgName !== 'string') {
+        await cliExitWithError('--pkg <module-name> is required.');
+    }
+    const granularityRaw = argv.granularity ?? 'object';
+    if (!isExportGranularity(granularityRaw)) {
+        await cliExitWithError(`Invalid --granularity "${granularityRaw}". Expected one of: ${EXPORT_GRANULARITIES.join(', ')}.`);
+    }
+    const granularity = granularityRaw;
+    const namingRaw = argv.naming ?? 'directory';
+    if (!NAMING_STYLES.includes(namingRaw)) {
+        await cliExitWithError(`Invalid --naming "${namingRaw}". Expected one of: ${NAMING_STYLES.join(', ')}.`);
+    }
+    const naming = namingRaw;
+    let partition;
+    if (typeof argv.partition === 'string' && argv.partition) {
+        try {
+            partition = parsePartitionConfig(path.resolve(cwd, argv.partition));
+        }
+        catch (err) {
+            await 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);
+    let source;
+    try {
+        source = loadDumpSource(path.resolve(cwd, input));
+    }
+    catch (err) {
+        await cliExitWithError(err instanceof Error ? err.message : String(err));
+        return;
+    }
+    if (source.files.length > 1) {
+        log.info(`concatenated ${source.files.length} .sql files in sorted order`);
+    }
+    for (const warning of dumpCompatibilityWarnings(source)) {
+        console.warn(`\nWARNING: ${warning}\n`);
+    }
+    const result = await importDumpRows(source, { granularity, naming, withData });
+    let packages;
+    if (partition) {
+        try {
+            const partitioned = await 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: linkTextualDeps(pkg.rows)
+            }));
+        }
+        catch (err) {
+            if (err instanceof PartitionCycleError) {
+                await 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 {
+        for (const pkg of packages) {
+            const guard = checkOverwrite(path.join(outBase, pkg.name), source.files[0], write);
+            if (guard) {
+                await cliExitWithError(guard);
+            }
+        }
+        for (const pkg of packages) {
+            const dir = writePackage(outBase, pkg);
+            log.success(`wrote ${pkg.rows.length} changes to ${dir}`);
+        }
+    }
+    const { summary } = result;
+    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/esm/commands/init/boilerplate.js

@@ -1,6 +1,6 @@
+import { DEFAULT_TEMPLATE_REPO, PgpmPackage, TEMPLATE_REPOS } from '@pgpmjs/core';
 import fs from 'fs';
 import path from 'path';
-import { DEFAULT_TEMPLATE_REPO, PgpmPackage, TEMPLATE_REPOS } from '@pgpmjs/core';
 /**
  * Resolve the template repo for an `init` invocation from its flags.
  *

package/esm/commands/init/index.js

@@ -1,10 +1,10 @@
-import { execSync } from 'child_process';
-import fs from 'fs';
-import path from 'path';
 import { DEFAULT_TEMPLATE_REPO, DEFAULT_TEMPLATE_TOOL_NAME, inspectTemplate, PgpmPackage, resolveBoilerplateBaseDir, scaffoldTemplate, scanBoilerplates, SkillInstaller, sluggify, } from '@pgpmjs/core';
 import { resolveWorkspaceByType } from '@pgpmjs/env';
 import { errors } from '@pgpmjs/types';
+import { execSync } from 'child_process';
+import fs from 'fs';
 import { registerDefaultResolver } from 'inquirerer';
+import path from 'path';
 import { isNoTtyRequested } from '../../utils';
 import { persistBoilerplateSource, readBoilerplateSource, resolveInitTemplateRepo, } from './boilerplate';
 const DEFAULT_MOTD = `

package/esm/commands/package.js

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

package/esm/commands/slice.js

@@ -1,8 +1,8 @@
 import { PgpmPackage } from '@pgpmjs/core';
 import { generateDryRunReport, slicePlan, writeSliceResult } from '@pgpmjs/slice';
 import { getGitConfigInfo } from '@pgpmjs/types';
+import { existsSync, readFileSync } from 'fs';
 import { resolve } from 'path';
-import { readFileSync, existsSync } from 'fs';
 const sliceUsageText = `
 Slice Command:
 

package/esm/commands/test-packages.js

@@ -2,8 +2,8 @@ import { PgpmPackage } from '@pgpmjs/core';
 import { getEnvOptions } from '@pgpmjs/env';
 import { Logger } from '@pgpmjs/logger';
 import path from 'path';
-import { getPgEnvOptions } from 'pg-env';
 import { getPgPool } from 'pg-cache';
+import { getPgEnvOptions } from 'pg-env';
 const log = new Logger('test-packages');
 // ANSI color codes
 const RED = '\x1b[0;31m';

package/esm/commands/transform.js

@@ -0,0 +1,236 @@
+import { PgpmMigrate, PgpmPackage } from '@pgpmjs/core';
+import { Logger } from '@pgpmjs/logger';
+import { EXPORT_GRANULARITIES, isExportGranularity, loadModuleSource, parsePartitionConfig, PartitionCycleError, partitionExportRows, restructureExportRows } from '@pgpmjs/transform';
+import * as fs from 'fs';
+import { cliExitWithError } from 'inquirerer';
+import * as path from 'path';
+import { getPgEnvOptions } from 'pg-env';
+import { checkOverwrite, writePackage } from '../utils/emit-package';
+import { catalogDifferences, withScratchDatabases } from '../utils/scratch-db';
+export { checkOverwrite } from '../utils/emit-package';
+const log = new 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)
+  --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
+  --check                 Deploy original and transformed output into scratch
+                          databases and assert the catalogs are equivalent
+  --dry-run               Print the resulting plan/paths without writing
+
+Examples:
+  pgpm transform --granularity object
+  pgpm transform --granularity atomic --naming flat --out ./out
+  pgpm transform --granularity object --partition partition.json --check
+`;
+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`.
+ */
+export const resolveOutBase = (modulePath, out) => {
+    if (out)
+        return path.resolve(out);
+    return path.dirname(modulePath);
+};
+/** Order partition packages so prerequisites come before dependents. */
+export 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;
+};
+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 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 = getPgEnvOptions();
+    const stamp = Date.now();
+    const names = [`pgpm_transform_check_a_${stamp}`, `pgpm_transform_check_b_${stamp}`];
+    return withScratchDatabases(config, names, async ([cfgOriginal, cfgTransformed]) => {
+        await deployModules(cfgOriginal, [transformed.modulePath]);
+        const orderedDirs = orderPackages(transformed.packages).map(pkg => path.join(transformed.outBase, pkg.name));
+        await deployModules(cfgTransformed, orderedDirs);
+        return catalogDifferences(cfgOriginal, cfgTransformed);
+    });
+};
+const transformModule = async (modulePath, granularity, naming, partition, out) => {
+    const source = 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 restructureExportRows(rows, granularity, { naming });
+    warnings.push(...restructured.warnings.map(w => `restructure (${granularity}): ${w}`));
+    const outBase = resolveOutBase(modulePath, out);
+    let packages;
+    if (partition) {
+        const result = await 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}`);
+        }
+    }
+};
+export default async (argv, prompter, _options) => {
+    if (argv.help || argv.h) {
+        console.log(transformUsageText);
+        process.exit(0);
+    }
+    const granularityRaw = argv.granularity;
+    if (granularityRaw === undefined) {
+        await cliExitWithError(`--granularity is required. Expected one of: ${EXPORT_GRANULARITIES.join(', ')}.`);
+    }
+    if (!isExportGranularity(granularityRaw)) {
+        await cliExitWithError(`Invalid --granularity "${granularityRaw}". Expected one of: ${EXPORT_GRANULARITIES.join(', ')}.`);
+    }
+    const granularity = granularityRaw;
+    const namingRaw = argv.naming ?? 'directory';
+    if (!NAMING_STYLES.includes(namingRaw)) {
+        await 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 = parsePartitionConfig(path.resolve(cwd, argv.partition));
+        }
+        catch (err) {
+            await 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 pkg = new 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 cliExitWithError('No modules found in workspace.');
+        }
+        if (out && modulePaths.length > 1) {
+            await cliExitWithError('--out is not supported when transforming a multi-module workspace.');
+        }
+    }
+    else {
+        await cliExitWithError('Not inside a pgpm module or workspace (pass --cwd <dir>).');
+        return;
+    }
+    for (const modulePath of modulePaths) {
+        let transformed;
+        try {
+            transformed = await transformModule(modulePath, granularity, naming, partition, out);
+        }
+        catch (err) {
+            if (err instanceof PartitionCycleError) {
+                await 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 = checkOverwrite(targetDir, modulePath, write);
+            if (guard) {
+                await cliExitWithError(guard);
+            }
+        }
+        const sourceRequires = readControlRequires(modulePath, transformed.name);
+        for (const pkgRows of transformed.packages) {
+            const dir = writePackage(transformed.outBase, pkgRows, sourceRequires);
+            log.success(`wrote ${pkgRows.rows.length} changes to ${dir}`);
+        }
+        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 cliExitWithError('Transform is not structurally lossless.');
+            }
+            log.success('--check passed: catalogs are structurally equivalent.');
+        }
+    }
+    prompter.close();
+    return argv;
+};

package/esm/commands/update.js

@@ -1,7 +1,7 @@
 import { suppressUpdateCheck } from '@inquirerer/utils';
 import { Logger } from '@pgpmjs/logger';
-import { cliExitWithError, getPackageJson } from 'inquirerer';
 import { spawn } from 'child_process';
+import { cliExitWithError, getPackageJson } from 'inquirerer';
 import { fetchLatestVersion } from '../utils/npm-version';
 const log = new Logger('update');
 const updateUsageText = `

package/esm/commands.js

@@ -7,12 +7,14 @@ import analyze from './commands/analyze';
 import cache from './commands/cache';
 import clear from './commands/clear';
 import deploy from './commands/deploy';
+import diff from './commands/diff';
 import docker from './commands/docker';
 import doctor from './commands/doctor';
 import dump from './commands/dump';
 import env from './commands/env';
 import _export from './commands/export';
 import extension from './commands/extension';
+import _import from './commands/import';
 import init from './commands/init';
 import install from './commands/install';
 import kill from './commands/kill';
@@ -28,6 +30,7 @@ import slice from './commands/slice';
 import syncVersions from './commands/sync-versions';
 import tag from './commands/tag';
 import testPackages from './commands/test-packages';
+import transform from './commands/transform';
 import tune from './commands/tune';
 import updateCmd from './commands/update';
 import upgrade from './commands/upgrade';
@@ -47,6 +50,7 @@ const ENGINE_EXEMPT_COMMANDS = new Set([
     'doctor',
     'env',
     'extension',
+    'import',
     'init',
     'install',
     'package',
@@ -79,6 +83,7 @@ export const createPgpmCommandMap = (skipPgTeardown = false) => {
         'admin-users': pgt(adminUsers),
         clear: pgt(clear),
         deploy: pgt(deploy),
+        diff: pgt(diff),
         docker,
         doctor,
         dump: pgt(dump),
@@ -91,6 +96,7 @@ export const createPgpmCommandMap = (skipPgTeardown = false) => {
         plan: pgt(plan),
         regen,
         export: pgt(_export),
+        import: pgt(_import),
         package: pgt(_package),
         tag: pgt(tag),
         kill: pgt(kill),
@@ -102,6 +108,7 @@ export const createPgpmCommandMap = (skipPgTeardown = false) => {
         slice,
         'sync-versions': syncVersions,
         'test-packages': pgt(testPackages),
+        transform: pgt(transform),
         tune: pgt(tune),
         upgrade: pgt(upgrade),
         up: pgt(upgrade),

package/esm/utils/display.js

@@ -12,6 +12,9 @@ export const usageText = `
     extension          Manage module dependencies
     plan               Generate module deployment plans
     regen              Generate revert/verify scripts from deploy scripts
+    transform          Re-dial a module through the dials pipeline (granularity/naming/partition)
+    import             pgpm-itize an arbitrary SQL dump into a deployable module
+    diff               Identity-keyed semantic diff between two schema sources (+ migration generation)
     package            Package module for distribution
     materialize        Transpile an apply proxy into a plain, committed module
     sync-versions      Sync .control/Makefile/sql metadata to package.json versions

package/esm/utils/driver.js

@@ -1,6 +1,6 @@
-import { PGPM_DRIVER_EXPORT, } from '@pgpmjs/types';
 import { createRequire } from 'node:module';
 import { resolve } from 'node:path';
+import { PGPM_DRIVER_EXPORT, } from '@pgpmjs/types';
 /** Package name of the built-in PGlite driver plugin (the `--pglite` alias). */
 export const PGLITE_DRIVER_PLUGIN = '@pgpmjs/pglite-adapter';
 /**

package/esm/utils/emit-package.js

@@ -0,0 +1 @@
+export { checkOverwrite, writeControlFile, writeModule as writePackage } from '@pgpmjs/transform';

package/esm/utils/engine.js

@@ -1,6 +1,6 @@
+import { resolve } from 'node:path';
 import { getEnvOptions } from '@pgpmjs/env';
 import { BUILTIN_ENGINES, DEFAULT_ENGINE, } from '@pgpmjs/types';
-import { resolve } from 'node:path';
 import { activateDriver, driverOverrideFromArgv, PGLITE_DRIVER_PLUGIN } from './driver';
 /** Everything a real Postgres server can do — the built-in `pg` engine. */
 export const SERVER_CAPABILITIES = {