@pgpmjs/transform 0.17.0 → 0.19.0

package/partition.js

@@ -0,0 +1,127 @@
+"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.partitionExportRows = exports.parsePartitionConfig = void 0;
+const fs = __importStar(require("fs"));
+const plpgsql_parser_1 = require("plpgsql-parser");
+const partition_driver_1 = require("./partition-driver");
+const regen_1 = require("./regen");
+const PATH_STYLES = ['directory', 'flat'];
+/**
+ * Parse and validate a partition config file (JSON matching
+ * `PartitionConfig`: rules, defaultPackage, optional style/splitRiders).
+ * Throws with a message naming the offending field.
+ */
+const parsePartitionConfig = (filePath) => {
+    let raw;
+    try {
+        raw = fs.readFileSync(filePath, 'utf-8');
+    }
+    catch {
+        throw new Error(`Partition config not found: ${filePath}`);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (err) {
+        throw new Error(`Partition config is not valid JSON (${filePath}): ${err?.message ?? err}`);
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`Partition config must be a JSON object (${filePath})`);
+    }
+    if (typeof parsed.defaultPackage !== 'string' || !parsed.defaultPackage) {
+        throw new Error('Partition config: "defaultPackage" must be a non-empty string');
+    }
+    if (!Array.isArray(parsed.rules)) {
+        throw new Error('Partition config: "rules" must be an array');
+    }
+    parsed.rules.forEach((rule, i) => {
+        if (typeof rule !== 'object' || rule === null) {
+            throw new Error(`Partition config: rules[${i}] must be an object`);
+        }
+        if (typeof rule.package !== 'string' || !rule.package) {
+            throw new Error(`Partition config: rules[${i}].package must be a non-empty string`);
+        }
+        if (!Array.isArray(rule.select) || rule.select.length === 0) {
+            throw new Error(`Partition config: rules[${i}].select must be a non-empty array of selectors`);
+        }
+    });
+    if (parsed.style !== undefined && !PATH_STYLES.includes(parsed.style)) {
+        throw new Error(`Partition config: "style" must be one of: ${PATH_STYLES.join(', ')}`);
+    }
+    if (parsed.splitRiders !== undefined && !Array.isArray(parsed.splitRiders)) {
+        throw new Error('Partition config: "splitRiders" must be an array of statement kinds');
+    }
+    return parsed;
+};
+exports.parsePartitionConfig = parsePartitionConfig;
+/**
+ * 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`.
+ */
+const partitionExportRows = async (rows, config) => {
+    await (0, plpgsql_parser_1.loadModule)();
+    const input = rows.map(row => ({
+        name: row.deploy,
+        dependencies: row.deps ?? [],
+        deploy: row.content
+    }));
+    const { packages, warnings } = (0, partition_driver_1.partitionUnits)(input, config);
+    const result = packages.map(pkg => ({
+        name: pkg.name,
+        requires: pkg.requires,
+        rows: pkg.changes.map(change => {
+            const scripts = (0, regen_1.regenerateScripts)(change.deploy);
+            for (const warning of scripts.revert.warnings) {
+                warnings.push(`${pkg.name}:${change.name}: ${warning}`);
+            }
+            for (const warning of scripts.verify.warnings) {
+                warnings.push(`${pkg.name}:${change.name}: ${warning}`);
+            }
+            return {
+                name: change.name,
+                deploy: change.name,
+                deps: change.dependencies,
+                content: change.deploy,
+                revert: scripts.revert.sql,
+                verify: scripts.verify.sql
+            };
+        })
+    }));
+    return { packages: result, warnings };
+};
+exports.partitionExportRows = partitionExportRows;

package/restructure.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Granularity dial for `pgpm export`: route exported sql_actions rows through
+ * the dials pipeline (`restructureChanges` in `@pgpmjs/transform`) so change
+ * paths are derived from the naming spec (`identityOf` + `pathFor`) and
+ * `requires` come from the statement dependency graph instead of the
+ * hand-chained deps recorded at action time.
+ */
+import { PgpmRow } from '@pgpmjs/ast';
+import { PathStyle } from '@pgpmjs/naming-spec';
+import { Granularity } from '@pgsql/transform';
+export type ExportGranularity = Granularity;
+export declare const EXPORT_GRANULARITIES: readonly ExportGranularity[];
+export declare const isExportGranularity: (value: unknown) => value is ExportGranularity;
+export interface RestructureExportRowsResult {
+    rows: PgpmRow[];
+    warnings: string[];
+}
+export interface RestructureExportRowsOptions {
+    /** Naming-spec rendering style for derived paths (default `directory`). */
+    naming?: PathStyle;
+}
+/**
+ * Restructure exported migration rows to the target granularity.
+ *
+ * The rows' deploy SQL is flattened in export order, restructured, and
+ * re-sliced into per-object changes whose paths come from the naming spec and
+ * whose deps come from the statement graph. When two changes derive the same
+ * path (the same object altered again), later occurrences get the spec's
+ * alteration convention via `alterationPathFor` (monotonic per-parent
+ * counter), with the parent added to their deps.
+ *
+ * Revert/verify scripts are not carried through from the original rows (the
+ * restructured grouping no longer matches them one-to-one); instead each
+ * change gets scripts generated from its own statements via
+ * `revertFor`/`verifyFor` (drops in reverse topological order, one existence
+ * check per created object).
+ */
+export declare const restructureExportRows: (rows: PgpmRow[], granularity: ExportGranularity, options?: RestructureExportRowsOptions) => Promise<RestructureExportRowsResult>;

package/restructure.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.restructureExportRows = exports.isExportGranularity = exports.EXPORT_GRANULARITIES = void 0;
+const naming_spec_1 = require("@pgpmjs/naming-spec");
+const transform_1 = require("@pgsql/transform");
+const plpgsql_parser_1 = require("plpgsql-parser");
+const granularity_driver_1 = require("./granularity-driver");
+exports.EXPORT_GRANULARITIES = ['atomic', 'object', 'consolidated'];
+const isExportGranularity = (value) => typeof value === 'string' && exports.EXPORT_GRANULARITIES.includes(value);
+exports.isExportGranularity = isExportGranularity;
+/**
+ * Restructure exported migration rows to the target granularity.
+ *
+ * The rows' deploy SQL is flattened in export order, restructured, and
+ * re-sliced into per-object changes whose paths come from the naming spec and
+ * whose deps come from the statement graph. When two changes derive the same
+ * path (the same object altered again), later occurrences get the spec's
+ * alteration convention via `alterationPathFor` (monotonic per-parent
+ * counter), with the parent added to their deps.
+ *
+ * Revert/verify scripts are not carried through from the original rows (the
+ * restructured grouping no longer matches them one-to-one); instead each
+ * change gets scripts generated from its own statements via
+ * `revertFor`/`verifyFor` (drops in reverse topological order, one existence
+ * check per created object).
+ */
+const restructureExportRows = async (rows, granularity, options = {}) => {
+    await (0, plpgsql_parser_1.loadModule)();
+    const style = options.naming ?? 'directory';
+    const changeName = (facts) => {
+        const identity = (0, transform_1.identityOf)(facts);
+        if (identity)
+            return (0, naming_spec_1.pathFor)(identity, { style });
+        return 'misc/statements';
+    };
+    const { changes, warnings } = (0, granularity_driver_1.restructureChanges)(rows.map(row => ({
+        name: row.deploy,
+        dependencies: row.deps ?? [],
+        deploy: row.content
+    })), { granularity, changeName });
+    const counters = new Map();
+    const taken = new Set();
+    const restructured = changes.map(change => {
+        let deploy = change.name;
+        const deps = [...change.dependencies];
+        if (taken.has(deploy)) {
+            let n = (counters.get(change.name) ?? 0) + 1;
+            while (taken.has((0, naming_spec_1.alterationPathFor)(change.name, n)))
+                n++;
+            counters.set(change.name, n);
+            deploy = (0, naming_spec_1.alterationPathFor)(change.name, n);
+            if (!deps.includes(change.name))
+                deps.push(change.name);
+        }
+        taken.add(deploy);
+        return {
+            name: deploy,
+            deploy,
+            deps,
+            content: change.deploy,
+            revert: change.revert,
+            verify: change.verify
+        };
+    });
+    return { rows: restructured, warnings };
+};
+exports.restructureExportRows = restructureExportRows;

package/semantic-diff-driver.d.ts

@@ -16,10 +16,13 @@
  * 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.
  */

package/semantic-diff-driver.js

@@ -20,10 +20,13 @@ exports.diffChangeSets = diffChangeSets;
  * 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.
  */
@@ -211,32 +214,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;
 }
 /**
@@ -256,17 +273,46 @@ 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 } = (0, scripts_1.revertFor)((0, transform_1.classifyStatements)(deploy));
-        warnings.push(...w.map(x => `${context}: ${x}`));
-        return sql;
+        const facts = (0, transform_1.classifyStatements)(deploy);
+        const graph = (0, transform_1.buildStatementGraph)(facts);
+        const pieces = [];
+        for (const i of [...graph.order].reverse()) {
+            const nodes = (0, scripts_1.invertStatement)(facts[i]);
+            if (nodes === null) {
+                const { sql, warnings: w } = (0, scripts_1.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 } = (0, scripts_1.verifyFor)((0, transform_1.classifyStatements)(deploy));
-        warnings.push(...w.map(x => `${context}: ${x}`));
-        return sql;
+        const pieces = [];
+        for (const fact of (0, transform_1.classifyStatements)(deploy)) {
+            const nodes = (0, scripts_1.existenceCheck)(fact);
+            if (nodes === null) {
+                const { warnings: w } = (0, scripts_1.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);