@pgpmjs/core 6.32.2 → 6.34.0

package/refactor/rename.js

@@ -0,0 +1,206 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateRenames = validateRenames;
+exports.renameInPlanContent = renameInPlanContent;
+exports.renameChanges = renameChanges;
+exports.deriveRenamesFromSchemaMapping = deriveRenamesFromSchemaMapping;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const parser_1 = require("../files/plan/parser");
+const header_1 = require("../files/sql/header");
+const SCRIPT_DIRS = ['deploy', 'revert', 'verify'];
+function escapeRe(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function findSqlFiles(dir) {
+    const files = [];
+    if (!(0, fs_1.existsSync)(dir))
+        return files;
+    const entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+        const fullPath = (0, path_1.join)(dir, entry.name);
+        if (entry.isDirectory()) {
+            files.push(...findSqlFiles(fullPath));
+        }
+        else if (entry.isFile() && entry.name.endsWith('.sql')) {
+            files.push(fullPath);
+        }
+    }
+    return files;
+}
+function removeEmptyDirs(dir, stopAt) {
+    let current = dir;
+    while (current !== stopAt && current.startsWith(stopAt)) {
+        if (!(0, fs_1.existsSync)(current) || (0, fs_1.readdirSync)(current).length > 0)
+            return;
+        (0, fs_1.rmdirSync)(current);
+        current = (0, path_1.dirname)(current);
+    }
+}
+/**
+ * Validate a rename map against a module directory: every source change must
+ * exist in the plan, no target may collide with an existing change, and no
+ * two sources may map to the same target.
+ *
+ * @throws on any violation.
+ */
+function validateRenames(moduleDir, renames) {
+    const planPath = (0, path_1.join)(moduleDir, 'pgpm.plan');
+    const plan = (0, parser_1.parsePlanFileSimple)(planPath);
+    const changeNames = new Set(plan.changes.map(c => c.name));
+    const targets = new Set();
+    for (const [from, to] of renames) {
+        if (from === to) {
+            throw new Error(`Rename maps change to itself: ${from}`);
+        }
+        if (!changeNames.has(from)) {
+            throw new Error(`Cannot rename unknown change: ${from}`);
+        }
+        if (changeNames.has(to) && !renames.has(to)) {
+            throw new Error(`Rename target already exists in plan: ${to}`);
+        }
+        if (targets.has(to)) {
+            throw new Error(`Multiple changes rename to the same target: ${to}`);
+        }
+        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.
+ */
+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
+ * scripts' own header identity, (3) `-- requires:` headers in every script
+ * that references a renamed change, and (4) the pgpm.plan.
+ *
+ * SQL statement bodies are NOT touched: schema-name rewrites inside SQL are a
+ * separate AST-level concern for callers to compose (e.g. transform passes).
+ */
+function renameChanges(moduleDir, renames, options = {}) {
+    const dryRun = options.dryRun ?? false;
+    const result = {
+        filesMoved: [],
+        headersRewritten: [],
+        planRewritten: false
+    };
+    if (dryRun)
+        result.dryRunReport = [];
+    if (renames.size === 0)
+        return result;
+    validateRenames(moduleDir, renames);
+    // 1. Move script files
+    for (const scriptDir of SCRIPT_DIRS) {
+        for (const [from, to] of renames) {
+            const oldPath = (0, path_1.join)(moduleDir, scriptDir, `${from}.sql`);
+            if (!(0, fs_1.existsSync)(oldPath) || !(0, fs_1.statSync)(oldPath).isFile())
+                continue;
+            const newPath = (0, path_1.join)(moduleDir, scriptDir, `${to}.sql`);
+            if ((0, fs_1.existsSync)(newPath)) {
+                throw new Error(`Rename target file already exists: ${(0, path_1.relative)(moduleDir, newPath)}`);
+            }
+            if (dryRun) {
+                result.dryRunReport.push(`Would move: ${(0, path_1.relative)(moduleDir, oldPath)} -> ${(0, path_1.relative)(moduleDir, newPath)}`);
+            }
+            else {
+                (0, fs_1.mkdirSync)((0, path_1.dirname)(newPath), { recursive: true });
+                (0, fs_1.renameSync)(oldPath, newPath);
+                removeEmptyDirs((0, path_1.dirname)(oldPath), (0, path_1.join)(moduleDir, scriptDir));
+            }
+            result.filesMoved.push({
+                from: [scriptDir, `${from}.sql`].join(path_1.sep),
+                to: [scriptDir, `${to}.sql`].join(path_1.sep)
+            });
+        }
+    }
+    // 2 + 3. Rewrite headers in every script (identity of moved files,
+    // requires of dependents)
+    for (const scriptDir of SCRIPT_DIRS) {
+        const dir = (0, path_1.join)(moduleDir, scriptDir);
+        for (const file of findSqlFiles(dir)) {
+            const content = (0, fs_1.readFileSync)(file, 'utf-8');
+            const script = (0, header_1.parsePgpmHeader)(content);
+            const count = (0, header_1.renameInHeader)(script, renames);
+            if (count === 0)
+                continue;
+            const rewritten = (0, header_1.writePgpmScript)(script);
+            if (rewritten === content)
+                continue;
+            if (dryRun) {
+                result.dryRunReport.push(`Would rewrite header: ${(0, path_1.relative)(moduleDir, file)}`);
+            }
+            else {
+                (0, fs_1.writeFileSync)(file, rewritten);
+            }
+            result.headersRewritten.push((0, path_1.relative)(moduleDir, file));
+        }
+    }
+    // In dry-run mode files were not moved, so dependents' headers are found at
+    // their original paths above; the moved files' own headers are still
+    // reported through the same scan.
+    // 4. Rewrite pgpm.plan
+    const planPath = (0, path_1.join)(moduleDir, 'pgpm.plan');
+    const planContent = (0, fs_1.readFileSync)(planPath, 'utf-8');
+    const newPlanContent = renameInPlanContent(planContent, renames);
+    if (newPlanContent !== planContent) {
+        if (dryRun) {
+            result.dryRunReport.push('Would rewrite: pgpm.plan');
+        }
+        else {
+            (0, fs_1.writeFileSync)(planPath, newPlanContent);
+        }
+        result.planRewritten = true;
+    }
+    return result;
+}
+/**
+ * Derive a change rename map from a schema mapping (old schema name -> new
+ * schema name) by rewriting the `schemas/<name>/` path segment of every plan
+ * change that lives under a renamed schema.
+ *
+ * This is the module-level counterpart of directory-based schema renames:
+ * `schemas/my-app/tables/users` with mapping `my-app -> my_app` yields
+ * `schemas/my_app/tables/users`.
+ */
+function deriveRenamesFromSchemaMapping(moduleDir, schemaMapping) {
+    const renames = new Map();
+    const planPath = (0, path_1.join)(moduleDir, 'pgpm.plan');
+    const plan = (0, parser_1.parsePlanFileSimple)(planPath);
+    const schemas = Array.from(schemaMapping.keys()).sort((a, b) => b.length - a.length);
+    for (const change of plan.changes) {
+        let renamed = change.name;
+        for (const schema of schemas) {
+            const to = schemaMapping.get(schema);
+            if (!to || to === schema)
+                continue;
+            const re = new RegExp(`(^|/)(schemas/)${escapeRe(schema)}(/|$)`, 'g');
+            renamed = renamed.replace(re, `$1$2${to}$3`);
+        }
+        if (renamed !== change.name) {
+            renames.set(change.name, renamed);
+        }
+    }
+    return renames;
+}

package/resolution/deps.js

@@ -6,6 +6,7 @@ const glob_1 = require("glob");
 const path_1 = require("path");
 const pgpm_1 = require("../core/class/pgpm");
 const parser_1 = require("../files/plan/parser");
+const header_1 = require("../files/sql/header");
 const types_1 = require("@pgpmjs/types");
 /**
  * Core dependency resolution algorithm that handles circular dependency detection
@@ -337,84 +338,46 @@ const resolveDependencies = (packageDir, extname, options = {}) => {
     const files = (0, glob_1.sync)(`${packageDir}/deploy/**/*.sql`).sort((a, b) => a.localeCompare(b));
     for (const file of files) {
         const data = (0, fs_1.readFileSync)(file, 'utf-8');
-        const lines = data.split('\n');
         const key = '/' + (0, path_1.relative)(packageDir, file);
         deps[key] = [];
-        for (const line of lines) {
-            // Handle requires statements
-            const requiresMatch = line.match(/^-- requires: (.*)/);
-            if (requiresMatch) {
-                const dep = requiresMatch[1].trim();
-                // For 'preserve' mode, just add the dependency as-is (like original getDeps)
-                if (tagResolution === 'preserve') {
-                    deps[key].push(dep);
-                    continue;
-                }
-                // For other modes, handle tag resolution
-                if (dep.includes('@')) {
-                    const match = dep.match(/^([^:]+):@(.+)$/);
-                    if (match) {
-                        const [, projectName, tagName] = match;
-                        const taggedChange = resolveTagToChange(projectName, tagName);
-                        if (taggedChange) {
-                            if (tagResolution === 'resolve') {
-                                // Full resolution: replace tag with actual change
-                                const resolvedDep = `${projectName}:${taggedChange}`;
-                                deps[key].push(resolvedDep);
-                            }
-                            else if (tagResolution === 'internal') {
-                                // Internal resolution: keep tag in deps but track mapping
-                                tagMappings[dep] = `${projectName}:${taggedChange}`;
-                                deps[key].push(dep);
-                            }
+        const { requires } = (0, header_1.scanDeployScript)(data, { key, extname, makeKey });
+        for (const dep of requires) {
+            // For 'preserve' mode, just add the dependency as-is (like original getDeps)
+            if (tagResolution === 'preserve') {
+                deps[key].push(dep);
+                continue;
+            }
+            // For other modes, handle tag resolution
+            if (dep.includes('@')) {
+                const match = dep.match(/^([^:]+):@(.+)$/);
+                if (match) {
+                    const [, projectName, tagName] = match;
+                    const taggedChange = resolveTagToChange(projectName, tagName);
+                    if (taggedChange) {
+                        if (tagResolution === 'resolve') {
+                            // Full resolution: replace tag with actual change
+                            const resolvedDep = `${projectName}:${taggedChange}`;
+                            deps[key].push(resolvedDep);
                         }
-                        else {
-                            // Could not resolve tag, keep it as is
+                        else if (tagResolution === 'internal') {
+                            // Internal resolution: keep tag in deps but track mapping
+                            tagMappings[dep] = `${projectName}:${taggedChange}`;
                             deps[key].push(dep);
                         }
                     }
                     else {
-                        // Invalid tag format, keep as is
+                        // Could not resolve tag, keep it as is
                         deps[key].push(dep);
                     }
                 }
                 else {
-                    // Not a tag, keep as is
+                    // Invalid tag format, keep as is
                     deps[key].push(dep);
                 }
-                continue;
-            }
-            // Handle deploy statements - exactly as in original
-            let m2;
-            let keyToTest;
-            if (/:/.test(line)) {
-                m2 = line.match(/^-- Deploy ([^:]*):([\w\/]+)(?:\s+to\s+pg)?/);
-                if (m2) {
-                    const actualProject = m2[1];
-                    keyToTest = m2[2];
-                    if (extname !== actualProject) {
-                        throw new Error(`Mismatched project name in deploy file:
-          Expected project: ${extname}
-          Found in line   : ${actualProject}
-          Line            : ${line}`);
-                    }
-                    const expectedKey = makeKey(keyToTest);
-                    if (key !== expectedKey) {
-                        throw new Error(`Deployment script path or internal name mismatch:
-          Expected key    : ${key}
-          Found in line   : ${expectedKey}
-          Line            : ${line}`);
-                    }
-                }
             }
             else {
-                m2 = line.match(/^-- Deploy (.*?)(?:\s+to\s+pg)?\s*$/);
-                if (m2) {
-                    keyToTest = m2[1].trim();
-                    if (key !== makeKey(keyToTest)) {
-                        throw new Error('deployment script in wrong place or is named wrong internally\n' + line);
-                    }
-                }
+                // Not a tag, keep as is
+                deps[key].push(dep);
             }
         }
     }

package/slice/slice.d.ts

@@ -1,5 +1,5 @@
 import { Change, Tag, ExtendedPlanFile } from '../files/types';
-import { SliceConfig, SliceResult, DependencyGraph, PackageOutput, GroupingStrategy, PatternStrategy } from './types';
+import { SliceConfig, SliceResult, DependencyGraph, PackageOutput, GroupingStrategy, PatternStrategy, CrossPackageDepMode } from './types';
 /**
  * Build a dependency graph from a parsed plan file
  */
@@ -52,7 +52,7 @@ export declare function generateControlContent(pkgName: string, deps: Set<string
 /**
  * Generate a single package output
  */
-export declare function generateSinglePackage(pkgName: string, changes: Set<string>, graph: DependencyGraph, changeToPackage: Map<string, string>, pkgDeps: Set<string>, useTagsForCrossPackageDeps?: boolean): PackageOutput;
+export declare function generateSinglePackage(pkgName: string, changes: Set<string>, graph: DependencyGraph, changeToPackage: Map<string, string>, pkgDeps: Set<string>, crossPackageDeps?: boolean | CrossPackageDepMode): PackageOutput;
 /**
  * Main slicing function
  */

package/slice/slice.js

@@ -356,7 +356,9 @@ function generateControlContent(pkgName, deps) {
 /**
  * Generate a single package output
  */
-function generateSinglePackage(pkgName, changes, graph, changeToPackage, pkgDeps, useTagsForCrossPackageDeps = false) {
+function generateSinglePackage(pkgName, changes, graph, changeToPackage, pkgDeps, crossPackageDeps = 'change') {
+    // Back-compat: earlier signature took useTagsForCrossPackageDeps: boolean
+    const crossPackageDepMode = crossPackageDeps === true ? 'tag' : crossPackageDeps === false ? 'change' : crossPackageDeps;
     // Sort changes in topological order within package
     const sortedChanges = topologicalSortWithinPackage(changes, graph);
     // Build plan entries with updated dependencies
@@ -377,7 +379,13 @@ function generateSinglePackage(pkgName, changes, graph, changeToPackage, pkgDeps
             }
             else {
                 // Cross-package dependency
-                if (useTagsForCrossPackageDeps) {
+                if (crossPackageDepMode === 'control-only') {
+                    // Dropped from the plan line; carried by the control file's
+                    // `requires` (extension install ordering deploys the whole
+                    // dependency package first)
+                    continue;
+                }
+                if (crossPackageDepMode === 'tag') {
                     // Find latest tag in the dependency package
                     const depPkgChanges = [...graph.nodes.keys()]
                         .filter(c => changeToPackage.get(c) === depPkg);
@@ -477,7 +485,7 @@ function slicePlan(config) {
         const changes = assignments.get(pkgName);
         if (!changes || changes.size === 0)
             continue;
-        const pkgOutput = generateSinglePackage(pkgName, changes, graph, changeToPackage, packageDeps.get(pkgName) || new Set(), config.useTagsForCrossPackageDeps || false);
+        const pkgOutput = generateSinglePackage(pkgName, changes, graph, changeToPackage, packageDeps.get(pkgName) || new Set(), config.crossPackageDepMode ?? (config.useTagsForCrossPackageDeps ? 'tag' : 'change'));
         packages.push(pkgOutput);
         // Check for heavy cross-package dependencies
         let crossDeps = 0;

package/slice/types.d.ts

@@ -13,11 +13,26 @@ export interface SliceConfig {
     defaultPackage?: string;
     /** Whether to use tags for cross-package deps */
     useTagsForCrossPackageDeps?: boolean;
+    /**
+     * How cross-package dependencies are recorded in sliced plans:
+     * - 'change' (default): per-change refs (`{package}:{change}`)
+     * - 'tag': per-change tag refs (`{package}:@tag`) when available
+     *   (equivalent to `useTagsForCrossPackageDeps: true`)
+     * - 'control-only': drop per-change cross-package refs from plan lines
+     *   entirely; the dependency is carried only by the control file's
+     *   `requires` (extension install ordering deploys the whole dependency
+     *   package first, which subsumes any per-change ordering constraint)
+     */
+    crossPackageDepMode?: CrossPackageDepMode;
     /** Minimum changes per package (merge smaller groups) */
     minChangesPerPackage?: number;
     /** Author for generated plan files */
     author?: string;
 }
+/**
+ * How cross-package dependencies are represented in sliced plan files
+ */
+export type CrossPackageDepMode = 'change' | 'tag' | 'control-only';
 /**
  * Grouping strategy for slicing
  */