@pgpmjs/ast 0.1.0

package/files/sql-scripts/index.js

@@ -0,0 +1,18 @@
+"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 __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 });
+// Re-export all sql-scripts functionality
+__exportStar(require("./reader"), exports);

package/files/sql-scripts/reader.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Read a SQL script file, return empty string if not found
+ */
+export declare function readScript(basePath: string, scriptType: string, changeName: string): string;
+/**
+ * Check if a script file exists
+ */
+export declare function scriptExists(basePath: string, scriptType: string, changeName: string): boolean;

package/files/sql-scripts/reader.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readScript = readScript;
+exports.scriptExists = scriptExists;
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * Read a SQL script file, return empty string if not found
+ */
+function readScript(basePath, scriptType, changeName) {
+    const scriptPath = (0, path_1.join)(basePath, scriptType, `${changeName}.sql`);
+    if (!(0, fs_1.existsSync)(scriptPath)) {
+        return '';
+    }
+    return (0, fs_1.readFileSync)(scriptPath, 'utf-8');
+}
+/**
+ * Check if a script file exists
+ */
+function scriptExists(basePath, scriptType, changeName) {
+    const scriptPath = (0, path_1.join)(basePath, scriptType, `${changeName}.sql`);
+    return (0, fs_1.existsSync)(scriptPath);
+}

package/files/types/index.d.ts

@@ -0,0 +1,46 @@
+export * from './package';
+export interface Change {
+    name: string;
+    dependencies: string[];
+    timestamp?: string;
+    planner?: string;
+    email?: string;
+    comment?: string;
+}
+export interface PlanFile {
+    package: string;
+    uri?: string;
+    changes: Change[];
+}
+export interface Tag {
+    name: string;
+    change: string;
+    timestamp?: string;
+    planner?: string;
+    email?: string;
+    comment?: string;
+}
+export interface ExtendedPlanFile extends PlanFile {
+    tags: Tag[];
+}
+export interface ParseError {
+    line: number;
+    message: string;
+}
+export interface ParseResult<T> {
+    data?: T;
+    errors: ParseError[];
+}
+export interface ResolvedReference {
+    type: 'change' | 'tag' | 'sha1' | 'relative';
+    target: string;
+    resolved?: string;
+}
+export interface PgpmRow {
+    deploy: string;
+    revert?: string;
+    verify?: string;
+    content: string;
+    deps?: string[];
+    name?: string;
+}

package/files/types/index.js

@@ -0,0 +1,17 @@
+"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 __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 });
+__exportStar(require("./package"), exports);

package/files/types/package.d.ts

@@ -0,0 +1,20 @@
+export interface PackageAnalysisIssue {
+    code: string;
+    message: string;
+    file?: string;
+    fixable?: boolean;
+}
+export interface PackageAnalysisResult {
+    ok: boolean;
+    name: string;
+    path: string;
+    issues: PackageAnalysisIssue[];
+}
+export interface RenameOptions {
+    dryRun?: boolean;
+    syncPackageJsonName?: boolean;
+}
+export interface RenameResult {
+    changed: string[];
+    warnings: string[];
+}

package/files/types/package.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/hash.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Generate a SHA256 hash (hex) of a string. Pure content-addressing primitive
+ * shared by the bundle layer and core; kept here so the artifact layer has a
+ * dependency-free hash without reaching into core.
+ */
+export declare function hashString(content: string): string;

package/hash.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hashString = hashString;
+const crypto_1 = require("crypto");
+/**
+ * Generate a SHA256 hash (hex) of a string. Pure content-addressing primitive
+ * shared by the bundle layer and core; kept here so the artifact layer has a
+ * dependency-free hash without reaching into core.
+ */
+function hashString(content) {
+    return (0, crypto_1.createHash)('sha256').update(content).digest('hex');
+}

package/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * @pgpmjs/ast — the pgpm module AST layer.
+ *
+ * Two things live here:
+ *   - `files/*` — the low-level file parsers/writers (plan, control, SQL header,
+ *     scripts) and their types. These are the primitives everything else composes.
+ *   - `module/*` — the unified {@link PgpmModuleAst}: `readModule`/`writeModule`
+ *     (parse/deparse a whole pgpm module) built by composing the `files/*` parsers,
+ *     lossless round-trip.
+ *
+ * This package is a pure leaf (no DB, no deploy engine); `@pgpmjs/core` and the
+ * bundle/artifact layer build on top of it.
+ */
+export * from './files';
+export * from './hash';
+export * from './module';
+export * from './plan-rename';
+export { parseAuthor } from './utils/author';
+export type { ParsedAuthor } from './utils/author';

package/index.js

@@ -0,0 +1,36 @@
+"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 __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.parseAuthor = void 0;
+/**
+ * @pgpmjs/ast — the pgpm module AST layer.
+ *
+ * Two things live here:
+ *   - `files/*` — the low-level file parsers/writers (plan, control, SQL header,
+ *     scripts) and their types. These are the primitives everything else composes.
+ *   - `module/*` — the unified {@link PgpmModuleAst}: `readModule`/`writeModule`
+ *     (parse/deparse a whole pgpm module) built by composing the `files/*` parsers,
+ *     lossless round-trip.
+ *
+ * This package is a pure leaf (no DB, no deploy engine); `@pgpmjs/core` and the
+ * bundle/artifact layer build on top of it.
+ */
+__exportStar(require("./files"), exports);
+__exportStar(require("./hash"), exports);
+__exportStar(require("./module"), exports);
+__exportStar(require("./plan-rename"), exports);
+var author_1 = require("./utils/author");
+Object.defineProperty(exports, "parseAuthor", { enumerable: true, get: function () { return author_1.parseAuthor; } });

package/module/index.d.ts

@@ -0,0 +1,12 @@
+/**
+ * pgpm-ast: the unified in-memory AST for pgpm modules ("AST for the migrations").
+ *
+ * Composes the existing file-level parsers (plan, control, SQL header) into a
+ * single typed {@link PgpmModuleAst} object that operators transform, then writes
+ * it back losslessly.
+ */
+export * from './parse';
+export * from './reader';
+export * from './roundtrip';
+export * from './types';
+export * from './writer';

package/module/index.js

@@ -0,0 +1,28 @@
+"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 __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 });
+/**
+ * pgpm-ast: the unified in-memory AST for pgpm modules ("AST for the migrations").
+ *
+ * Composes the existing file-level parsers (plan, control, SQL header) into a
+ * single typed {@link PgpmModuleAst} object that operators transform, then writes
+ * it back losslessly.
+ */
+__exportStar(require("./parse"), exports);
+__exportStar(require("./reader"), exports);
+__exportStar(require("./roundtrip"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./writer"), exports);

package/module/parse.d.ts

@@ -0,0 +1,23 @@
+import { PgpmModuleAst } from './types';
+import { WriteModuleOptions } from './writer';
+/**
+ * Parse a pgpm module directory into a {@link PgpmModuleAst}.
+ *
+ * The module-level analog of `pgsql-parser`'s `parse()`: where that turns SQL
+ * text into a PostgreSQL AST, this turns an on-disk pgpm module (plan + control
+ * + deploy/revert/verify scripts) into a single typed tree. Alias of
+ * {@link readModule}; the inverse of {@link deparseModule}.
+ */
+export declare function parseModule(dir: string): PgpmModuleAst;
+/**
+ * Deparse a {@link PgpmModuleAst} back to an on-disk pgpm module.
+ *
+ * The module-level analog of `pgsql-deparser`'s `deparse()`. With the default
+ * `fromRaw: true` it is lossless (byte-exact round-trip of {@link parseModule});
+ * with `fromRaw: false` it re-serializes the structured model, for operators
+ * that mutate the AST first. Alias of {@link writeModule}.
+ *
+ * For in-memory deparse-to-string of individual parts, use `serializePlan` /
+ * `serializeScript`.
+ */
+export declare function deparseModule(module: PgpmModuleAst, options?: WriteModuleOptions): void;

package/module/parse.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseModule = parseModule;
+exports.deparseModule = deparseModule;
+const reader_1 = require("./reader");
+const writer_1 = require("./writer");
+/**
+ * Parse a pgpm module directory into a {@link PgpmModuleAst}.
+ *
+ * The module-level analog of `pgsql-parser`'s `parse()`: where that turns SQL
+ * text into a PostgreSQL AST, this turns an on-disk pgpm module (plan + control
+ * + deploy/revert/verify scripts) into a single typed tree. Alias of
+ * {@link readModule}; the inverse of {@link deparseModule}.
+ */
+function parseModule(dir) {
+    return (0, reader_1.readModule)(dir);
+}
+/**
+ * Deparse a {@link PgpmModuleAst} back to an on-disk pgpm module.
+ *
+ * The module-level analog of `pgsql-deparser`'s `deparse()`. With the default
+ * `fromRaw: true` it is lossless (byte-exact round-trip of {@link parseModule});
+ * with `fromRaw: false` it re-serializes the structured model, for operators
+ * that mutate the AST first. Alias of {@link writeModule}.
+ *
+ * For in-memory deparse-to-string of individual parts, use `serializePlan` /
+ * `serializeScript`.
+ */
+function deparseModule(module, options = {}) {
+    (0, writer_1.writeModule)(module, options);
+}

package/module/reader.d.ts

@@ -0,0 +1,13 @@
+import { PgpmModuleAst } from './types';
+/**
+ * Read a pgpm module directory into the unified {@link PgpmModuleAst}.
+ *
+ * Composes the existing plan parser, control reader, and SQL header parser — it
+ * does not re-implement any parsing. The module is addressed by plan order: the
+ * `changes` array follows `pgpm.plan`, and each change eagerly parses its
+ * deploy/revert/verify scripts (missing ones are `null`). Every leaf retains its
+ * byte-exact source so {@link writeModule} can reproduce the module losslessly.
+ *
+ * @throws when `dir` has no `pgpm.plan`, or the plan fails to parse.
+ */
+export declare function readModule(dir: string): PgpmModuleAst;

package/module/reader.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readModule = readModule;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const reader_1 = require("../files/extension/reader");
+const parser_1 = require("../files/plan/parser");
+const header_1 = require("../files/sql/header");
+const reader_2 = require("../files/sql-scripts/reader");
+function readScriptAst(dir, kind, change) {
+    if (!(0, reader_2.scriptExists)(dir, kind, change))
+        return null;
+    const raw = (0, reader_2.readScript)(dir, kind, change);
+    const { header, body } = (0, header_1.parsePgpmHeader)(raw);
+    return { kind, header, body, raw };
+}
+/**
+ * Read a pgpm module directory into the unified {@link PgpmModuleAst}.
+ *
+ * Composes the existing plan parser, control reader, and SQL header parser — it
+ * does not re-implement any parsing. The module is addressed by plan order: the
+ * `changes` array follows `pgpm.plan`, and each change eagerly parses its
+ * deploy/revert/verify scripts (missing ones are `null`). Every leaf retains its
+ * byte-exact source so {@link writeModule} can reproduce the module losslessly.
+ *
+ * @throws when `dir` has no `pgpm.plan`, or the plan fails to parse.
+ */
+function readModule(dir) {
+    const planPath = (0, path_1.join)(dir, 'pgpm.plan');
+    if (!(0, fs_1.existsSync)(planPath)) {
+        throw new Error(`No pgpm.plan found in module directory: ${dir}`);
+    }
+    const planRaw = (0, fs_1.readFileSync)(planPath, 'utf-8');
+    const parsed = (0, parser_1.parsePlanFile)(planPath);
+    if (!parsed.data) {
+        const detail = parsed.errors
+            .map(e => `line ${e.line}: ${e.message}`)
+            .join('; ');
+        throw new Error(`Failed to parse plan file ${planPath}: ${detail}`);
+    }
+    const plan = parsed.data;
+    const name = plan.package;
+    let control = null;
+    if (name) {
+        const fileName = `${name}.control`;
+        const controlPath = (0, path_1.join)(dir, fileName);
+        if ((0, fs_1.existsSync)(controlPath)) {
+            const raw = (0, fs_1.readFileSync)(controlPath, 'utf-8');
+            const info = (0, reader_1.parseControlFile)(controlPath, dir);
+            control = {
+                fileName,
+                name,
+                requires: info.requires,
+                version: info.version,
+                raw
+            };
+        }
+    }
+    const changes = plan.changes.map(planChange => ({
+        name: planChange.name,
+        plan: planChange,
+        deploy: readScriptAst(dir, 'deploy', planChange.name),
+        revert: readScriptAst(dir, 'revert', planChange.name),
+        verify: readScriptAst(dir, 'verify', planChange.name)
+    }));
+    return { dir, name, plan, planRaw, control, changes };
+}

package/module/roundtrip.d.ts

@@ -0,0 +1,22 @@
+/**
+ * A single discrepancy found by {@link verifyModuleRoundTrip}.
+ */
+export interface RoundTripIssue {
+    kind: 'script-drift' | 'plan-drift' | 'change-count' | 'change-identity';
+    change?: string;
+    script?: string;
+    message: string;
+}
+/**
+ * Read-only invariant check for the module AST: proves a module survives a
+ * read → serialize → re-read cycle without drifting.
+ *
+ * Guarantees checked:
+ *   - every script serializes byte-identically to its source (the SQL header
+ *     parser is lossless), and
+ *   - the plan serialization is idempotent and the structured change set is
+ *     stable across a serialize → re-read round trip.
+ *
+ * Returns the issues found rather than throwing.
+ */
+export declare function verifyModuleRoundTrip(dir: string): RoundTripIssue[];

package/module/roundtrip.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyModuleRoundTrip = verifyModuleRoundTrip;
+const fs_1 = require("fs");
+const os_1 = require("os");
+const path_1 = require("path");
+const reader_1 = require("./reader");
+const writer_1 = require("./writer");
+/**
+ * Read-only invariant check for the module AST: proves a module survives a
+ * read → serialize → re-read cycle without drifting.
+ *
+ * Guarantees checked:
+ *   - every script serializes byte-identically to its source (the SQL header
+ *     parser is lossless), and
+ *   - the plan serialization is idempotent and the structured change set is
+ *     stable across a serialize → re-read round trip.
+ *
+ * Returns the issues found rather than throwing.
+ */
+function verifyModuleRoundTrip(dir) {
+    const issues = [];
+    const module = (0, reader_1.readModule)(dir);
+    for (const change of module.changes) {
+        for (const script of [change.deploy, change.revert, change.verify]) {
+            if (!script)
+                continue;
+            if ((0, writer_1.serializeScript)(script) !== script.raw) {
+                issues.push({
+                    kind: 'script-drift',
+                    change: change.name,
+                    script: script.kind,
+                    message: 'header serialize is not byte-identical to source'
+                });
+            }
+        }
+    }
+    const planOnce = (0, writer_1.serializePlan)(module);
+    const tmp = (0, fs_1.mkdtempSync)((0, path_1.join)((0, os_1.tmpdir)(), 'pgpm-ast-rt-'));
+    try {
+        (0, writer_1.writeModule)(module, { outDir: tmp, fromRaw: false });
+        const reread = (0, reader_1.readModule)(tmp);
+        if ((0, writer_1.serializePlan)(reread) !== planOnce) {
+            issues.push({ kind: 'plan-drift', message: 'plan serialization is not idempotent' });
+        }
+        if (reread.changes.length !== module.changes.length) {
+            issues.push({
+                kind: 'change-count',
+                message: `change count drifted: ${module.changes.length} -> ${reread.changes.length}`
+            });
+        }
+        else {
+            for (let i = 0; i < module.changes.length; i++) {
+                if (reread.changes[i].name !== module.changes[i].name) {
+                    issues.push({
+                        kind: 'change-identity',
+                        change: module.changes[i].name,
+                        message: `change at index ${i} drifted to "${reread.changes[i].name}"`
+                    });
+                }
+            }
+        }
+    }
+    finally {
+        (0, fs_1.rmSync)(tmp, { recursive: true, force: true });
+    }
+    return issues;
+}

package/module/types.d.ts

@@ -0,0 +1,72 @@
+import { PgpmHeader } from '../files/sql/header';
+import { Change, ExtendedPlanFile } from '../files/types';
+/**
+ * The three script directions a pgpm change is materialized into on disk.
+ */
+export type PgpmScriptKind = 'deploy' | 'revert' | 'verify';
+/**
+ * The parsed AST of a single pgpm SQL script (one of deploy/revert/verify for a
+ * change). Carries the structured header (verb/project/change/requires) plus the
+ * body, and retains the byte-exact `raw` source so a read→write cycle is lossless.
+ */
+export interface PgpmScriptAst {
+    kind: PgpmScriptKind;
+    /** Structured header block (see {@link PgpmHeader}). */
+    header: PgpmHeader;
+    /** Everything after the header block, byte-exact. */
+    body: string;
+    /** The original file content, byte-exact. */
+    raw: string;
+}
+/**
+ * The AST of a single pgpm change: its plan entry (identity + dependencies +
+ * attribution) together with the deploy/revert/verify scripts that implement it.
+ * A script is `null` when the corresponding file does not exist on disk.
+ */
+export interface PgpmChangeAst {
+    /** Path identity / plan change name (e.g. `schemas/auth/tables/users`). */
+    name: string;
+    /** The plan entry for this change (dependencies, timestamp, planner, ...). */
+    plan: Change;
+    deploy: PgpmScriptAst | null;
+    revert: PgpmScriptAst | null;
+    verify: PgpmScriptAst | null;
+}
+/**
+ * The parsed AST of a module's Postgres extension `.control` file.
+ */
+export interface PgpmControlAst {
+    /** The control file name (`<name>.control`). */
+    fileName: string;
+    /** Extension name (control basename, equals the plan project). */
+    name: string;
+    /** Extensions this module requires (from the control `requires =` line). */
+    requires: string[];
+    /** `default_version` from the control file. */
+    version: string;
+    /** The original file content, byte-exact. */
+    raw: string;
+}
+/**
+ * The unified in-memory AST for an entire pgpm module ("AST for the migrations").
+ *
+ * It composes the existing file-level parsers — plan parser, control reader, SQL
+ * header parser — into a single typed object addressed by plan-order changes.
+ * Operators (rename, rebundle, slice, transpile) become transforms over this tree
+ * instead of ad-hoc file/plan re-reads. Every leaf keeps its byte-exact `raw`, so
+ * {@link readModule} → {@link writeModule} is a lossless copy.
+ */
+export interface PgpmModuleAst {
+    /** Directory the module was read from. */
+    dir: string;
+    /** Project (extension) name, from the plan `%project=`. */
+    name: string;
+    /** Parsed plan (package/uri/changes/tags). */
+    plan: ExtendedPlanFile;
+    /** The original `pgpm.plan` content, byte-exact. */
+    planRaw: string;
+    /** Parsed `.control`, or `null` when the module has no control file. */
+    control: PgpmControlAst | null;
+    /** Changes in plan order, each with its deploy/revert/verify scripts. */
+    changes: PgpmChangeAst[];
+}

package/module/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/module/writer.d.ts

@@ -0,0 +1,30 @@
+import { PgpmModuleAst, PgpmScriptAst } from './types';
+/**
+ * Serialize a script AST back to SQL text from its structured header + body.
+ * Byte-identical to the source for scripts read via {@link readModule} (the SQL
+ * header parser is lossless), and reflects any structural header edits.
+ */
+export declare function serializeScript(script: PgpmScriptAst): string;
+/**
+ * Serialize a module's plan back to `pgpm.plan` text from its structured model.
+ */
+export declare function serializePlan(module: PgpmModuleAst): string;
+export interface WriteModuleOptions {
+    /** Target directory. Defaults to the module's own `dir`. */
+    outDir?: string;
+    /**
+     * When true (default), write each file from its byte-exact `raw`, producing a
+     * lossless copy of the source module. Set false to write from the structured
+     * model instead (`serializePlan` / `serializeScript`), e.g. after transforms.
+     */
+    fromRaw?: boolean;
+}
+/**
+ * Materialize a {@link PgpmModuleAst} back to disk: `pgpm.plan`, the `.control`
+ * file (when present), and every change's deploy/revert/verify script.
+ *
+ * With the default `fromRaw: true` this is a lossless copy of what
+ * {@link readModule} loaded; with `fromRaw: false` it emits the structured
+ * serialization (used by operators that mutate the AST before writing).
+ */
+export declare function writeModule(module: PgpmModuleAst, options?: WriteModuleOptions): void;

package/module/writer.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serializeScript = serializeScript;
+exports.serializePlan = serializePlan;
+exports.writeModule = writeModule;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const writer_1 = require("../files/plan/writer");
+const header_1 = require("../files/sql/header");
+/**
+ * Serialize a script AST back to SQL text from its structured header + body.
+ * Byte-identical to the source for scripts read via {@link readModule} (the SQL
+ * header parser is lossless), and reflects any structural header edits.
+ */
+function serializeScript(script) {
+    return (0, header_1.writePgpmScript)({ header: script.header, body: script.body });
+}
+/**
+ * Serialize a module's plan back to `pgpm.plan` text from its structured model.
+ */
+function serializePlan(module) {
+    return (0, writer_1.generatePlanFileContent)(module.plan);
+}
+/**
+ * Materialize a {@link PgpmModuleAst} back to disk: `pgpm.plan`, the `.control`
+ * file (when present), and every change's deploy/revert/verify script.
+ *
+ * With the default `fromRaw: true` this is a lossless copy of what
+ * {@link readModule} loaded; with `fromRaw: false` it emits the structured
+ * serialization (used by operators that mutate the AST before writing).
+ */
+function writeModule(module, options = {}) {
+    const outDir = options.outDir ?? module.dir;
+    const fromRaw = options.fromRaw ?? true;
+    (0, fs_1.mkdirSync)(outDir, { recursive: true });
+    (0, fs_1.writeFileSync)((0, path_1.join)(outDir, 'pgpm.plan'), fromRaw ? module.planRaw : serializePlan(module));
+    if (module.control) {
+        (0, fs_1.writeFileSync)((0, path_1.join)(outDir, module.control.fileName), module.control.raw);
+    }
+    for (const change of module.changes) {
+        const scripts = [change.deploy, change.revert, change.verify];
+        for (const script of scripts) {
+            if (!script)
+                continue;
+            const file = (0, path_1.join)(outDir, script.kind, `${change.name}.sql`);
+            (0, fs_1.mkdirSync)((0, path_1.dirname)(file), { recursive: true });
+            (0, fs_1.writeFileSync)(file, fromRaw ? script.raw : serializeScript(script));
+        }
+    }
+}