@pgpmjs/transform 0.17.0 → 0.18.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';
@@ -252,17 +255,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgpmjs/transform",
-  "version": "0.17.0",
+  "version": "0.18.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",
@@ -48,5 +48,5 @@
     "@pgsql/transform": "^18.11.0",
     "plpgsql-parser": "^18.2.3"
   },
-  "gitHead": "45cd961cf956d2d28e4d09b20db4204982c33593"
+  "gitHead": "6d3e25dc5c9f93421dba49ddedf93239f87213a8"
 }

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.
  */
@@ -256,17 +259,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);