@pgpmjs/ast 0.1.0

package/esm/utils/author.js

@@ -0,0 +1,11 @@
+export function parseAuthor(author) {
+    const trimmed = (author || '').trim();
+    const match = trimmed.match(/^(.+?)\s*<([^>]+)>$/);
+    if (match) {
+        return {
+            fullName: match[1].trim(),
+            email: match[2].trim()
+        };
+    }
+    return { fullName: trimmed };
+}

package/files/extension/index.d.ts

@@ -0,0 +1,2 @@
+export * from './reader';
+export * from './writer';

package/files/extension/index.js

@@ -0,0 +1,19 @@
+"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 extension functionality
+__exportStar(require("./reader"), exports);
+__exportStar(require("./writer"), exports);

package/files/extension/reader.d.ts

@@ -0,0 +1,24 @@
+import { ExtensionInfo } from './writer';
+export interface Module {
+    path: string;
+    requires: string[];
+    version: string;
+}
+/**
+ * Parse a .control file and extract its metadata.
+ * https://www.postgresql.org/docs/current/extend-extensions.html
+ */
+export declare function parseControlFile(filePath: string, basePath: string): Module;
+/**
+ * Parse the pgpm.plan file to get the extension name.
+ */
+export declare const getExtensionName: (packageDir: string) => string;
+/**
+ * Get detailed information about an extension in the specified directory.
+ */
+export declare const getExtensionInfo: (packageDir: string) => ExtensionInfo;
+/**
+ * Get a list of extensions required by an extension from its control file.
+ * Returns an empty array if the file doesn't exist or has no requires line.
+ */
+export declare const getInstalledExtensions: (controlFilePath: string) => string[];

package/files/extension/reader.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getInstalledExtensions = exports.getExtensionInfo = exports.getExtensionName = void 0;
+exports.parseControlFile = parseControlFile;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const plan_1 = require("../plan");
+/**
+ * Parse a .control file and extract its metadata.
+ * https://www.postgresql.org/docs/current/extend-extensions.html
+ */
+function parseControlFile(filePath, basePath) {
+    const contents = (0, fs_1.readFileSync)(filePath, 'utf-8');
+    const key = (0, path_1.basename)(filePath).split('.control')[0];
+    const requires = contents
+        .split('\n')
+        .find((line) => /^requires/.test(line))
+        ?.split('=')[1]
+        .split(',')
+        .map((req) => req.replace(/[\'\s]*/g, '').trim()) || [];
+    const version = contents
+        .split('\n')
+        .find((line) => /^default_version/.test(line))
+        ?.split('=')[1]
+        .replace(/[\']*/g, '')
+        .trim() || '';
+    return {
+        path: (0, path_1.dirname)((0, path_1.relative)(basePath, filePath)),
+        requires,
+        version,
+    };
+}
+/**
+ * Parse the pgpm.plan file to get the extension name.
+ */
+const getExtensionName = (packageDir) => {
+    const planPath = `${packageDir}/pgpm.plan`;
+    const plan = (0, plan_1.parsePlanFileSimple)(planPath);
+    if (!plan.package) {
+        throw new Error('No package name found in pgpm.plan!');
+    }
+    return plan.package;
+};
+exports.getExtensionName = getExtensionName;
+/**
+ * Get detailed information about an extension in the specified directory.
+ */
+const getExtensionInfo = (packageDir) => {
+    const pkgPath = `${packageDir}/package.json`;
+    const pkg = require(pkgPath);
+    const extname = (0, exports.getExtensionName)(packageDir);
+    const version = pkg.version;
+    const Makefile = `${packageDir}/Makefile`;
+    const controlFile = `${packageDir}/${extname}.control`;
+    const sqlFile = `sql/${extname}--${version}.sql`;
+    return { extname, packageDir, version, Makefile, controlFile, sqlFile };
+};
+exports.getExtensionInfo = getExtensionInfo;
+/**
+ * Get a list of extensions required by an extension from its control file.
+ * Returns an empty array if the file doesn't exist or has no requires line.
+ */
+const getInstalledExtensions = (controlFilePath) => {
+    try {
+        const contents = (0, fs_1.readFileSync)(controlFilePath, 'utf-8');
+        const match = contents.match(/^\s*requires\s*=\s*'([^']*)'/m);
+        if (!match) {
+            return [];
+        }
+        const requiresValue = match[1];
+        if (!requiresValue || requiresValue.trim() === '') {
+            return [];
+        }
+        return requiresValue
+            .split(',')
+            .map((ext) => ext.trim())
+            .filter((ext) => ext.length > 0);
+    }
+    catch (e) {
+        if (e.code === 'ENOENT') {
+            return [];
+        }
+        throw new Error(`Error reading control file at ${controlFilePath}: ${e.message}`);
+    }
+};
+exports.getInstalledExtensions = getInstalledExtensions;

package/files/extension/writer.d.ts

@@ -0,0 +1,48 @@
+/**
+ * Write the Makefile for the extension.
+ */
+export declare const writeExtensionMakefile: (outputPath: string, extname: string, version: string) => void;
+/**
+ * Generate content for a .control file
+ * https://www.postgresql.org/docs/current/extend-extensions.html
+ */
+export declare function generateControlFileContent(options: {
+    name: string;
+    version: string;
+    comment?: string;
+    requires?: string[];
+    default_version?: string;
+    relocatable?: boolean;
+    superuser?: boolean;
+    schema?: string;
+    module_pathname?: string;
+}): string;
+/**
+ * Update (or insert/remove) the `requires =` line of an existing .control file
+ * in place, preserving every other field and the file's formatting. Used when
+ * changing a module's dependencies after init (e.g. via `pgpm extension`) so
+ * hand-tuned fields (comment, schema, relocatable, module_pathname) survive.
+ */
+export declare function upsertRequiresLine(content: string, requires: string[]): string;
+/**
+ * Write the control file for the extension.
+ * If the file already exists, only its `requires` line is updated so that any
+ * custom fields are preserved; otherwise a fresh file is generated.
+ */
+export declare const writeExtensionControlFile: (outputPath: string, extname: string, extensions: string[], version: string) => void;
+/**
+ * Interface for extension information
+ */
+export interface ExtensionInfo {
+    extname: string;
+    packageDir: string;
+    version: string;
+    Makefile: string;
+    controlFile: string;
+    sqlFile: string;
+}
+/**
+ * Write control and Makefile for the extension with given data.
+ * If extInfo is not provided, it will be generated from packageDir.
+ */
+export declare const writeExtensions: (packageDir: string, extensions: string[], extInfo?: ExtensionInfo) => void;

package/files/extension/writer.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.writeExtensions = exports.writeExtensionControlFile = exports.writeExtensionMakefile = void 0;
+exports.generateControlFileContent = generateControlFileContent;
+exports.upsertRequiresLine = upsertRequiresLine;
+const fs_1 = require("fs");
+const reader_1 = require("./reader");
+/**
+ * Write the Makefile for the extension.
+ */
+const writeExtensionMakefile = (outputPath, extname, version) => {
+    const content = `EXTENSION = ${extname}
+DATA = sql/${extname}--${version}.sql
+
+PG_CONFIG = pg_config
+PGXS := $(shell $(PG_CONFIG) --pgxs)
+include $(PGXS)
+  `;
+    (0, fs_1.writeFileSync)(outputPath, content);
+};
+exports.writeExtensionMakefile = writeExtensionMakefile;
+/**
+ * Generate content for a .control file
+ * https://www.postgresql.org/docs/current/extend-extensions.html
+ */
+function generateControlFileContent(options) {
+    const { name, version, comment = `${name} extension`, requires = [], default_version = version, relocatable = false, superuser = false, schema, module_pathname } = options;
+    let content = `# ${name} extension
+comment = '${comment}'
+default_version = '${default_version}'
+`;
+    if (module_pathname) {
+        content += `module_pathname = '${module_pathname}'\n`;
+    }
+    else {
+        content += `module_pathname = '$libdir/${name}'\n`;
+    }
+    if (requires.length > 0) {
+        content += `requires = '${requires.join(',')}'\n`;
+    }
+    content += `relocatable = ${relocatable}
+superuser = ${superuser}\n`;
+    if (schema) {
+        content += `schema = ${schema}\n`;
+    }
+    return content;
+}
+/**
+ * Update (or insert/remove) the `requires =` line of an existing .control file
+ * in place, preserving every other field and the file's formatting. Used when
+ * changing a module's dependencies after init (e.g. via `pgpm extension`) so
+ * hand-tuned fields (comment, schema, relocatable, module_pathname) survive.
+ */
+function upsertRequiresLine(content, requires) {
+    const lines = content.split('\n');
+    const idx = lines.findIndex((line) => /^\s*requires\s*=/.test(line));
+    if (requires.length === 0) {
+        if (idx !== -1)
+            lines.splice(idx, 1);
+        return lines.join('\n');
+    }
+    const requiresLine = `requires = '${requires.join(',')}'`;
+    if (idx !== -1) {
+        lines[idx] = requiresLine;
+        return lines.join('\n');
+    }
+    // Insert to match generated ordering (before relocatable/superuser/schema).
+    const insertAt = lines.findIndex((line) => /^\s*(relocatable|superuser|schema)\s*=/.test(line));
+    if (insertAt !== -1) {
+        lines.splice(insertAt, 0, requiresLine);
+    }
+    else {
+        lines.push(requiresLine);
+    }
+    return lines.join('\n');
+}
+/**
+ * Write the control file for the extension.
+ * If the file already exists, only its `requires` line is updated so that any
+ * custom fields are preserved; otherwise a fresh file is generated.
+ */
+const writeExtensionControlFile = (outputPath, extname, extensions, version) => {
+    if ((0, fs_1.existsSync)(outputPath)) {
+        const existing = (0, fs_1.readFileSync)(outputPath, 'utf-8');
+        (0, fs_1.writeFileSync)(outputPath, upsertRequiresLine(existing, extensions));
+        return;
+    }
+    const content = generateControlFileContent({
+        name: extname,
+        version,
+        requires: extensions
+    });
+    (0, fs_1.writeFileSync)(outputPath, content);
+};
+exports.writeExtensionControlFile = writeExtensionControlFile;
+/**
+ * Write control and Makefile for the extension with given data.
+ * If extInfo is not provided, it will be generated from packageDir.
+ */
+const writeExtensions = (packageDir, extensions, extInfo) => {
+    // If extInfo is not provided, get it from packageDir
+    const info = extInfo || (0, reader_1.getExtensionInfo)(packageDir);
+    const { controlFile, Makefile, extname, version } = info;
+    (0, exports.writeExtensionControlFile)(controlFile, extname, extensions, version);
+    (0, exports.writeExtensionMakefile)(Makefile, extname, version);
+};
+exports.writeExtensions = writeExtensions;

package/files/index.d.ts

@@ -0,0 +1,5 @@
+export * from './extension';
+export * from './plan';
+export * from './sql';
+export * from './sql-scripts';
+export * from './types';

package/files/index.js

@@ -0,0 +1,22 @@
+"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 functionality from package-files
+__exportStar(require("./extension"), exports);
+__exportStar(require("./plan"), exports);
+__exportStar(require("./sql"), exports);
+__exportStar(require("./sql-scripts"), exports);
+__exportStar(require("./types"), exports);

package/files/plan/generator.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Get a timestamp for the plan file.
+ * Uses the PGPM_FROZEN_TIME env var if present, otherwise the fixed epoch.
+ */
+export declare function getNow(): string;
+export interface PlanEntry {
+    change: string;
+    dependencies: string[];
+    comment?: string;
+}
+export interface GeneratePlanOptions {
+    moduleName: string;
+    uri?: string;
+    entries: PlanEntry[];
+}
+/**
+ * Generate a plan file content from structured data
+ */
+export declare function generatePlan(options: GeneratePlanOptions): string;
+/**
+ * Write a generated plan file to disk
+ */
+export declare function writePlan(planPath: string, plan: string): void;

package/files/plan/generator.js

@@ -0,0 +1,90 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNow = getNow;
+exports.generatePlan = generatePlan;
+exports.writePlan = writePlan;
+const fs_1 = __importDefault(require("fs"));
+/**
+ * Fixed epoch timestamp used for deterministic plan generation.
+ * Can be overridden with the PGPM_FROZEN_TIME environment variable.
+ */
+const DEFAULT_FROZEN_TIME = '2017-08-11T08:11:51Z';
+/**
+ * Get a UTC timestamp string from a Date object.
+ */
+function getUTCTimestamp(d) {
+    return (d.getUTCFullYear() +
+        '-' + String(d.getUTCMonth() + 1).padStart(2, '0') +
+        '-' + String(d.getUTCDate()).padStart(2, '0') +
+        'T' + String(d.getUTCHours()).padStart(2, '0') +
+        ':' + String(d.getUTCMinutes()).padStart(2, '0') +
+        ':' + String(d.getUTCSeconds()).padStart(2, '0') +
+        'Z');
+}
+/**
+ * Get a timestamp for the plan file.
+ * Uses the PGPM_FROZEN_TIME env var if present, otherwise the fixed epoch.
+ */
+function getNow() {
+    const frozen = process.env.PGPM_FROZEN_TIME;
+    if (frozen) {
+        return getUTCTimestamp(new Date(frozen));
+    }
+    return DEFAULT_FROZEN_TIME;
+}
+/**
+ * Sort dependencies by their order in the supplied plan, so prerequisites
+ * (parent migrations) appear before their dependents in the bracket.
+ * Internal dependencies are sorted by their plan index, and external
+ * dependencies (not in the plan) preserve their original order.
+ */
+const sortDependencies = (deps, order) => {
+    const originalOrder = new Map(deps.map((dep, index) => [dep, index]));
+    return [...deps].sort((a, b) => {
+        const aIndex = order.get(a);
+        const bIndex = order.get(b);
+        const aOriginal = originalOrder.get(a);
+        const bOriginal = originalOrder.get(b);
+        if (aIndex !== undefined && bIndex !== undefined)
+            return aIndex - bIndex || aOriginal - bOriginal;
+        if (aIndex !== undefined)
+            return -1;
+        if (bIndex !== undefined)
+            return 1;
+        return aOriginal - bOriginal;
+    });
+};
+/**
+ * Generate a plan file content from structured data
+ */
+function generatePlan(options) {
+    const { moduleName, uri, entries } = options;
+    const now = getNow();
+    const planfile = [
+        `%syntax-version=1.0.0`,
+        `%project=${moduleName}`,
+        `%uri=${uri || moduleName}`
+    ];
+    // Build an order map from the entry list so brackets can be sorted by plan order
+    const entryOrder = new Map(entries.map((entry, index) => [entry.change, index]));
+    // Generate the plan entries
+    entries.forEach(entry => {
+        const deps = sortDependencies(entry.dependencies || [], entryOrder);
+        if (deps.length > 0) {
+            planfile.push(`${entry.change} [${deps.join(' ')}] ${now} constructive <constructive@5b0c196eeb62>${entry.comment ? ` # ${entry.comment}` : ''}`);
+        }
+        else {
+            planfile.push(`${entry.change} ${now} constructive <constructive@5b0c196eeb62>${entry.comment ? ` # ${entry.comment}` : ''}`);
+        }
+    });
+    return planfile.join('\n');
+}
+/**
+ * Write a generated plan file to disk
+ */
+function writePlan(planPath, plan) {
+    fs_1.default.writeFileSync(planPath, plan);
+}

package/files/plan/index.d.ts

@@ -0,0 +1,4 @@
+export * from './generator';
+export * from './parser';
+export * from './validators';
+export * from './writer';

package/files/plan/index.js

@@ -0,0 +1,21 @@
+"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 plan functionality
+__exportStar(require("./generator"), exports);
+__exportStar(require("./parser"), exports);
+__exportStar(require("./validators"), exports);
+__exportStar(require("./writer"), exports);

package/files/plan/parser.d.ts

@@ -0,0 +1,28 @@
+import { ExtendedPlanFile, ParseResult, PlanFile } from '../types';
+/**
+ * Parse a Sqitch plan file with full validation
+ * Supports both changes and tags
+ */
+export declare function parsePlanFile(planPath: string): ParseResult<ExtendedPlanFile>;
+/**
+ * Resolve a reference within a plan file context
+ * Handles symbolic references (HEAD, ROOT) and relative references
+ */
+export declare function resolveReference(ref: string, plan: ExtendedPlanFile, currentPackage?: string): {
+    change?: string;
+    tag?: string;
+    error?: string;
+};
+/**
+ * Simple plan file parser without validation.
+ * Returns a PlanFile (without tags) for callers that don't need tag data.
+ */
+export declare function parsePlanFileSimple(planPath: string): PlanFile;
+/**
+ * Get all change names from a plan file
+ */
+export declare function getChanges(planPath: string): string[];
+/**
+ * Get the latest (last) change from a plan file
+ */
+export declare function getLatestChange(planPath: string): string;