@pgpmjs/core 7.0.0 → 7.2.0

package/esm/rebundle/module.js

@@ -0,0 +1,111 @@
+import { copyFileSync, existsSync, mkdirSync, readdirSync, writeFileSync } from 'fs';
+import { join } from 'path';
+import { parsePlanFile } from '@pgpmjs/ast/files/plan/parser';
+import { mergeSqlStatements, packageModule } from '../packaging/package';
+import { generatePlanContent } from '../slice/slice';
+import { assembleChunkSql, rebundlePlan } from './rebundle';
+export const SCRIPT_DIRS = ['deploy', 'revert', 'verify'];
+/**
+ * Wrap a merged chunk body in a single transaction. Deploy/revert commit;
+ * verify rolls back (a verify script must leave no trace). The individual
+ * member files' own BEGIN/COMMIT were stripped during the merge, so each
+ * rebundled chunk deploys as exactly one transaction.
+ */
+function wrapTransaction(body, scriptType) {
+    const trimmed = body.trim();
+    const tail = scriptType === 'verify' ? 'ROLLBACK;' : 'COMMIT;';
+    return `BEGIN;\n\n${trimmed}\n\n${tail}\n`;
+}
+/**
+ * Merge one chunk's member scripts (in the correct order per direction) into a
+ * single deparsed, single-transaction migration string. Shared by the
+ * single-module (`rebundleModule`) and workspace (`rebundleWorkspace`) emitters.
+ */
+export async function mergeChunkScript(sourceDir, chunk, scriptType, opts = {}) {
+    const merged = await mergeSqlStatements(assembleChunkSql(sourceDir, chunk, scriptType), {
+        stripTransactions: true,
+        pretty: opts.pretty ?? true,
+        functionDelimiter: opts.functionDelimiter ?? '$EOFCODE$',
+    });
+    return wrapTransaction(merged.sql, scriptType);
+}
+/**
+ * Copy any top-level files (control, Makefile, package.json, README, ...) from
+ * the source module, excluding the plan and the per-change script directories
+ * which are regenerated. The rebundled module stays the same extension — same
+ * name, same control `requires` — only its internal change set collapses.
+ */
+function copyModuleMetadata(sourceDir, outputDir) {
+    for (const entry of readdirSync(sourceDir, { withFileTypes: true })) {
+        if (entry.isDirectory())
+            continue;
+        if (entry.name === 'pgpm.plan')
+            continue;
+        copyFileSync(join(sourceDir, entry.name), join(outputDir, entry.name));
+    }
+}
+/**
+ * Materialize a rebundled module: merge each chunk's member scripts into a
+ * single deparsed migration (reusing `packageModule`'s merge engine), write the
+ * chunk-quotient plan, and verify the result is byte-identical when packaged.
+ *
+ * Reuses existing plumbing throughout — `rebundlePlan` for the chunk model,
+ * `mergeSqlStatements`/`packageModule` for statement merging and the gate,
+ * `generatePlanContent` for the chunk plan, and the source control/Makefile
+ * verbatim.
+ */
+export async function rebundleModule(sourceDir, options) {
+    const { outputDir, overwrite = false, pretty = true, functionDelimiter = '$EOFCODE$', ...strategy } = options;
+    if (existsSync(outputDir) && readdirSync(outputDir).length > 0 && !overwrite) {
+        throw new Error(`Output directory is not empty: ${outputDir}. Pass overwrite: true to replace.`);
+    }
+    const plan = rebundlePlan(sourceDir, strategy);
+    // Tags anchor on the last member of the chunk that sealed at them; remap each
+    // to its chunk name so `deploy --to @tag` still lands on a real change.
+    const parsed = parsePlanFile(join(sourceDir, 'pgpm.plan'));
+    const sourceTags = parsed.data?.tags ?? [];
+    const memberToChunk = new Map();
+    for (const chunk of plan.chunks) {
+        for (const member of chunk.deploy)
+            memberToChunk.set(member, chunk.name);
+    }
+    const remappedTags = sourceTags.map(tag => ({
+        ...tag,
+        change: memberToChunk.get(tag.change) ?? tag.change,
+    }));
+    mkdirSync(outputDir, { recursive: true });
+    for (const dir of SCRIPT_DIRS)
+        mkdirSync(join(outputDir, dir), { recursive: true });
+    copyModuleMetadata(sourceDir, outputDir);
+    const written = [];
+    for (const chunk of plan.chunks) {
+        const paths = { chunk: chunk.name };
+        for (const dir of SCRIPT_DIRS) {
+            const merged = await mergeSqlStatements(assembleChunkSql(sourceDir, chunk, dir), {
+                stripTransactions: true,
+                pretty,
+                functionDelimiter,
+            });
+            const rel = join(dir, `${chunk.name}.sql`);
+            writeFileSync(join(outputDir, rel), wrapTransaction(merged.sql, dir));
+            paths[dir] = rel;
+        }
+        written.push(paths);
+    }
+    // Chunk-quotient plan: one change per chunk, deps are earlier chunk names.
+    const planEntries = plan.chunks.map(chunk => ({
+        name: chunk.name,
+        dependencies: chunk.dependencies,
+    }));
+    writeFileSync(join(outputDir, 'pgpm.plan'), generatePlanContent(plan.project, planEntries, remappedTags));
+    // Byte-identical gate: packaging the source and the rebundled module must
+    // produce the same consolidated extension SQL.
+    const sourcePkg = await packageModule(sourceDir, { pretty, functionDelimiter });
+    const outputPkg = await packageModule(outputDir, { pretty, functionDelimiter });
+    const invariant = {
+        ok: sourcePkg.sql === outputPkg.sql,
+        sourceDiff: !!sourcePkg.diff,
+        outputDiff: !!outputPkg.diff,
+    };
+    return { ...plan, outputDir, written, invariant };
+}

package/esm/rebundle/rebundle.js

@@ -0,0 +1,170 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { getChanges } from '@pgpmjs/ast/files/plan/parser';
+import { resolveWithPlan } from '../resolution/resolve';
+import { buildDependencyGraph, buildPackageDependencies, computeDeployOrder, detectPackageCycle, extractPackageFromPath, } from '../slice/slice';
+import { parsePlanFile } from '@pgpmjs/ast/files/plan/parser';
+/**
+ * Derive the boundary key for a change under the given strategy.
+ * Consecutive changes sharing a key may be merged into the same chunk.
+ */
+function boundaryKey(changeName, strategy) {
+    if (strategy.boundary === 'none')
+        return '';
+    const folderKey = () => extractPackageFromPath(changeName, strategy.depth ?? 1, strategy.prefixToStrip ?? 'schemas');
+    if (strategy.boundary === 'category') {
+        // Classifier/facts-driven seam: the caller decides each change's category;
+        // fall back to the folder key for changes it doesn't classify.
+        const category = strategy.categoryOf?.(changeName);
+        return category ?? folderKey();
+    }
+    return folderKey();
+}
+/**
+ * Assign changes to chunks by walking the source plan in order and greedily
+ * accumulating consecutive changes that share a boundary key, sealing a chunk
+ * when the key changes, the size cap is reached, or a member carries a tag
+ * (tags mark points you can `deploy --to @tag`, so they must stay chunk seams).
+ *
+ * Because chunks are contiguous runs of the plan, member and chunk order both
+ * follow the source, which is what guarantees byte-identical output.
+ */
+function assignChunks(orderedChanges, graph, strategy) {
+    const chunks = [];
+    const seen = new Map();
+    const maxSize = strategy.maxChunkSize && strategy.maxChunkSize > 0 ? strategy.maxChunkSize : Infinity;
+    let current = null;
+    const seal = () => {
+        current = null;
+    };
+    for (const change of orderedChanges) {
+        const key = boundaryKey(change, strategy);
+        const changeHasTag = (graph.tags.get(change)?.length ?? 0) > 0;
+        if (current &&
+            current.key === key &&
+            current.members.length < maxSize) {
+            current.members.push(change);
+        }
+        else {
+            // Deterministic, collision-free chunk name: boundary key (or 'chunk'),
+            // suffixed with an ordinal when the same key splits across size caps.
+            const base = key || 'chunk';
+            const ordinal = (seen.get(base) ?? 0) + 1;
+            seen.set(base, ordinal);
+            const name = ordinal === 1 ? base : `${base}~${ordinal}`;
+            current = { name, members: [change], key };
+            chunks.push(current);
+        }
+        // A member that is a tag anchor seals the chunk after inclusion.
+        if (changeHasTag)
+            seal();
+    }
+    return chunks.map(({ name, members }) => ({ name, members }));
+}
+/**
+ * Compute a rebundle plan for a pgpm module directory.
+ *
+ * Uses the existing plan parser, dependency graph, and package-dependency /
+ * deploy-order primitives from the slicer — chunks are treated exactly like
+ * packages for dependency and ordering purposes. No plan re-parsing or path
+ * logic is reinvented here.
+ */
+export function rebundlePlan(moduleDir, strategy = {}) {
+    const planPath = join(moduleDir, 'pgpm.plan');
+    const planResult = parsePlanFile(planPath);
+    if (!planResult.data) {
+        const msg = planResult.errors?.map(e => `Line ${e.line}: ${e.message}`).join('\n') || 'Unknown error';
+        throw new Error(`Failed to parse plan file: ${msg}`);
+    }
+    const graph = buildDependencyGraph(planResult.data);
+    const orderedChanges = planResult.data.changes.map(c => c.name);
+    const warnings = [];
+    const rawChunks = assignChunks(orderedChanges, graph, strategy);
+    // Reverse lookup change -> chunk, reusing slice's package-dep machinery.
+    const assignments = new Map();
+    const changeToChunk = new Map();
+    for (const chunk of rawChunks) {
+        assignments.set(chunk.name, new Set(chunk.members));
+        for (const member of chunk.members)
+            changeToChunk.set(member, chunk.name);
+    }
+    const chunkDeps = buildPackageDependencies(graph, assignments);
+    const cycle = detectPackageCycle(chunkDeps);
+    if (cycle) {
+        warnings.push({
+            type: 'cycle_detected',
+            message: `Chunk cycle detected: ${cycle.join(' -> ')}`,
+            suggestedAction: 'Widen the boundary or raise maxChunkSize so cyclic changes share a chunk',
+        });
+    }
+    const deployOrder = computeDeployOrder(chunkDeps);
+    // Because chunks are contiguous runs of the source plan, the greedy creation
+    // order is already a valid deploy order. If the dependency-derived order
+    // disagrees, the boundary split a back-edge — surface it rather than silently
+    // reordering (that would break byte-identical output).
+    const creationOrder = rawChunks.map(c => c.name);
+    const orderMatches = deployOrder.length === creationOrder.length &&
+        deployOrder.every((name, i) => name === creationOrder[i]);
+    if (!orderMatches) {
+        warnings.push({
+            type: 'heavy_cross_deps',
+            message: 'Chunk deploy order differs from source order; a boundary split a dependency edge',
+            suggestedAction: 'Adjust the boundary/maxChunkSize so dependent changes stay contiguous',
+        });
+    }
+    const chunkByName = new Map(rawChunks.map(c => [c.name, c.members]));
+    const chunks = creationOrder.map(name => {
+        const members = chunkByName.get(name);
+        return {
+            name,
+            deploy: members,
+            verify: members,
+            revert: [...members].reverse(),
+            dependencies: [...(chunkDeps.get(name) ?? new Set())].sort(),
+        };
+    });
+    return {
+        chunks,
+        deployOrder: creationOrder,
+        warnings,
+        sourceChanges: planResult.data.changes,
+        project: planResult.data.package,
+    };
+}
+/**
+ * Assemble the merged SQL for one chunk in the given direction by concatenating
+ * its member script files — the same file-concatenation `resolveWithPlan` uses,
+ * just scoped to the chunk. Members are already correctly ordered per direction.
+ */
+export function assembleChunkSql(moduleDir, chunk, scriptType = 'deploy') {
+    const members = scriptType === 'revert' ? chunk.revert : scriptType === 'verify' ? chunk.verify : chunk.deploy;
+    const parts = [];
+    for (const change of members) {
+        parts.push(readFileSync(join(moduleDir, scriptType, `${change}.sql`), 'utf-8'));
+    }
+    return parts.join('\n');
+}
+/**
+ * Byte-identical gate: assembling all chunks in deploy order must reproduce the
+ * module's original resolved output in every direction the engine cares about
+ * (deploy topological, verify in deploy order, revert reversed). This is the
+ * invariant that makes any granularity-dial position safe.
+ */
+export function verifyRebundleInvariant(moduleDir, result) {
+    const mismatches = [];
+    const assembled = (scriptType) => {
+        const chunks = scriptType === 'revert' ? [...result.chunks].reverse() : result.chunks;
+        return chunks.map(chunk => assembleChunkSql(moduleDir, chunk, scriptType)).join('\n');
+    };
+    // deploy / revert have canonical resolvers; verify concatenates in deploy order.
+    const originalVerify = getChanges(join(moduleDir, 'pgpm.plan'))
+        .map(change => readFileSync(join(moduleDir, 'verify', `${change}.sql`), 'utf-8'))
+        .join('\n');
+    if (assembled('deploy') !== resolveWithPlan(moduleDir, 'deploy'))
+        mismatches.push('deploy');
+    if (assembled('revert') !== resolveWithPlan(moduleDir, 'revert'))
+        mismatches.push('revert');
+    if (assembled('verify') !== originalVerify)
+        mismatches.push('verify');
+    return { ok: mismatches.length === 0, mismatches };
+}

package/esm/rebundle/workspace.js

@@ -0,0 +1,170 @@
+import { existsSync, readdirSync, readFileSync } from 'fs';
+import { basename, join } from 'path';
+import { DEFAULT_TEMPLATE_REPO, scaffoldTemplate } from '../core/template-scaffold';
+import { parsePlanFile } from '@pgpmjs/ast/files/plan/parser';
+import { mergeSqlStatements } from '../packaging/package';
+import { resolveWithPlan } from '../resolution/resolve';
+import { writeMinimalModule, writeMinimalWorkspace } from '../workspace/minimal';
+import { mergeChunkScript } from './module';
+import { rebundlePlan } from './rebundle';
+/**
+ * Materialize a rebundled workspace: emit each chunk as its own tiny module
+ * (one merged change) under `packages/<chunk>/`, carrying cross-chunk deps via
+ * the control-file `requires` (and optionally a plan cross-reference).
+ *
+ * This is the "modular workspace" carve — the same monolith sliced into
+ * independently publishable module forks (e.g. a users module, an admin module).
+ * The emitted directory is a real, discoverable pgpm workspace: it reuses
+ * `writeMinimalWorkspace`/`writeMinimalModule` (the minimal deployable file set
+ * pgpm recognizes — `pgpm.json`, `pgpm.plan`, `<name>.control`, `Makefile`,
+ * `package.json`), `rebundlePlan` for the chunk model, and `mergeChunkScript`
+ * for the per-chunk merge.
+ */
+export async function rebundleWorkspace(sourceDir, options) {
+    const { outputDir, overwrite = false, pretty = true, functionDelimiter = '$EOFCODE$', crossChunkDepMode = 'control-only', initScaffold = false, templateRepo = DEFAULT_TEMPLATE_REPO, templateBranch, license = 'CONSTRUCTIVE', ...strategy } = options;
+    if (existsSync(outputDir) && readdirSync(outputDir).length > 0 && !overwrite) {
+        throw new Error(`Output directory is not empty: ${outputDir}. Pass overwrite: true to replace.`);
+    }
+    const plan = rebundlePlan(sourceDir, strategy);
+    // Remap tags onto their sealing chunk (each tag anchored a chunk boundary).
+    const parsed = parsePlanFile(join(sourceDir, 'pgpm.plan'));
+    const sourceTags = parsed.data?.tags ?? [];
+    const memberToChunk = new Map();
+    for (const chunk of plan.chunks) {
+        for (const member of chunk.deploy)
+            memberToChunk.set(member, chunk.name);
+    }
+    const remappedTags = sourceTags.map(tag => ({
+        ...tag,
+        change: memberToChunk.get(tag.change) ?? tag.change,
+    }));
+    if (initScaffold) {
+        // Lay down the full `pgpm init` workspace shell (pgpm.json, pnpm-workspace,
+        // lerna.json, tsconfig, lint/format configs, CI); the merged pgpm files are
+        // written on top per module below.
+        await scaffoldTemplate({
+            fromPath: 'workspace',
+            outputDir,
+            templateRepo,
+            branch: templateBranch,
+            answers: workspaceAnswers(outputDir, license),
+            noTty: true,
+        });
+    }
+    else {
+        writeMinimalWorkspace(outputDir, { packages: ['packages/*'] });
+    }
+    const byDeployOrder = [...plan.chunks].sort((a, b) => plan.deployOrder.indexOf(a.name) - plan.deployOrder.indexOf(b.name));
+    const packages = [];
+    for (const chunk of byDeployOrder) {
+        const pkgRel = join('packages', chunk.name);
+        const pkgDir = join(outputDir, pkgRel);
+        if (initScaffold) {
+            // Scaffold the module's developer shell (package.json, jest.config.js,
+            // README, LICENSE, __tests__); writeMinimalModule overwrites the pgpm
+            // files (pgpm.plan, .control, Makefile, deploy/revert/verify) below.
+            await scaffoldTemplate({
+                fromPath: 'module',
+                outputDir: pkgDir,
+                templateRepo,
+                branch: templateBranch,
+                answers: moduleAnswers(chunk.name, license),
+                noTty: true,
+            });
+        }
+        const scripts = {
+            [chunk.name]: {
+                deploy: await mergeChunkScript(sourceDir, chunk, 'deploy', { pretty, functionDelimiter }),
+                revert: await mergeChunkScript(sourceDir, chunk, 'revert', { pretty, functionDelimiter }),
+                verify: await mergeChunkScript(sourceDir, chunk, 'verify', { pretty, functionDelimiter }),
+            },
+        };
+        // Control `requires` always carries the module-level dependency; in
+        // 'change' mode the plan additionally records the fine-grained cross-ref.
+        const deps = chunk.dependencies;
+        const planChange = {
+            name: chunk.name,
+            dependencies: planChangeDeps(deps, crossChunkDepMode),
+        };
+        writeMinimalModule(pkgDir, {
+            name: chunk.name,
+            changes: [planChange],
+            scripts,
+            tags: remappedTags.filter(t => t.change === chunk.name),
+            requires: deps,
+            license,
+            overwrite: true,
+            // When scaffolded, keep the boilerplate's richer package.json.
+            writePackageJson: !initScaffold,
+        });
+        packages.push({ name: chunk.name, dir: pkgRel, dependencies: [...deps] });
+    }
+    const invariant = { ok: await checkWorkspaceInvariant(sourceDir, outputDir, packages, { pretty, functionDelimiter }) };
+    return { ...plan, outputDir, packages, crossChunkDepMode, invariant };
+}
+/**
+ * In 'change' mode, express each cross-chunk dep as a plan cross-reference
+ * (`<dep>:<dep>`, since each chunk-module has a single change named after it);
+ * in 'control-only' mode the plan carries no deps — the control `requires`
+ * governs ordering.
+ */
+function planChangeDeps(deps, mode) {
+    if (mode === 'control-only')
+        return [];
+    return deps.map(dep => `${dep}:${dep}`);
+}
+/**
+ * Non-interactive answers for the `pgpm init` workspace template. Values are
+ * deterministic placeholders (the generated pgpm files are the real payload);
+ * the workspace name derives from the output directory.
+ */
+function workspaceAnswers(outputDir, license) {
+    const name = basename(outputDir) || 'rebundled-workspace';
+    return {
+        name,
+        fullName: 'Constructive',
+        email: 'noreply@constructive.io',
+        moduleName: name,
+        username: 'constructive-io',
+        repoName: name,
+        license,
+    };
+}
+/** Non-interactive answers for the `pgpm init` module template. */
+function moduleAnswers(name, license) {
+    return {
+        name,
+        moduleName: name,
+        moduleDesc: `${name} module`,
+        description: `${name} module`,
+        repoName: name,
+        fullName: 'Constructive',
+        email: 'noreply@constructive.io',
+        username: 'constructive-io',
+        access: 'public',
+        license,
+    };
+}
+/**
+ * Byte-identical gate for a workspace: concatenate every package's deploy
+ * script in workspace deploy order, merge it, and compare against the merged
+ * original module deploy output. Both go through the same `mergeSqlStatements`
+ * pipeline, so equality proves the carve preserved the deployed statements and
+ * their order.
+ */
+async function checkWorkspaceInvariant(sourceDir, outputDir, packages, opts) {
+    const concatenated = packages
+        .map(p => readFileSync(join(outputDir, p.dir, 'deploy', `${p.name}.sql`), 'utf-8'))
+        .join('\n');
+    const workspaceMerged = await mergeSqlStatements(concatenated, {
+        stripTransactions: true,
+        pretty: opts.pretty,
+        functionDelimiter: opts.functionDelimiter,
+    });
+    const sourceMerged = await mergeSqlStatements(resolveWithPlan(sourceDir, 'deploy'), {
+        stripTransactions: true,
+        pretty: opts.pretty,
+        functionDelimiter: opts.functionDelimiter,
+    });
+    return workspaceMerged.sql === sourceMerged.sql;
+}

package/esm/refactor/rename.js

@@ -1,7 +1,10 @@
 import { existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmdirSync, statSync, writeFileSync } from 'fs';
 import { dirname, join, relative, sep } from 'path';
-import { parsePlanFileSimple } from '../files/plan/parser';
-import { parsePgpmHeader, renameInHeader, writePgpmScript } from '../files/sql/header';
+import { parsePlanFileSimple } from '@pgpmjs/ast/files/plan/parser';
+import { parsePgpmHeader, renameInHeader, writePgpmScript } from '@pgpmjs/ast/files/sql/header';
+import { renameInPlanContent } from '@pgpmjs/ast/plan-rename';
+// Re-exported from @pgpmjs/ast so existing `@pgpmjs/core` consumers keep importing it here.
+export { renameInPlanContent };
 const SCRIPT_DIRS = ['deploy', 'revert', 'verify'];
 function escapeRe(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
@@ -59,31 +62,6 @@ export function validateRenames(moduleDir, renames) {
         targets.add(to);
     }
 }
-/**
- * Rewrite change names in a pgpm.plan's content according to a rename map.
- * Textual and format-preserving: only the change-name token at the start of a
- * change line, plain (same-package) dependency refs inside `[...]`, and tag
- * lines' change field are rewritten; timestamps, planners, comments,
- * cross-package refs, and tag refs are untouched.
- */
-export function renameInPlanContent(content, renames) {
-    const froms = Array.from(renames.keys()).sort((a, b) => b.length - a.length);
-    return content
-        .split('\n')
-        .map(line => {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#') || trimmed.startsWith('%'))
-            return line;
-        let result = line;
-        for (const from of froms) {
-            const to = renames.get(from);
-            const re = new RegExp(`(^|[\\s\\[])${escapeRe(from)}(?=$|[\\s\\]@])`, 'g');
-            result = result.replace(re, `$1${to}`);
-        }
-        return result;
-    })
-        .join('\n');
-}
 /**
  * Atomically rename/move changes within a pgpm module: the coupled 4-way
  * rewrite of (1) deploy/revert/verify script files on disk, (2) the moved

package/esm/resolution/deps.js

@@ -2,8 +2,8 @@ import { readFileSync } from 'fs';
 import { sync as glob } from 'glob';
 import { join, relative } from 'path';
 import { PgpmPackage } from '../core/class/pgpm';
-import { parsePlanFile } from '../files/plan/parser';
-import { scanDeployScript } from '../files/sql/header';
+import { parsePlanFile } from '@pgpmjs/ast/files/plan/parser';
+import { scanDeployScript } from '@pgpmjs/ast/files/sql/header';
 import { errors } from '@pgpmjs/types';
 /**
  * Core dependency resolution algorithm that handles circular dependency detection

package/esm/resolution/resolve.js

@@ -1,6 +1,6 @@
 import { readFileSync } from 'fs';
-import { getChanges, getExtensionName } from '../files';
-import { parsePlanFile } from '../files/plan/parser';
+import { getChanges, getExtensionName } from '@pgpmjs/ast/files';
+import { parsePlanFile } from '@pgpmjs/ast/files/plan/parser';
 import { resolveDependencies } from './deps';
 import { errors } from '@pgpmjs/types';
 /**

package/esm/slice/slice.js

@@ -1,4 +1,4 @@
-import { parsePlanFile } from '../files/plan/parser';
+import { parsePlanFile } from '@pgpmjs/ast/files/plan/parser';
 import { minimatch } from 'minimatch';
 /**
  * Build a dependency graph from a parsed plan file

package/esm/workspace/minimal.js

@@ -0,0 +1,73 @@
+import fs from 'fs';
+import path from 'path';
+import { generatePlanContent } from '../slice/slice';
+const SCRIPT_DIRS = ['deploy', 'revert', 'verify'];
+/**
+ * The minimal set of files pgpm needs to recognize and deploy a module:
+ * `pgpm.plan` (module marker + change order), `<name>.control` (extension
+ * metadata), `Makefile` (PGXS packaging), `package.json`, and the
+ * deploy/revert/verify scripts. Mirrors what `pgpm init` scaffolds, minus the
+ * network-fetched boilerplate (README/LICENSE/jest/tests/lint configs).
+ */
+export function writeMinimalModule(moduleDir, options) {
+    const { name, changes, scripts, tags = [], requires = [], version = '0.0.1', license = 'CONSTRUCTIVE', overwrite = false, writePackageJson = true, } = options;
+    if (fs.existsSync(moduleDir) && fs.readdirSync(moduleDir).length > 0 && !overwrite) {
+        throw new Error(`Module directory is not empty: ${moduleDir}. Pass overwrite: true to replace.`);
+    }
+    for (const dir of SCRIPT_DIRS) {
+        fs.mkdirSync(path.join(moduleDir, dir), { recursive: true });
+    }
+    for (const change of changes) {
+        const changeScripts = scripts[change.name];
+        if (!changeScripts) {
+            throw new Error(`Missing scripts for change "${change.name}" in module "${name}"`);
+        }
+        fs.writeFileSync(path.join(moduleDir, 'deploy', `${change.name}.sql`), changeScripts.deploy);
+        fs.writeFileSync(path.join(moduleDir, 'revert', `${change.name}.sql`), changeScripts.revert);
+        fs.writeFileSync(path.join(moduleDir, 'verify', `${change.name}.sql`), changeScripts.verify ?? `-- Verify ${change.name}\n\nBEGIN;\n\nSELECT 1;\n\nROLLBACK;\n`);
+    }
+    fs.writeFileSync(path.join(moduleDir, 'pgpm.plan'), generatePlanContent(name, changes, tags));
+    fs.writeFileSync(path.join(moduleDir, `${name}.control`), generateModuleControl(name, requires, version));
+    fs.writeFileSync(path.join(moduleDir, 'Makefile'), generateModuleMakefile(name, version));
+    if (writePackageJson) {
+        fs.writeFileSync(path.join(moduleDir, 'package.json'), JSON.stringify({ name, version, description: `${name} module`, license }, null, 2) + '\n');
+    }
+}
+/**
+ * Write the minimal workspace marker (`pgpm.json`) so pgpm discovers the
+ * directory as a workspace. This is what `getWorkspacePath` walks up to find.
+ */
+export function writeMinimalWorkspace(workspaceDir, options = {}) {
+    const { packages = ['packages/*'], overwrite = true } = options;
+    const configPath = path.join(workspaceDir, 'pgpm.json');
+    if (fs.existsSync(configPath) && !overwrite)
+        return;
+    fs.mkdirSync(workspaceDir, { recursive: true });
+    fs.writeFileSync(configPath, JSON.stringify({ packages }, null, 2) + '\n');
+}
+/**
+ * Full extension control file, matching the shape `pgpm init` emits (comment,
+ * default_version, module_pathname, requires, relocatable, superuser).
+ */
+export function generateModuleControl(name, requires = [], version = '0.0.1') {
+    let content = `# ${name} extension\n`;
+    content += `comment = '${name} extension'\n`;
+    content += `default_version = '${version}'\n`;
+    content += `module_pathname = '$libdir/${name}'\n`;
+    if (requires.length > 0) {
+        content += `requires = '${requires.join(',')}'\n`;
+    }
+    content += `relocatable = false\n`;
+    content += `superuser = false\n`;
+    return content;
+}
+/**
+ * PGXS Makefile for `pgpm package`/`make install`.
+ */
+export function generateModuleMakefile(name, version = '0.0.1') {
+    return (`EXTENSION = ${name}\n` +
+        `DATA = sql/${name}--${version}.sql\n\n` +
+        `PG_CONFIG = pg_config\n` +
+        `PGXS := $(shell $(PG_CONFIG) --pgxs)\n` +
+        `include $(PGXS)\n`);
+}

package/index.d.ts

@@ -1,5 +1,6 @@
 export * from './core/class/pgpm';
 export * from './slice';
+export * from './rebundle';
 export * from './extensions/extensions';
 export * from './modules/modules';
 export * from './packaging/package';
@@ -8,16 +9,19 @@ export * from './resolution/deps';
 export * from './resolution/resolve';
 export * from './workspace/paths';
 export * from './workspace/utils';
+export * from './workspace/minimal';
 export * from './core/template-scaffold';
 export * from './core/boilerplate-types';
 export * from './core/boilerplate-scanner';
-export * from './files';
+export * from '@pgpmjs/ast/files';
+export * from '@pgpmjs/ast/module';
+export * from './bundle';
 export * from './refactor';
 export { cleanSql } from './migrate/clean';
 export { PgpmMigrate } from './migrate/client';
 export { PgpmInit } from './init/client';
 export * from './roles';
-export { parseAuthor } from './utils/author';
+export { parseAuthor } from '@pgpmjs/ast';
 export { DeployOptions, DeployResult, MigrateChange, MigratePlanFile, RevertOptions, RevertResult, StatusResult, VerifyOptions, VerifyResult } from './migrate/types';
 export { hashFile, hashString } from './migrate/utils/hash';
 export { executeQuery, TransactionContext, TransactionOptions, withTransaction } from './migrate/utils/transaction';

package/index.js

@@ -17,6 +17,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.withTransaction = exports.executeQuery = exports.hashString = exports.hashFile = exports.parseAuthor = exports.PgpmInit = exports.PgpmMigrate = exports.cleanSql = void 0;
 __exportStar(require("./core/class/pgpm"), exports);
 __exportStar(require("./slice"), exports);
+__exportStar(require("./rebundle"), exports);
 __exportStar(require("./extensions/extensions"), exports);
 __exportStar(require("./modules/modules"), exports);
 __exportStar(require("./packaging/package"), exports);
@@ -25,11 +26,14 @@ __exportStar(require("./resolution/deps"), exports);
 __exportStar(require("./resolution/resolve"), exports);
 __exportStar(require("./workspace/paths"), exports);
 __exportStar(require("./workspace/utils"), exports);
+__exportStar(require("./workspace/minimal"), exports);
 __exportStar(require("./core/template-scaffold"), exports);
 __exportStar(require("./core/boilerplate-types"), exports);
 __exportStar(require("./core/boilerplate-scanner"), exports);
-// Export package-files functionality (now integrated into core)
-__exportStar(require("./files"), exports);
+// Re-export the module AST layer (moved to the @pgpmjs/ast leaf package)
+__exportStar(require("@pgpmjs/ast/files"), exports);
+__exportStar(require("@pgpmjs/ast/module"), exports);
+__exportStar(require("./bundle"), exports);
 __exportStar(require("./refactor"), exports);
 var clean_1 = require("./migrate/clean");
 Object.defineProperty(exports, "cleanSql", { enumerable: true, get: function () { return clean_1.cleanSql; } });
@@ -38,8 +42,8 @@ Object.defineProperty(exports, "PgpmMigrate", { enumerable: true, get: function
 var client_2 = require("./init/client");
 Object.defineProperty(exports, "PgpmInit", { enumerable: true, get: function () { return client_2.PgpmInit; } });
 __exportStar(require("./roles"), exports);
-var author_1 = require("./utils/author");
-Object.defineProperty(exports, "parseAuthor", { enumerable: true, get: function () { return author_1.parseAuthor; } });
+var ast_1 = require("@pgpmjs/ast");
+Object.defineProperty(exports, "parseAuthor", { enumerable: true, get: function () { return ast_1.parseAuthor; } });
 var hash_1 = require("./migrate/utils/hash");
 Object.defineProperty(exports, "hashFile", { enumerable: true, get: function () { return hash_1.hashFile; } });
 Object.defineProperty(exports, "hashString", { enumerable: true, get: function () { return hash_1.hashString; } });