@pgpmjs/core 7.0.0 → 7.2.0

package/esm/files/extension/reader.js

@@ -1,79 +0,0 @@
-import { readFileSync } from 'fs';
-import { basename, dirname, relative } from 'path';
-import { parsePlanFileSimple } from '../plan';
-/**
- * Parse a .control file and extract its metadata.
- * https://www.postgresql.org/docs/current/extend-extensions.html
- */
-export function parseControlFile(filePath, basePath) {
-    const contents = readFileSync(filePath, 'utf-8');
-    const key = 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: dirname(relative(basePath, filePath)),
-        requires,
-        version,
-    };
-}
-/**
- * Parse the pgpm.plan file to get the extension name.
- */
-export const getExtensionName = (packageDir) => {
-    const planPath = `${packageDir}/pgpm.plan`;
-    const plan = parsePlanFileSimple(planPath);
-    if (!plan.package) {
-        throw new Error('No package name found in pgpm.plan!');
-    }
-    return plan.package;
-};
-/**
- * Get detailed information about an extension in the specified directory.
- */
-export const getExtensionInfo = (packageDir) => {
-    const pkgPath = `${packageDir}/package.json`;
-    const pkg = require(pkgPath);
-    const extname = 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 };
-};
-/**
- * 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 const getInstalledExtensions = (controlFilePath) => {
-    try {
-        const contents = 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}`);
-    }
-};

package/esm/files/extension/writer.js

@@ -1,99 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from 'fs';
-import { getExtensionInfo } from './reader';
-/**
- * Write the Makefile for the extension.
- */
-export 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)
-  `;
-    writeFileSync(outputPath, content);
-};
-/**
- * Generate content for a .control file
- * https://www.postgresql.org/docs/current/extend-extensions.html
- */
-export 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.
- */
-export 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.
- */
-export const writeExtensionControlFile = (outputPath, extname, extensions, version) => {
-    if (existsSync(outputPath)) {
-        const existing = readFileSync(outputPath, 'utf-8');
-        writeFileSync(outputPath, upsertRequiresLine(existing, extensions));
-        return;
-    }
-    const content = generateControlFileContent({
-        name: extname,
-        version,
-        requires: extensions
-    });
-    writeFileSync(outputPath, content);
-};
-/**
- * Write control and Makefile for the extension with given data.
- * If extInfo is not provided, it will be generated from packageDir.
- */
-export const writeExtensions = (packageDir, extensions, extInfo) => {
-    // If extInfo is not provided, get it from packageDir
-    const info = extInfo || getExtensionInfo(packageDir);
-    const { controlFile, Makefile, extname, version } = info;
-    writeExtensionControlFile(controlFile, extname, extensions, version);
-    writeExtensionMakefile(Makefile, extname, version);
-};

package/esm/files/index.js

@@ -1,6 +0,0 @@
-// Re-export all functionality from package-files
-export * from './extension';
-export * from './plan';
-export * from './sql';
-export * from './sql-scripts';
-export * from './types';

package/esm/files/plan/generator.js

@@ -1,82 +0,0 @@
-import fs from '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.
- */
-export 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
- */
-export 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
- */
-export function writePlan(planPath, plan) {
-    fs.writeFileSync(planPath, plan);
-}

package/esm/files/plan/index.js

@@ -1,5 +0,0 @@
-// Re-export all plan functionality
-export * from './generator';
-export * from './parser';
-export * from './validators';
-export * from './writer';

package/esm/files/plan/parser.js

@@ -1,297 +0,0 @@
-import { readFileSync } from 'fs';
-import { isValidChangeName, isValidDependency, isValidTagName, parseReference } from './validators';
-import { errors } from '@pgpmjs/types';
-/**
- * Parse a Sqitch plan file with full validation
- * Supports both changes and tags
- */
-export function parsePlanFile(planPath) {
-    const content = readFileSync(planPath, 'utf-8');
-    const lines = content.split('\n');
-    let project = '';
-    let uri = '';
-    const changes = [];
-    const tags = [];
-    const errors = [];
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i];
-        const lineNum = i + 1;
-        const trimmed = line.trim();
-        // Skip empty lines
-        if (!trimmed)
-            continue;
-        // Skip comments
-        if (trimmed.startsWith('#'))
-            continue;
-        // Parse package metadata
-        if (trimmed.startsWith('%project=')) {
-            project = trimmed.substring('%project='.length);
-            continue;
-        }
-        if (trimmed.startsWith('%uri=')) {
-            uri = trimmed.substring('%uri='.length);
-            continue;
-        }
-        // Skip other metadata lines
-        if (trimmed.startsWith('%')) {
-            continue;
-        }
-        // Parse tag lines
-        if (trimmed.startsWith('@')) {
-            const lastChangeName = changes.length > 0 ? changes[changes.length - 1].name : null;
-            const tag = parseTagLine(trimmed, lastChangeName);
-            if (tag) {
-                if (isValidTagName(tag.name)) {
-                    tags.push(tag);
-                }
-                else {
-                    errors.push({
-                        line: lineNum,
-                        message: `Invalid tag name: ${tag.name}`
-                    });
-                }
-            }
-            else {
-                errors.push({
-                    line: lineNum,
-                    message: 'Invalid tag line format'
-                });
-            }
-            continue;
-        }
-        // Parse change lines
-        const change = parseChangeLine(trimmed);
-        if (change) {
-            // Validate change name
-            if (!isValidChangeName(change.name)) {
-                errors.push({
-                    line: lineNum,
-                    message: `Invalid change name: ${change.name}`
-                });
-                continue;
-            }
-            // Validate dependencies
-            for (const dep of change.dependencies) {
-                if (!isValidDependency(dep)) {
-                    errors.push({
-                        line: lineNum,
-                        message: `Invalid dependency reference: ${dep}`
-                    });
-                }
-            }
-            changes.push(change);
-        }
-        else if (trimmed) {
-            // Non-empty line that couldn't be parsed
-            errors.push({
-                line: lineNum,
-                message: 'Invalid line format'
-            });
-        }
-    }
-    if (errors.length > 0) {
-        return { errors };
-    }
-    return {
-        data: { package: project, uri, changes, tags },
-        errors: []
-    };
-}
-/**
- * Parse a single change line from a plan file
- * Format: change_name [deps] timestamp planner <email> # comment
- */
-function parseChangeLine(line) {
-    // More flexible regex that handles various formats, including planner names with spaces
-    // Format: change_name [deps] timestamp planner <email> # comment
-    // The timestamp is required if planner/email/comment are present
-    const regex = /^(\S+)(?:\s+\[([^\]]*)\])?(?:\s+(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z)(?:\s+([^<]+?))?(?:\s+<([^>]+)>)?(?:\s+#\s+(.*))?)?$/;
-    const match = line.match(regex);
-    if (!match) {
-        return null;
-    }
-    const [, name, depsStr, timestamp, planner, email, comment] = match;
-    // Parse dependencies
-    const dependencies = depsStr
-        ? depsStr.split(/\s+/).filter(dep => dep.length > 0)
-        : [];
-    return {
-        name,
-        dependencies,
-        timestamp,
-        planner,
-        email,
-        comment
-    };
-}
-/**
- * Parse a tag line from a plan file
- * Format: @tag_name change_name timestamp planner <email> # comment
- */
-function parseTagLine(line, lastChangeName) {
-    // Tag lines start with @
-    if (!line.startsWith('@')) {
-        return null;
-    }
-    // Remove the @ and parse
-    const tagContent = line.substring(1);
-    // Two possible formats:
-    // 1. tagname timestamp planner <email> # comment (tag for last change)
-    // 2. tagname changename timestamp planner <email> # comment (tag for specific change)
-    // First try to match with change name (format 2)
-    const regexWithChange = /^(\S+)\s+(\S+)\s+(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z)\s+(.+?)\s+<([^>]+)>(?:\s+#\s+(.*))?$/;
-    let match = tagContent.match(regexWithChange);
-    if (match) {
-        const [, name, secondToken, timestamp, planner, email, comment] = match;
-        // Check if the second token is a timestamp (format 1) or change name (format 2)
-        if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$/.test(secondToken)) {
-            // Format 1: no change name specified
-            return {
-                name,
-                change: lastChangeName || '', // Tag is associated with the last change
-                timestamp: secondToken,
-                planner: timestamp, // What we thought was timestamp is actually planner
-                email: planner, // Shift everything
-                comment: email || comment
-            };
-        }
-        else {
-            // Format 2: explicit change name
-            return {
-                name,
-                change: secondToken,
-                timestamp,
-                planner,
-                email,
-                comment
-            };
-        }
-    }
-    // Try simple format without change name
-    const regexSimple = /^(\S+)\s+(\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z)\s+(.+?)\s+<([^>]+)>(?:\s+#\s+(.*))?$/;
-    match = tagContent.match(regexSimple);
-    if (!match) {
-        return null;
-    }
-    const [, name, timestamp, planner, email, comment] = match;
-    return {
-        name,
-        change: lastChangeName || '', // Tag is associated with the last change
-        timestamp,
-        planner,
-        email,
-        comment
-    };
-}
-/**
- * Resolve a reference within a plan file context
- * Handles symbolic references (HEAD, ROOT) and relative references
- */
-export function resolveReference(ref, plan, currentPackage) {
-    const parsed = parseReference(ref);
-    if (!parsed) {
-        return { error: `Invalid reference: ${ref}` };
-    }
-    // Handle package qualifier
-    const planPackage = currentPackage || plan.package;
-    if (parsed.package && parsed.package !== planPackage) {
-        // Cross-package reference - return as-is
-        return { change: ref };
-    }
-    // Handle SHA1 references
-    if (parsed.sha1) {
-        // Would need to look up in database
-        return { change: ref };
-    }
-    // Handle symbolic references
-    if (parsed.symbolic === 'HEAD' && plan.changes.length > 0) {
-        return { change: plan.changes[plan.changes.length - 1].name };
-    }
-    if (parsed.symbolic === 'ROOT' && plan.changes.length > 0) {
-        return { change: plan.changes[0].name };
-    }
-    // Handle relative references
-    if (parsed.relative) {
-        const baseResolved = resolveReference(parsed.relative.base, plan, currentPackage);
-        if (baseResolved.error) {
-            return baseResolved;
-        }
-        // Get the change name from the resolved reference
-        const baseChange = baseResolved.change;
-        if (!baseChange) {
-            return { error: `Cannot resolve base reference: ${parsed.relative.base}` };
-        }
-        const changeIndex = plan.changes.findIndex(c => c.name === baseChange);
-        if (changeIndex === -1) {
-            return { error: `Change not found: ${baseChange}` };
-        }
-        let targetIndex;
-        if (parsed.relative.direction === '^') {
-            // Go backwards
-            targetIndex = changeIndex - parsed.relative.count;
-        }
-        else {
-            // Go forwards
-            targetIndex = changeIndex + parsed.relative.count;
-        }
-        if (targetIndex < 0 || targetIndex >= plan.changes.length) {
-            return { error: `Relative reference out of bounds: ${ref}` };
-        }
-        return { change: plan.changes[targetIndex].name };
-    }
-    // Handle tag references
-    if (parsed.tag) {
-        const tag = plan.tags.find(t => t.name === parsed.tag);
-        if (!tag) {
-            return { error: `Tag not found: ${parsed.tag}` };
-        }
-        return { tag: parsed.tag, change: tag.change };
-    }
-    // Handle change@tag format
-    if (parsed.change && parsed.tag) {
-        return { change: parsed.change, tag: parsed.tag };
-    }
-    // Plain change reference
-    if (parsed.change) {
-        // Validate that the change exists in the plan
-        const changeExists = plan.changes.some(c => c.name === parsed.change);
-        if (!changeExists) {
-            return { error: `Change not found: ${parsed.change}` };
-        }
-        return { change: parsed.change };
-    }
-    return { error: `Cannot resolve reference: ${ref}` };
-}
-/**
- * Simple plan file parser without validation.
- * Returns a PlanFile (without tags) for callers that don't need tag data.
- */
-export function parsePlanFileSimple(planPath) {
-    const result = parsePlanFile(planPath);
-    if (result.data) {
-        // Return without tags for simple format
-        const { tags, ...planWithoutTags } = result.data;
-        return planWithoutTags;
-    }
-    // If there are errors, throw with details
-    if (result.errors && result.errors.length > 0) {
-        const errorMessages = result.errors.map(e => `Line ${e.line}: ${e.message}`).join('\n');
-        throw errors.PLAN_PARSE_ERROR({ planPath, errors: errorMessages });
-    }
-    // Return empty plan if no data and no errors
-    return { package: '', uri: '', changes: [] };
-}
-/**
- * Get all change names from a plan file
- */
-export function getChanges(planPath) {
-    const plan = parsePlanFileSimple(planPath);
-    return plan.changes.map(change => change.name);
-}
-/**
- * Get the latest (last) change from a plan file
- */
-export function getLatestChange(planPath) {
-    const changes = getChanges(planPath);
-    return changes[changes.length - 1] || '';
-}