@pgpmjs/core 6.33.0 → 6.34.0

package/esm/index.js

@@ -13,6 +13,7 @@ export * from './core/boilerplate-types';
 export * from './core/boilerplate-scanner';
 // Export package-files functionality (now integrated into core)
 export * from './files';
+export * from './refactor';
 export { cleanSql } from './migrate/clean';
 export { PgpmMigrate } from './migrate/client';
 export { PgpmInit } from './init/client';

package/esm/refactor/index.js

@@ -0,0 +1 @@
+export * from './rename';

package/esm/refactor/rename.js

@@ -0,0 +1,200 @@
+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';
+const SCRIPT_DIRS = ['deploy', 'revert', 'verify'];
+function escapeRe(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function findSqlFiles(dir) {
+    const files = [];
+    if (!existsSync(dir))
+        return files;
+    const entries = readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+        const fullPath = 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 (!existsSync(current) || readdirSync(current).length > 0)
+            return;
+        rmdirSync(current);
+        current = 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.
+ */
+export function validateRenames(moduleDir, renames) {
+    const planPath = join(moduleDir, 'pgpm.plan');
+    const plan = 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.
+ */
+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
+ * 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).
+ */
+export 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 = join(moduleDir, scriptDir, `${from}.sql`);
+            if (!existsSync(oldPath) || !statSync(oldPath).isFile())
+                continue;
+            const newPath = join(moduleDir, scriptDir, `${to}.sql`);
+            if (existsSync(newPath)) {
+                throw new Error(`Rename target file already exists: ${relative(moduleDir, newPath)}`);
+            }
+            if (dryRun) {
+                result.dryRunReport.push(`Would move: ${relative(moduleDir, oldPath)} -> ${relative(moduleDir, newPath)}`);
+            }
+            else {
+                mkdirSync(dirname(newPath), { recursive: true });
+                renameSync(oldPath, newPath);
+                removeEmptyDirs(dirname(oldPath), join(moduleDir, scriptDir));
+            }
+            result.filesMoved.push({
+                from: [scriptDir, `${from}.sql`].join(sep),
+                to: [scriptDir, `${to}.sql`].join(sep)
+            });
+        }
+    }
+    // 2 + 3. Rewrite headers in every script (identity of moved files,
+    // requires of dependents)
+    for (const scriptDir of SCRIPT_DIRS) {
+        const dir = join(moduleDir, scriptDir);
+        for (const file of findSqlFiles(dir)) {
+            const content = readFileSync(file, 'utf-8');
+            const script = parsePgpmHeader(content);
+            const count = renameInHeader(script, renames);
+            if (count === 0)
+                continue;
+            const rewritten = writePgpmScript(script);
+            if (rewritten === content)
+                continue;
+            if (dryRun) {
+                result.dryRunReport.push(`Would rewrite header: ${relative(moduleDir, file)}`);
+            }
+            else {
+                writeFileSync(file, rewritten);
+            }
+            result.headersRewritten.push(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 = join(moduleDir, 'pgpm.plan');
+    const planContent = readFileSync(planPath, 'utf-8');
+    const newPlanContent = renameInPlanContent(planContent, renames);
+    if (newPlanContent !== planContent) {
+        if (dryRun) {
+            result.dryRunReport.push('Would rewrite: pgpm.plan');
+        }
+        else {
+            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`.
+ */
+export function deriveRenamesFromSchemaMapping(moduleDir, schemaMapping) {
+    const renames = new Map();
+    const planPath = join(moduleDir, 'pgpm.plan');
+    const plan = 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/index.d.ts

@@ -12,6 +12,7 @@ export * from './core/template-scaffold';
 export * from './core/boilerplate-types';
 export * from './core/boilerplate-scanner';
 export * from './files';
+export * from './refactor';
 export { cleanSql } from './migrate/clean';
 export { PgpmMigrate } from './migrate/client';
 export { PgpmInit } from './init/client';

package/index.js

@@ -30,6 +30,7 @@ __exportStar(require("./core/boilerplate-types"), exports);
 __exportStar(require("./core/boilerplate-scanner"), exports);
 // Export package-files functionality (now integrated into core)
 __exportStar(require("./files"), exports);
+__exportStar(require("./refactor"), exports);
 var clean_1 = require("./migrate/clean");
 Object.defineProperty(exports, "cleanSql", { enumerable: true, get: function () { return clean_1.cleanSql; } });
 var client_1 = require("./migrate/client");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgpmjs/core",
-  "version": "6.33.0",
+  "version": "6.34.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "PGPM Package and Migration Tools",
   "main": "index.js",
@@ -64,5 +64,5 @@
     "pgsql-parser": "^17.9.17",
     "yanse": "^0.2.1"
   },
-  "gitHead": "6a1d3e65a4a786e602efe5ec3835238eb1648734"
+  "gitHead": "08b12923f099191b2d1592b9c897f9f04b4950aa"
 }

package/refactor/index.d.ts

@@ -0,0 +1 @@
+export * from './rename';

package/refactor/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("./rename"), exports);

package/refactor/rename.d.ts

@@ -0,0 +1,59 @@
+/**
+ * Options for {@link renameChanges}.
+ */
+export interface RenameChangesOptions {
+    /** Report planned operations without touching the filesystem. Default: false */
+    dryRun?: boolean;
+}
+/**
+ * Result of a {@link renameChanges} run.
+ */
+export interface RenameChangesResult {
+    /** deploy/revert/verify script files moved (old path -> new path, module-relative). */
+    filesMoved: Array<{
+        from: string;
+        to: string;
+    }>;
+    /** Script files whose headers were rewritten (identity and/or requires). */
+    headersRewritten: string[];
+    /** Whether pgpm.plan was rewritten. */
+    planRewritten: boolean;
+    /** Dry-run report lines (only populated when dryRun). */
+    dryRunReport?: string[];
+}
+/**
+ * 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.
+ */
+export declare function validateRenames(moduleDir: string, renames: Map<string, string>): void;
+/**
+ * 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 declare function renameInPlanContent(content: string, renames: Map<string, string>): string;
+/**
+ * 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).
+ */
+export declare function renameChanges(moduleDir: string, renames: Map<string, string>, options?: RenameChangesOptions): RenameChangesResult;
+/**
+ * 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`.
+ */
+export declare function deriveRenamesFromSchemaMapping(moduleDir: string, schemaMapping: Map<string, string>): Map<string, string>;

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;
+}