@pgpmjs/transform 0.17.0 → 0.19.0

package/esm/semantic-diff-driver.js

@@ -16,15 +16,18 @@
  * modified objects routed through the granularity pipeline
  * (`restructureChanges`), so names come from the naming spec and `requires`
  * from the statement graph — the same derivation every other projection uses.
- * Every emitted change carries a full deploy/revert/verify triple: drops are
- * `@pgsql/scripts`' `revertFor` inverses of the object's own deploy
- * statements (never hand-templated), reverts recreate what was dropped, and
- * verifies come from `verifyFor`.
+ * Every emitted change carries a full deploy/revert/verify triple: inverses
+ * and existence checks are composed at the AST level via `@pgsql/scripts`'
+ * node-level API (`invertStatement`/`existenceCheck`) — never hand-templated
+ * and never round-tripped through deparsed text — deparsing only once at the
+ * end. Statements the node layer cannot derive fall back to the text layer
+ * (`revertFor`/`verifyFor`) solely to surface its not-derivable comment and
+ * warning.
  *
  * Requires `loadModule()` from `plpgsql-parser` before use.
  */
 import { pathFor } from '@pgpmjs/naming-spec';
-import { revertFor, verifyFor } from '@pgsql/scripts';
+import { existenceCheck, invertStatement, revertFor, verifyFor } from '@pgsql/scripts';
 import { buildStatementGraph, classifyStatements, cleanTree, identityOf } from '@pgsql/transform';
 import { Deparser, parseSync } from 'plpgsql-parser';
 import { restructureChanges } from './granularity-driver';
@@ -207,32 +210,46 @@ function diffTable(from, to, diff, warnings) {
             stmts.push(alter({ subtype: 'AT_DropColumn', name }));
         }
     }
-    for (const [print, extra] of to.extras) {
-        if (!from.extras.has(print)) {
-            const at = extra.AlterTableCmd;
-            if (at)
-                stmts.push(alter(at));
-            else if (extra.Constraint) {
-                stmts.push(alter({ subtype: 'AT_AddConstraint', def: extra }));
-            }
-            else {
-                warnings.push(`${diff.path}: unrecognized added table element; emit a manual ALTER`);
-            }
-        }
-    }
+    // Self-inverse ALTER TABLE subtypes: a removed extra with one of these
+    // undoes with the paired subtype rather than a DROP CONSTRAINT.
+    const INVERSE_SUBTYPE = {
+        AT_EnableRowSecurity: 'AT_DisableRowSecurity',
+        AT_DisableRowSecurity: 'AT_EnableRowSecurity',
+        AT_ForceRowSecurity: 'AT_NoForceRowSecurity',
+        AT_NoForceRowSecurity: 'AT_ForceRowSecurity'
+    };
+    // Removed extras drop before added ones: a changed constraint that keeps
+    // its name must DROP CONSTRAINT before the replacement ADD CONSTRAINT.
     for (const [print, extra] of from.extras) {
         if (to.extras.has(print))
             continue;
         const conname = extra.Constraint?.conname
             ?? extra
                 .AlterTableCmd?.def?.Constraint?.conname;
+        const subtype = extra.AlterTableCmd?.subtype;
         if (conname) {
             stmts.push(alter({ subtype: 'AT_DropConstraint', name: conname }));
         }
+        else if (subtype && INVERSE_SUBTYPE[subtype]) {
+            stmts.push(alter({ subtype: INVERSE_SUBTYPE[subtype] }));
+        }
         else {
             warnings.push(`${diff.path}: removed table element has no name to drop; emit a manual ALTER`);
         }
     }
+    for (const [print, extra] of to.extras) {
+        if (!from.extras.has(print)) {
+            const at = extra.AlterTableCmd;
+            if (at)
+                stmts.push(alter(at));
+            else if (extra.Constraint) {
+                stmts.push(alter({ subtype: 'AT_AddConstraint', def: extra }));
+            }
+            else {
+                warnings.push(`${diff.path}: unrecognized added table element; emit a manual ALTER`);
+            }
+        }
+    }
     return stmts;
 }
 /**
@@ -252,17 +269,46 @@ export function diffSchemas(from, to, options = {}) {
     const forwardSql = [];
     const modifiedChanges = [];
     const dropUnits = [];
-    /** `@pgsql/scripts` inverse of a deploy script (drops in reverse topo order). */
+    /**
+     * `@pgsql/scripts` inverse of a deploy script (drops in reverse topo
+     * order), composed at the AST level via `invertStatement` and deparsed
+     * once. Underivable statements fall back to `revertFor` on the single
+     * statement to surface its not-derivable comment and warning.
+     */
     const inverseOf = (deploy, context) => {
-        const { sql, warnings: w } = revertFor(classifyStatements(deploy));
-        warnings.push(...w.map(x => `${context}: ${x}`));
-        return sql;
+        const facts = classifyStatements(deploy);
+        const graph = buildStatementGraph(facts);
+        const pieces = [];
+        for (const i of [...graph.order].reverse()) {
+            const nodes = invertStatement(facts[i]);
+            if (nodes === null) {
+                const { sql, warnings: w } = revertFor([facts[i]]);
+                warnings.push(...w.map(x => `${context}: ${x}`));
+                if (sql.trim())
+                    pieces.push(sql);
+                continue;
+            }
+            pieces.push(...nodes.map(n => deparseStmt(n)));
+        }
+        return pieces.join('\n');
     };
-    /** `@pgsql/scripts` existence checks for a deploy script. */
+    /**
+     * `@pgsql/scripts` existence checks for a deploy script, composed from
+     * `existenceCheck`'s SelectStmt nodes and deparsed once. Underivable
+     * statements fall back to `verifyFor` to surface the warning.
+     */
     const verifyOf = (deploy, context) => {
-        const { sql, warnings: w } = verifyFor(classifyStatements(deploy));
-        warnings.push(...w.map(x => `${context}: ${x}`));
-        return sql;
+        const pieces = [];
+        for (const fact of classifyStatements(deploy)) {
+            const nodes = existenceCheck(fact);
+            if (nodes === null) {
+                const { warnings: w } = verifyFor([fact]);
+                warnings.push(...w.map(x => `${context}: ${x}`));
+                continue;
+            }
+            pieces.push(...nodes.map(n => deparseStmt(n)));
+        }
+        return pieces.join('\n\n');
     };
     for (const key of b.order) {
         const unit = b.units.get(key);

package/fixture-closure.d.ts

@@ -1,5 +1,5 @@
-import { CategoryProfile, ChangeCategory } from './categorize';
 import { QualifiedName } from '@pgsql/transform';
+import { CategoryProfile, ChangeCategory } from './categorize';
 /**
  * A change plus its deploy SQL. Optional plan `dependencies` (from `pgpm.plan`)
  * are followed as authoritative prerequisites in addition to AST-derived edges.

package/fixture-closure.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.resolveFixtureClosure = resolveFixtureClosure;
-const categorize_1 = require("./categorize");
 const transform_1 = require("@pgsql/transform");
+const categorize_1 = require("./categorize");
 function objectKey(schema, name) {
     return `${schema ?? ''}\u0000${name}`;
 }

package/index.d.ts

@@ -1,18 +1,28 @@
-export * from '@pgsql/transform';
-export { loadModule } from 'plpgsql-parser';
 export type { BundleScriptContext, ExtensionRoutingInput, NamespaceValidatorOptions, SchemaObjectRoute, SchemaTranspiler, SchemaTranspilerOptions, } from './bundle-driver';
 export { buildExtensionRouter, buildSchemaRouter, makeNamespaceValidator, makeSchemaTranspiler, } from './bundle-driver';
-export type { GranularityChange, RestructuredChange, RestructureModuleOptions, RestructureModuleResult, } from './granularity-driver';
-export { defaultChangeName, restructureChanges, } from './granularity-driver';
-export type { DiffInputChange, ObjectDelta, SemanticDeltaChange, SemanticDiffOptions, SemanticDiffResult, SemanticObjectDiff, } from './semantic-diff-driver';
-export { diffChangeSets, diffSchemas, } from './semantic-diff-driver';
-export type { PartitionConfig, PartitionedChange, PartitionedPackage, PartitionInputChange, PartitionRule, PartitionUnit, PartitionUnitsResult, UnitSelector, } from './partition-driver';
-export { PartitionCycleError, partitionUnits, RESIDUAL_UNIT_PATH, } from './partition-driver';
+export type { CatalogQueryable, CatalogSnapshot } from './catalog-check';
+export { diffCatalogSnapshots, snapshotCatalog, withoutColumnOrder } from './catalog-check';
 export type { CategoryProfile, ChangeCategory, } from './categorize';
 export { buildCategoryOf, categorizeChange, TIER_PROFILE, } from './categorize';
 export type { ClosureChange, ClosureInputChange, ClosureReason, FixtureClosure, ResolveFixtureClosureOptions, } from './fixture-closure';
 export { resolveFixtureClosure } from './fixture-closure';
-export type { GeneratedScript, RegeneratedScripts, } from './regen';
-export { classifyScript, isStubScript, regenerateScripts, } from './regen';
+export type { GranularityChange, RestructuredChange, RestructureModuleOptions, RestructureModuleResult, } from './granularity-driver';
+export { defaultChangeName, restructureChanges, } from './granularity-driver';
+export type { PgpmModuleModel } from './module-emit';
+export { checkOverwrite, writeControlFile, writeModule } from './module-emit';
+export type { ModuleSource, ModuleSourceChange } from './module-source';
+export { loadModuleSource, stripTransactionWrapper } from './module-source';
+export type { PartitionedPackageRows, PartitionExportRowsResult } from './partition';
+export { parsePartitionConfig, partitionExportRows } from './partition';
+export type { PartitionConfig, PartitionedChange, PartitionedPackage, PartitionInputChange, PartitionRule, PartitionUnit, PartitionUnitsResult, UnitSelector, } from './partition-driver';
+export { PartitionCycleError, partitionUnits, RESIDUAL_UNIT_PATH, } from './partition-driver';
 export type { SqlProgram, SqlStatementAst, SqlStatementSpan, } from './program';
 export { emitSqlProgram, parseSqlProgram } from './program';
+export type { GeneratedScript, RegeneratedScripts, } from './regen';
+export { classifyScript, isStubScript, regenerateScripts, } from './regen';
+export type { ExportGranularity, RestructureExportRowsOptions, RestructureExportRowsResult } from './restructure';
+export { EXPORT_GRANULARITIES, isExportGranularity, restructureExportRows } from './restructure';
+export type { DiffInputChange, ObjectDelta, SemanticDeltaChange, SemanticDiffOptions, SemanticDiffResult, SemanticObjectDiff, } from './semantic-diff-driver';
+export { diffChangeSets, diffSchemas, } from './semantic-diff-driver';
+export * from '@pgsql/transform';
+export { loadModule } from 'plpgsql-parser';

package/index.js

@@ -14,35 +14,53 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.parseSqlProgram = exports.emitSqlProgram = exports.regenerateScripts = exports.isStubScript = exports.classifyScript = exports.resolveFixtureClosure = exports.TIER_PROFILE = exports.categorizeChange = exports.buildCategoryOf = exports.RESIDUAL_UNIT_PATH = exports.partitionUnits = exports.PartitionCycleError = exports.diffSchemas = exports.diffChangeSets = exports.restructureChanges = exports.defaultChangeName = exports.makeSchemaTranspiler = exports.makeNamespaceValidator = exports.buildSchemaRouter = exports.buildExtensionRouter = exports.loadModule = void 0;
-__exportStar(require("@pgsql/transform"), exports);
-var plpgsql_parser_1 = require("plpgsql-parser");
-Object.defineProperty(exports, "loadModule", { enumerable: true, get: function () { return plpgsql_parser_1.loadModule; } });
+exports.loadModule = exports.diffSchemas = exports.diffChangeSets = exports.restructureExportRows = exports.isExportGranularity = exports.EXPORT_GRANULARITIES = exports.regenerateScripts = exports.isStubScript = exports.classifyScript = exports.parseSqlProgram = exports.emitSqlProgram = exports.RESIDUAL_UNIT_PATH = exports.partitionUnits = exports.PartitionCycleError = exports.partitionExportRows = exports.parsePartitionConfig = exports.stripTransactionWrapper = exports.loadModuleSource = exports.writeModule = exports.writeControlFile = exports.checkOverwrite = exports.restructureChanges = exports.defaultChangeName = exports.resolveFixtureClosure = exports.TIER_PROFILE = exports.categorizeChange = exports.buildCategoryOf = exports.withoutColumnOrder = exports.snapshotCatalog = exports.diffCatalogSnapshots = exports.makeSchemaTranspiler = exports.makeNamespaceValidator = exports.buildSchemaRouter = exports.buildExtensionRouter = void 0;
 var bundle_driver_1 = require("./bundle-driver");
 Object.defineProperty(exports, "buildExtensionRouter", { enumerable: true, get: function () { return bundle_driver_1.buildExtensionRouter; } });
 Object.defineProperty(exports, "buildSchemaRouter", { enumerable: true, get: function () { return bundle_driver_1.buildSchemaRouter; } });
 Object.defineProperty(exports, "makeNamespaceValidator", { enumerable: true, get: function () { return bundle_driver_1.makeNamespaceValidator; } });
 Object.defineProperty(exports, "makeSchemaTranspiler", { enumerable: true, get: function () { return bundle_driver_1.makeSchemaTranspiler; } });
+var catalog_check_1 = require("./catalog-check");
+Object.defineProperty(exports, "diffCatalogSnapshots", { enumerable: true, get: function () { return catalog_check_1.diffCatalogSnapshots; } });
+Object.defineProperty(exports, "snapshotCatalog", { enumerable: true, get: function () { return catalog_check_1.snapshotCatalog; } });
+Object.defineProperty(exports, "withoutColumnOrder", { enumerable: true, get: function () { return catalog_check_1.withoutColumnOrder; } });
+var categorize_1 = require("./categorize");
+Object.defineProperty(exports, "buildCategoryOf", { enumerable: true, get: function () { return categorize_1.buildCategoryOf; } });
+Object.defineProperty(exports, "categorizeChange", { enumerable: true, get: function () { return categorize_1.categorizeChange; } });
+Object.defineProperty(exports, "TIER_PROFILE", { enumerable: true, get: function () { return categorize_1.TIER_PROFILE; } });
+var fixture_closure_1 = require("./fixture-closure");
+Object.defineProperty(exports, "resolveFixtureClosure", { enumerable: true, get: function () { return fixture_closure_1.resolveFixtureClosure; } });
 var granularity_driver_1 = require("./granularity-driver");
 Object.defineProperty(exports, "defaultChangeName", { enumerable: true, get: function () { return granularity_driver_1.defaultChangeName; } });
 Object.defineProperty(exports, "restructureChanges", { enumerable: true, get: function () { return granularity_driver_1.restructureChanges; } });
-var semantic_diff_driver_1 = require("./semantic-diff-driver");
-Object.defineProperty(exports, "diffChangeSets", { enumerable: true, get: function () { return semantic_diff_driver_1.diffChangeSets; } });
-Object.defineProperty(exports, "diffSchemas", { enumerable: true, get: function () { return semantic_diff_driver_1.diffSchemas; } });
+var module_emit_1 = require("./module-emit");
+Object.defineProperty(exports, "checkOverwrite", { enumerable: true, get: function () { return module_emit_1.checkOverwrite; } });
+Object.defineProperty(exports, "writeControlFile", { enumerable: true, get: function () { return module_emit_1.writeControlFile; } });
+Object.defineProperty(exports, "writeModule", { enumerable: true, get: function () { return module_emit_1.writeModule; } });
+var module_source_1 = require("./module-source");
+Object.defineProperty(exports, "loadModuleSource", { enumerable: true, get: function () { return module_source_1.loadModuleSource; } });
+Object.defineProperty(exports, "stripTransactionWrapper", { enumerable: true, get: function () { return module_source_1.stripTransactionWrapper; } });
+var partition_1 = require("./partition");
+Object.defineProperty(exports, "parsePartitionConfig", { enumerable: true, get: function () { return partition_1.parsePartitionConfig; } });
+Object.defineProperty(exports, "partitionExportRows", { enumerable: true, get: function () { return partition_1.partitionExportRows; } });
 var partition_driver_1 = require("./partition-driver");
 Object.defineProperty(exports, "PartitionCycleError", { enumerable: true, get: function () { return partition_driver_1.PartitionCycleError; } });
 Object.defineProperty(exports, "partitionUnits", { enumerable: true, get: function () { return partition_driver_1.partitionUnits; } });
 Object.defineProperty(exports, "RESIDUAL_UNIT_PATH", { enumerable: true, get: function () { return partition_driver_1.RESIDUAL_UNIT_PATH; } });
-var categorize_1 = require("./categorize");
-Object.defineProperty(exports, "buildCategoryOf", { enumerable: true, get: function () { return categorize_1.buildCategoryOf; } });
-Object.defineProperty(exports, "categorizeChange", { enumerable: true, get: function () { return categorize_1.categorizeChange; } });
-Object.defineProperty(exports, "TIER_PROFILE", { enumerable: true, get: function () { return categorize_1.TIER_PROFILE; } });
-var fixture_closure_1 = require("./fixture-closure");
-Object.defineProperty(exports, "resolveFixtureClosure", { enumerable: true, get: function () { return fixture_closure_1.resolveFixtureClosure; } });
+var program_1 = require("./program");
+Object.defineProperty(exports, "emitSqlProgram", { enumerable: true, get: function () { return program_1.emitSqlProgram; } });
+Object.defineProperty(exports, "parseSqlProgram", { enumerable: true, get: function () { return program_1.parseSqlProgram; } });
 var regen_1 = require("./regen");
 Object.defineProperty(exports, "classifyScript", { enumerable: true, get: function () { return regen_1.classifyScript; } });
 Object.defineProperty(exports, "isStubScript", { enumerable: true, get: function () { return regen_1.isStubScript; } });
 Object.defineProperty(exports, "regenerateScripts", { enumerable: true, get: function () { return regen_1.regenerateScripts; } });
-var program_1 = require("./program");
-Object.defineProperty(exports, "emitSqlProgram", { enumerable: true, get: function () { return program_1.emitSqlProgram; } });
-Object.defineProperty(exports, "parseSqlProgram", { enumerable: true, get: function () { return program_1.parseSqlProgram; } });
+var restructure_1 = require("./restructure");
+Object.defineProperty(exports, "EXPORT_GRANULARITIES", { enumerable: true, get: function () { return restructure_1.EXPORT_GRANULARITIES; } });
+Object.defineProperty(exports, "isExportGranularity", { enumerable: true, get: function () { return restructure_1.isExportGranularity; } });
+Object.defineProperty(exports, "restructureExportRows", { enumerable: true, get: function () { return restructure_1.restructureExportRows; } });
+var semantic_diff_driver_1 = require("./semantic-diff-driver");
+Object.defineProperty(exports, "diffChangeSets", { enumerable: true, get: function () { return semantic_diff_driver_1.diffChangeSets; } });
+Object.defineProperty(exports, "diffSchemas", { enumerable: true, get: function () { return semantic_diff_driver_1.diffSchemas; } });
+__exportStar(require("@pgsql/transform"), exports);
+var plpgsql_parser_1 = require("plpgsql-parser");
+Object.defineProperty(exports, "loadModule", { enumerable: true, get: function () { return plpgsql_parser_1.loadModule; } });

package/module-emit.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Module emission — the single seam every dials command renders through.
+ *
+ * The engine (semantic diff, granularity, partition) produces plan-ordered
+ * {@link PgpmRow}s; a {@link PgpmModuleModel} is just those rows plus the
+ * module's name and control-file requires. `writeModule` is the one writer
+ * that turns a model into an on-disk pgpm module (`.control` + `pgpm.plan` +
+ * deploy/revert/verify trees) — so `pgpm diff`, `pgpm transform`, and
+ * `pgpm import` all emit byte-identical module layouts instead of each
+ * carrying its own copy of the writer.
+ */
+import { PgpmRow } from '@pgpmjs/ast';
+/**
+ * A pgpm module as an in-memory value: a name, the extensions it requires
+ * (control-file names), and its changes in plan order. `writeModule` and the
+ * other projections (linear SQL, bundle) are pure functions of this model.
+ */
+export interface PgpmModuleModel {
+    /** Package (module) name. */
+    name: string;
+    /** Module names this package requires (control-file names). */
+    requires: string[];
+    /** Changes in plan order. */
+    rows: PgpmRow[];
+}
+/** Write a module's Postgres extension `.control` file. */
+export declare const writeControlFile: (dir: string, name: string, requires: string[]) => void;
+/**
+ * Write a {@link PgpmModuleModel} to `<outBase>/<name>` as a full pgpm module:
+ * a `.control` file, `pgpm.plan`, and deploy/revert/verify script trees.
+ * The deploy/revert/verify directories are cleared first so a re-emit never
+ * leaves stale scripts behind. Returns the module directory.
+ */
+export declare const writeModule: (outBase: string, model: PgpmModuleModel, extraRequires?: string[]) => string;
+/**
+ * Guard against clobbering: writing into the source directory requires
+ * `--write`, as does overwriting any existing package directory.
+ */
+export declare const checkOverwrite: (targetDir: string, sourcePath: string, write: boolean) => string | null;

package/module-emit.js

@@ -0,0 +1,104 @@
+"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.checkOverwrite = exports.writeModule = exports.writeControlFile = void 0;
+/**
+ * Module emission — the single seam every dials command renders through.
+ *
+ * The engine (semantic diff, granularity, partition) produces plan-ordered
+ * {@link PgpmRow}s; a {@link PgpmModuleModel} is just those rows plus the
+ * module's name and control-file requires. `writeModule` is the one writer
+ * that turns a model into an on-disk pgpm module (`.control` + `pgpm.plan` +
+ * deploy/revert/verify trees) — so `pgpm diff`, `pgpm transform`, and
+ * `pgpm import` all emit byte-identical module layouts instead of each
+ * carrying its own copy of the writer.
+ */
+const ast_1 = require("@pgpmjs/ast");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/** Write a module's Postgres extension `.control` file. */
+const writeControlFile = (dir, name, requires) => {
+    const lines = [
+        `# ${name} extension`,
+        `comment = '${name} extension'`,
+        `default_version = '0.0.1'`,
+        `relocatable = false`,
+        `superuser = false`
+    ];
+    if (requires.length) {
+        lines.push(`requires = '${requires.join(',')}'`);
+    }
+    fs.writeFileSync(path.join(dir, `${name}.control`), lines.join('\n') + '\n');
+};
+exports.writeControlFile = writeControlFile;
+/**
+ * Write a {@link PgpmModuleModel} to `<outBase>/<name>` as a full pgpm module:
+ * a `.control` file, `pgpm.plan`, and deploy/revert/verify script trees.
+ * The deploy/revert/verify directories are cleared first so a re-emit never
+ * leaves stale scripts behind. Returns the module directory.
+ */
+const writeModule = (outBase, model, extraRequires = []) => {
+    const dir = path.join(outBase, model.name);
+    fs.rmSync(path.join(dir, 'deploy'), { recursive: true, force: true });
+    fs.rmSync(path.join(dir, 'revert'), { recursive: true, force: true });
+    fs.rmSync(path.join(dir, 'verify'), { recursive: true, force: true });
+    fs.mkdirSync(dir, { recursive: true });
+    (0, exports.writeControlFile)(dir, model.name, [...extraRequires, ...model.requires]);
+    const opts = {
+        outdir: outBase,
+        name: model.name,
+        replacer: (str) => str.split('constructive-extension-name').join(model.name)
+    };
+    (0, ast_1.writePgpmPlan)(model.rows, opts);
+    (0, ast_1.writePgpmFiles)(model.rows, opts);
+    return dir;
+};
+exports.writeModule = writeModule;
+/**
+ * Guard against clobbering: writing into the source directory requires
+ * `--write`, as does overwriting any existing package directory.
+ */
+const checkOverwrite = (targetDir, sourcePath, write) => {
+    const resolvedTarget = path.resolve(targetDir);
+    const resolvedSource = path.resolve(sourcePath);
+    if (resolvedTarget === resolvedSource && !write) {
+        return `Refusing to overwrite the source module at ${resolvedSource} (pass --write to allow).`;
+    }
+    if (resolvedTarget !== resolvedSource && fs.existsSync(resolvedTarget) && !write) {
+        return `Output directory ${resolvedTarget} already exists (pass --write to overwrite).`;
+    }
+    return null;
+};
+exports.checkOverwrite = checkOverwrite;

package/module-source.d.ts

@@ -0,0 +1,33 @@
+/** One change of a loaded module: headerless, unwrapped deploy SQL. */
+export interface ModuleSourceChange {
+    /** Change name (plan token). */
+    name: string;
+    /** Change names this change requires, as recorded in the plan. */
+    dependencies: string[];
+    /** Deploy SQL with the pgpm header and BEGIN/COMMIT wrapper stripped. */
+    deploy: string;
+}
+/** A pgpm module loaded from disk, flattened in plan order. */
+export interface ModuleSource {
+    /** Module (project) name from pgpm.plan. */
+    name: string;
+    /** Absolute module directory. */
+    modulePath: string;
+    /** Changes in plan order. */
+    changes: ModuleSourceChange[];
+    /** Non-fatal notes (missing deploy scripts, etc.). */
+    warnings: string[];
+}
+/**
+ * Strip the transaction wrapper some modules carry inside their scripts
+ * (standalone `BEGIN;` / `COMMIT;` / `ROLLBACK;` lines). The caller owns
+ * transaction control.
+ */
+export declare const stripTransactionWrapper: (sql: string) => string;
+/**
+ * Load a pgpm module from disk: parse pgpm.plan and read each change's
+ * deploy script, stripping pgpm headers and transaction wrappers so the
+ * result can be flattened straight into the dials pipeline
+ * (`restructureChanges` / `partitionUnits`).
+ */
+export declare const loadModuleSource: (moduleDir: string) => ModuleSource;

package/module-source.js

@@ -0,0 +1,92 @@
+"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.loadModuleSource = exports.stripTransactionWrapper = void 0;
+/**
+ * Module ingestion for the dials pipeline: load an on-disk pgpm module into
+ * the flattened, classified change list the transform/partition drivers
+ * consume. `pgpm transform` uses this today; a future `pgpm import` (dumps)
+ * and `pgpm diff` are expected to reuse the same seam.
+ */
+const ast_1 = require("@pgpmjs/ast");
+const path = __importStar(require("path"));
+const TX_LINE = /^\s*(BEGIN|COMMIT|ROLLBACK)\s*;\s*$/i;
+/**
+ * Strip the transaction wrapper some modules carry inside their scripts
+ * (standalone `BEGIN;` / `COMMIT;` / `ROLLBACK;` lines). The caller owns
+ * transaction control.
+ */
+const stripTransactionWrapper = (sql) => sql
+    .split('\n')
+    .filter(line => !TX_LINE.test(line))
+    .join('\n')
+    .trim();
+exports.stripTransactionWrapper = stripTransactionWrapper;
+/**
+ * Load a pgpm module from disk: parse pgpm.plan and read each change's
+ * deploy script, stripping pgpm headers and transaction wrappers so the
+ * result can be flattened straight into the dials pipeline
+ * (`restructureChanges` / `partitionUnits`).
+ */
+const loadModuleSource = (moduleDir) => {
+    const modulePath = path.resolve(moduleDir);
+    const planResult = (0, ast_1.parsePlanFile)(path.join(modulePath, 'pgpm.plan'));
+    if (!planResult.data) {
+        const reasons = planResult.errors.map(e => e.message).join(', ');
+        throw new Error(`Failed to parse pgpm.plan in ${modulePath}: ${reasons}`);
+    }
+    const warnings = [];
+    const changes = [];
+    for (const change of planResult.data.changes) {
+        const raw = (0, ast_1.readScript)(modulePath, 'deploy', change.name);
+        if (!raw) {
+            warnings.push(`${change.name}: no deploy script found, skipping`);
+            continue;
+        }
+        const { body } = (0, ast_1.parsePgpmHeader)(raw);
+        changes.push({
+            name: change.name,
+            dependencies: change.dependencies ?? [],
+            deploy: (0, exports.stripTransactionWrapper)(body)
+        });
+    }
+    return {
+        name: planResult.data.package,
+        modulePath,
+        changes,
+        warnings
+    };
+};
+exports.loadModuleSource = loadModuleSource;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgpmjs/transform",
-  "version": "0.17.0",
+  "version": "0.19.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "Change-aware SQL transformation for PGPM — superset of @pgsql/transform plus change categorization, fixture closure, and bundle transpile/apply drivers",
   "main": "index.js",
@@ -39,14 +39,15 @@
     "plpgsql"
   ],
   "devDependencies": {
-    "@pgpmjs/bundle": "^0.13.2",
+    "@pgpmjs/bundle": "^0.13.3",
     "makage": "^0.3.0"
   },
   "dependencies": {
+    "@pgpmjs/ast": "^0.10.3",
     "@pgpmjs/naming-spec": "^0.1.2",
-    "@pgsql/scripts": "^18.1.0",
-    "@pgsql/transform": "^18.11.0",
-    "plpgsql-parser": "^18.2.3"
+    "@pgsql/scripts": "^18.3.1",
+    "@pgsql/transform": "^18.14.1",
+    "plpgsql-parser": "^18.5.1"
   },
-  "gitHead": "45cd961cf956d2d28e4d09b20db4204982c33593"
+  "gitHead": "c20b6be96b39bf71c0e2df0f4b51e05deacd006b"
 }

package/partition.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Partition dial wiring shared by `pgpm transform --partition` and
+ * `pgpm export --partition`: parse a partition config file, run
+ * `partitionUnits` (`@pgpmjs/transform`), and lift the emitted packages back
+ * onto the PgpmRow seam with generated revert/verify per change.
+ */
+import { PgpmRow } from '@pgpmjs/ast';
+import { PartitionConfig } from './partition-driver';
+export type { PartitionConfig } from './partition-driver';
+/**
+ * Parse and validate a partition config file (JSON matching
+ * `PartitionConfig`: rules, defaultPackage, optional style/splitRiders).
+ * Throws with a message naming the offending field.
+ */
+export declare const parsePartitionConfig: (filePath: string) => PartitionConfig;
+/** One partitioned package on the PgpmRow seam, ready to write to disk. */
+export interface PartitionedPackageRows {
+    name: string;
+    /** Package names this package requires (cross-package edges). */
+    requires: string[];
+    rows: PgpmRow[];
+}
+export interface PartitionExportRowsResult {
+    packages: PartitionedPackageRows[];
+    warnings: string[];
+}
+/**
+ * Partition changes into packages and generate revert/verify for every
+ * emitted change. Cross-package dependencies keep the `<pkg>:<path>`
+ * convention in `deps`. May throw `PartitionCycleError`.
+ */
+export declare const partitionExportRows: (rows: PgpmRow[], config: PartitionConfig) => Promise<PartitionExportRowsResult>;