@pgpmjs/transform 0.12.0 → 0.13.0

package/esm/index.js

@@ -3,3 +3,4 @@ export { loadModule } from 'plpgsql-parser';
 export { buildExtensionRouter, buildSchemaRouter, makeNamespaceValidator, makeSchemaTranspiler, } from './bundle-driver';
 export { buildCategoryOf, categorizeChange, TIER_PROFILE, } from './categorize';
 export { resolveFixtureClosure } from './fixture-closure';
+export { emitSqlProgram, parseSqlProgram } from './program';

package/esm/program.js

@@ -0,0 +1,49 @@
+import { classifyStatements } from '@pgsql/transform';
+import { Deparser, parseSql } from 'plpgsql-parser';
+/**
+ * Parse a SQL script into a statement program. Requires `loadModule()` from
+ * `plpgsql-parser` to have completed.
+ */
+export function parseSqlProgram(source) {
+    const parseResult = parseSql(source);
+    const stmts = parseResult?.stmts ?? [];
+    const facts = classifyStatements(source);
+    const statements = [];
+    for (let i = 0; i < stmts.length; i++) {
+        const rawStmt = stmts[i];
+        if (!rawStmt?.stmt)
+            continue;
+        const { start, len } = facts[i].span;
+        statements.push({
+            stmt: rawStmt.stmt,
+            facts: facts[i],
+            span: { start, len },
+            raw: source.slice(start, start + len),
+            dirty: false
+        });
+    }
+    return { source, statements };
+}
+/**
+ * Emit a program back to SQL. Clean statements — and every byte between
+ * statements — are copied verbatim from the source; dirty statements are
+ * re-printed through the deparser. With no dirty statements the output is
+ * byte-identical to the source.
+ */
+export function emitSqlProgram(program) {
+    const { source, statements } = program;
+    if (!statements.some(s => s.dirty))
+        return source;
+    const pieces = [];
+    let cursor = 0;
+    for (const statement of statements) {
+        const { start, len } = statement.span;
+        if (start > cursor)
+            pieces.push(source.slice(cursor, start));
+        pieces.push(statement.dirty ? Deparser.deparse(statement.stmt) : source.slice(start, start + len));
+        cursor = start + len;
+    }
+    if (cursor < source.length)
+        pieces.push(source.slice(cursor));
+    return pieces.join('');
+}

package/index.d.ts

@@ -6,3 +6,5 @@ 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 { SqlProgram, SqlStatementAst, SqlStatementSpan, } from './program';
+export { emitSqlProgram, parseSqlProgram } from './program';

package/index.js

@@ -14,7 +14,7 @@ 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.resolveFixtureClosure = exports.TIER_PROFILE = exports.categorizeChange = exports.buildCategoryOf = exports.makeSchemaTranspiler = exports.makeNamespaceValidator = exports.buildSchemaRouter = exports.buildExtensionRouter = exports.loadModule = void 0;
+exports.parseSqlProgram = exports.emitSqlProgram = exports.resolveFixtureClosure = exports.TIER_PROFILE = exports.categorizeChange = exports.buildCategoryOf = 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; } });
@@ -29,3 +29,6 @@ Object.defineProperty(exports, "categorizeChange", { enumerable: true, get: func
 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; } });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgpmjs/transform",
-  "version": "0.12.0",
+  "version": "0.13.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,12 +39,12 @@
     "plpgsql"
   ],
   "devDependencies": {
-    "@pgpmjs/bundle": "^0.12.2",
+    "@pgpmjs/bundle": "^0.12.4",
     "makage": "^0.3.0"
   },
   "dependencies": {
-    "@pgsql/transform": "^18.7.0",
-    "plpgsql-parser": "^18.2.1"
+    "@pgsql/transform": "^18.8.0",
+    "plpgsql-parser": "^18.2.2"
   },
-  "gitHead": "2832d5632d11eb22e1437df773706ac6a99175fe"
+  "gitHead": "04b34ce4b5efcebfd8e49d64d196e651288d97f3"
 }

package/program.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Statement-level SQL program AST.
+ *
+ * A `SqlProgram` is one parse of a SQL script into per-statement units, each
+ * carrying its parsed node, semantic facts, source span, verbatim text, and a
+ * dirty flag. Transformations mutate a statement's `stmt` node and mark it
+ * dirty; emission re-prints only dirty statements through the deparser and
+ * copies every other byte of the script verbatim (comments, whitespace,
+ * untouched statements). A program with no dirty statements emits its source
+ * byte-identically, so content-addressed hashes are preserved.
+ */
+import type { StatementFacts } from '@pgsql/transform';
+/** A statement's location in the source script (byte offsets). */
+export type SqlStatementSpan = StatementFacts['span'];
+/** One statement of a parsed SQL script. */
+export interface SqlStatementAst {
+    /** The tagged statement node (e.g. `{ CreateStmt: {...} }`), mutable. */
+    stmt: any;
+    /** Semantic facts classified from the statement. */
+    facts: StatementFacts;
+    /** Source span within the program's `source`. */
+    span: SqlStatementSpan;
+    /** Verbatim source text of the statement (`source.slice(start, start+len)`). */
+    raw: string;
+    /** Whether the statement's AST has been mutated and must be deparsed. */
+    dirty: boolean;
+}
+/** A SQL script parsed once into statement units. */
+export interface SqlProgram {
+    source: string;
+    statements: SqlStatementAst[];
+}
+/**
+ * Parse a SQL script into a statement program. Requires `loadModule()` from
+ * `plpgsql-parser` to have completed.
+ */
+export declare function parseSqlProgram(source: string): SqlProgram;
+/**
+ * Emit a program back to SQL. Clean statements — and every byte between
+ * statements — are copied verbatim from the source; dirty statements are
+ * re-printed through the deparser. With no dirty statements the output is
+ * byte-identical to the source.
+ */
+export declare function emitSqlProgram(program: SqlProgram): string;

package/program.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSqlProgram = parseSqlProgram;
+exports.emitSqlProgram = emitSqlProgram;
+const transform_1 = require("@pgsql/transform");
+const plpgsql_parser_1 = require("plpgsql-parser");
+/**
+ * Parse a SQL script into a statement program. Requires `loadModule()` from
+ * `plpgsql-parser` to have completed.
+ */
+function parseSqlProgram(source) {
+    const parseResult = (0, plpgsql_parser_1.parseSql)(source);
+    const stmts = parseResult?.stmts ?? [];
+    const facts = (0, transform_1.classifyStatements)(source);
+    const statements = [];
+    for (let i = 0; i < stmts.length; i++) {
+        const rawStmt = stmts[i];
+        if (!rawStmt?.stmt)
+            continue;
+        const { start, len } = facts[i].span;
+        statements.push({
+            stmt: rawStmt.stmt,
+            facts: facts[i],
+            span: { start, len },
+            raw: source.slice(start, start + len),
+            dirty: false
+        });
+    }
+    return { source, statements };
+}
+/**
+ * Emit a program back to SQL. Clean statements — and every byte between
+ * statements — are copied verbatim from the source; dirty statements are
+ * re-printed through the deparser. With no dirty statements the output is
+ * byte-identical to the source.
+ */
+function emitSqlProgram(program) {
+    const { source, statements } = program;
+    if (!statements.some(s => s.dirty))
+        return source;
+    const pieces = [];
+    let cursor = 0;
+    for (const statement of statements) {
+        const { start, len } = statement.span;
+        if (start > cursor)
+            pieces.push(source.slice(cursor, start));
+        pieces.push(statement.dirty ? plpgsql_parser_1.Deparser.deparse(statement.stmt) : source.slice(start, start + len));
+        cursor = start + len;
+    }
+    if (cursor < source.length)
+        pieces.push(source.slice(cursor));
+    return pieces.join('');
+}