@pgpmjs/core 7.4.2 → 7.5.0

package/esm/slice/slice.js

@@ -1,503 +0,0 @@
-import { parsePlanFile } from '@pgpmjs/ast/files/plan/parser';
-import { generateChangeLineContent, generateTagLineContent } from '@pgpmjs/ast/files/plan/writer';
-import { minimatch } from 'minimatch';
-/**
- * Build a dependency graph from a parsed plan file
- */
-export function buildDependencyGraph(plan) {
-    const graph = {
-        nodes: new Map(),
-        edges: new Map(),
-        reverseEdges: new Map(),
-        tags: new Map(),
-        plan
-    };
-    // Add all changes as nodes
-    for (const change of plan.changes) {
-        graph.nodes.set(change.name, change);
-        graph.edges.set(change.name, new Set(change.dependencies || []));
-        // Build reverse edges for dependency analysis
-        for (const dep of change.dependencies || []) {
-            if (!graph.reverseEdges.has(dep)) {
-                graph.reverseEdges.set(dep, new Set());
-            }
-            graph.reverseEdges.get(dep).add(change.name);
-        }
-    }
-    // Index tags by change
-    for (const tag of plan.tags || []) {
-        if (!graph.tags.has(tag.change)) {
-            graph.tags.set(tag.change, []);
-        }
-        graph.tags.get(tag.change).push(tag);
-    }
-    return graph;
-}
-/**
- * Validate that the dependency graph is a DAG (no cycles)
- */
-export function validateDAG(graph) {
-    const visited = new Set();
-    const visiting = new Set();
-    function dfs(node, path) {
-        if (visiting.has(node)) {
-            throw new Error(`Cycle detected: ${[...path, node].join(' -> ')}`);
-        }
-        if (visited.has(node))
-            return;
-        visiting.add(node);
-        const deps = graph.edges.get(node) || new Set();
-        for (const dep of deps) {
-            // Only follow internal dependencies
-            if (graph.nodes.has(dep)) {
-                dfs(dep, [...path, node]);
-            }
-        }
-        visiting.delete(node);
-        visited.add(node);
-    }
-    for (const node of graph.nodes.keys()) {
-        dfs(node, []);
-    }
-}
-/**
- * Extract package name from a change path using folder-based strategy
- */
-export function extractPackageFromPath(changeName, depth = 1, prefixToStrip = 'schemas') {
-    const parts = changeName.split('/');
-    // Handle special folders that should go to core
-    if (parts[0] === 'extensions' || parts[0] === 'migrate') {
-        return 'core';
-    }
-    // Strip prefix if present
-    let startIdx = 0;
-    if (parts[0] === prefixToStrip) {
-        startIdx = 1;
-    }
-    // Get package name at specified depth
-    if (parts.length > startIdx) {
-        // For depth > 1, join multiple segments
-        const endIdx = Math.min(startIdx + depth, parts.length - 1);
-        if (endIdx > startIdx) {
-            return parts.slice(startIdx, endIdx).join('/');
-        }
-        return parts[startIdx];
-    }
-    return 'core';
-}
-/**
- * Find the matching package for a change using pattern-based strategy.
- * Returns the first matching slice's package name, or undefined if no match.
- */
-export function findMatchingPattern(changeName, strategy) {
-    for (const slice of strategy.slices) {
-        for (const pattern of slice.patterns) {
-            if (minimatch(changeName, pattern, { dot: true })) {
-                return slice.packageName;
-            }
-        }
-    }
-    return undefined;
-}
-/**
- * Assign changes to packages based on grouping strategy
- */
-export function assignChangesToPackages(graph, strategy, defaultPackage = 'core') {
-    const assignments = new Map();
-    for (const [changeName] of graph.nodes) {
-        let packageName;
-        switch (strategy.type) {
-            case 'folder': {
-                const depth = strategy.depth ?? 1;
-                const prefix = strategy.prefixToStrip ?? 'schemas';
-                packageName = extractPackageFromPath(changeName, depth, prefix);
-                break;
-            }
-            case 'pattern': {
-                const matched = findMatchingPattern(changeName, strategy);
-                packageName = matched || defaultPackage;
-                break;
-            }
-            case 'explicit': {
-                packageName = strategy.mapping[changeName] || defaultPackage;
-                break;
-            }
-            default:
-                packageName = defaultPackage;
-        }
-        // Fallback to default package
-        if (!packageName) {
-            packageName = defaultPackage;
-        }
-        if (!assignments.has(packageName)) {
-            assignments.set(packageName, new Set());
-        }
-        assignments.get(packageName).add(changeName);
-    }
-    return assignments;
-}
-/**
- * Merge small packages into larger ones
- */
-export function mergeSmallPackages(assignments, minChanges, defaultPackage = 'core') {
-    const result = new Map();
-    // Ensure default package exists
-    if (!result.has(defaultPackage)) {
-        result.set(defaultPackage, new Set());
-    }
-    for (const [pkg, changes] of assignments) {
-        if (changes.size < minChanges && pkg !== defaultPackage) {
-            // Merge into default package
-            const defaultChanges = result.get(defaultPackage);
-            for (const change of changes) {
-                defaultChanges.add(change);
-            }
-        }
-        else {
-            result.set(pkg, new Set(changes));
-        }
-    }
-    // Remove empty default package if it exists
-    if (result.get(defaultPackage)?.size === 0) {
-        result.delete(defaultPackage);
-    }
-    return result;
-}
-/**
- * Build package-level dependency graph
- */
-export function buildPackageDependencies(graph, assignments) {
-    const packageDeps = new Map();
-    // Build reverse lookup: change -> package
-    const changeToPackage = new Map();
-    for (const [pkg, changes] of assignments) {
-        packageDeps.set(pkg, new Set());
-        for (const change of changes) {
-            changeToPackage.set(change, pkg);
-        }
-    }
-    // Check each change's dependencies
-    for (const [changeName, deps] of graph.edges) {
-        const myPackage = changeToPackage.get(changeName);
-        if (!myPackage)
-            continue;
-        for (const dep of deps) {
-            const depPackage = changeToPackage.get(dep);
-            if (depPackage && depPackage !== myPackage) {
-                // Cross-package dependency
-                packageDeps.get(myPackage).add(depPackage);
-            }
-        }
-    }
-    return packageDeps;
-}
-/**
- * Detect cycles in package dependency graph
- */
-export function detectPackageCycle(deps) {
-    const visited = new Set();
-    const visiting = new Set();
-    function dfs(pkg, path) {
-        if (visiting.has(pkg)) {
-            return [...path, pkg];
-        }
-        if (visited.has(pkg))
-            return null;
-        visiting.add(pkg);
-        const pkgDeps = deps.get(pkg) || new Set();
-        for (const dep of pkgDeps) {
-            const cycle = dfs(dep, [...path, pkg]);
-            if (cycle)
-                return cycle;
-        }
-        visiting.delete(pkg);
-        visited.add(pkg);
-        return null;
-    }
-    for (const pkg of deps.keys()) {
-        const cycle = dfs(pkg, []);
-        if (cycle)
-            return cycle;
-    }
-    return null;
-}
-/**
- * Compute deployment order for packages (topological sort)
- */
-export function computeDeployOrder(packageDeps) {
-    const order = [];
-    const visited = new Set();
-    const allPackages = new Set();
-    // Collect all packages
-    for (const pkg of packageDeps.keys()) {
-        allPackages.add(pkg);
-    }
-    for (const deps of packageDeps.values()) {
-        for (const dep of deps) {
-            allPackages.add(dep);
-        }
-    }
-    function visit(pkg) {
-        if (visited.has(pkg))
-            return;
-        visited.add(pkg);
-        const deps = packageDeps.get(pkg) || new Set();
-        for (const dep of deps) {
-            visit(dep);
-        }
-        order.push(pkg);
-    }
-    // Visit all packages (sorted for determinism)
-    for (const pkg of [...allPackages].sort()) {
-        visit(pkg);
-    }
-    return order;
-}
-/**
- * Topological sort of changes within a package
- */
-export function topologicalSortWithinPackage(changes, graph) {
-    const result = [];
-    const visited = new Set();
-    function visit(change) {
-        if (visited.has(change))
-            return;
-        if (!changes.has(change))
-            return;
-        visited.add(change);
-        const deps = graph.edges.get(change) || new Set();
-        for (const dep of deps) {
-            if (changes.has(dep)) {
-                visit(dep);
-            }
-        }
-        result.push(change);
-    }
-    // Visit in alphabetical order for determinism
-    for (const change of [...changes].sort()) {
-        visit(change);
-    }
-    return result;
-}
-/**
- * Generate plan file content for a package
- */
-export function generatePlanContent(pkgName, entries, tags = []) {
-    let content = `%syntax-version=1.0.0\n`;
-    content += `%project=${pkgName}\n`;
-    content += `%uri=${pkgName}\n\n`;
-    // Dependency brackets keep their original order (empty order map), matching
-    // the source plans this content is sliced from.
-    const originalOrder = new Map();
-    for (const entry of entries) {
-        content += generateChangeLineContent(entry, originalOrder) + '\n';
-        // Add tags associated with this change
-        const changeTags = tags.filter(t => t.change === entry.name);
-        for (const tag of changeTags) {
-            content += generateTagLineContent(tag) + '\n';
-        }
-    }
-    return content;
-}
-/**
- * Generate control file content for a package
- */
-export function generateControlContent(pkgName, deps) {
-    let content = `# ${pkgName} extension\n`;
-    content += `comment = '${pkgName} module'\n`;
-    content += `default_version = '0.0.1'\n`;
-    content += `relocatable = false\n`;
-    if (deps.size > 0) {
-        content += `requires = '${[...deps].sort().join(', ')}'\n`;
-    }
-    return content;
-}
-/**
- * Generate a single package output
- */
-export 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
-    const planEntries = [];
-    for (const changeName of sortedChanges) {
-        const originalChange = graph.nodes.get(changeName);
-        const deps = graph.edges.get(changeName) || new Set();
-        const newDeps = [];
-        for (const dep of deps) {
-            const depPkg = changeToPackage.get(dep);
-            if (!depPkg) {
-                // External dependency (from installed module) - keep as-is
-                newDeps.push(dep);
-            }
-            else if (depPkg === pkgName) {
-                // Internal dependency - keep as-is
-                newDeps.push(dep);
-            }
-            else {
-                // Cross-package dependency
-                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);
-                    const lastChange = depPkgChanges[depPkgChanges.length - 1];
-                    const tags = graph.tags.get(lastChange);
-                    if (tags && tags.length > 0) {
-                        const latestTag = tags[tags.length - 1];
-                        newDeps.push(`${depPkg}:@${latestTag.name}`);
-                    }
-                    else {
-                        newDeps.push(`${depPkg}:${dep}`);
-                    }
-                }
-                else {
-                    newDeps.push(`${depPkg}:${dep}`);
-                }
-            }
-        }
-        planEntries.push({
-            name: changeName,
-            dependencies: newDeps,
-            timestamp: originalChange.timestamp,
-            planner: originalChange.planner,
-            email: originalChange.email,
-            comment: originalChange.comment
-        });
-    }
-    // Collect tags for this package
-    const packageTags = [];
-    for (const changeName of sortedChanges) {
-        const changeTags = graph.tags.get(changeName) || [];
-        packageTags.push(...changeTags);
-    }
-    // Generate plan content
-    const planContent = generatePlanContent(pkgName, planEntries, packageTags);
-    // Generate control file content
-    const controlContent = generateControlContent(pkgName, pkgDeps);
-    return {
-        name: pkgName,
-        planContent,
-        controlContent,
-        changes: planEntries,
-        packageDependencies: [...pkgDeps]
-    };
-}
-/**
- * Main slicing function
- */
-export function slicePlan(config) {
-    // Parse the source plan file
-    const planResult = parsePlanFile(config.sourcePlan);
-    if (!planResult.data) {
-        const errorMessages = planResult.errors?.map(e => `Line ${e.line}: ${e.message}`).join('\n') || 'Unknown error';
-        throw new Error(`Failed to parse plan file: ${errorMessages}`);
-    }
-    const plan = planResult.data;
-    const warnings = [];
-    // Build dependency graph
-    const graph = buildDependencyGraph(plan);
-    // Validate DAG
-    try {
-        validateDAG(graph);
-    }
-    catch (error) {
-        throw new Error(`Invalid plan file: ${error.message}`);
-    }
-    // Assign changes to packages
-    let assignments = assignChangesToPackages(graph, config.strategy, config.defaultPackage || 'core');
-    // Merge small packages if configured
-    if (config.minChangesPerPackage && config.minChangesPerPackage > 1) {
-        assignments = mergeSmallPackages(assignments, config.minChangesPerPackage, config.defaultPackage || 'core');
-    }
-    // Build package dependencies
-    const packageDeps = buildPackageDependencies(graph, assignments);
-    // Check for package cycles
-    const cycle = detectPackageCycle(packageDeps);
-    if (cycle) {
-        warnings.push({
-            type: 'cycle_detected',
-            message: `Package cycle detected: ${cycle.join(' -> ')}`,
-            suggestedAction: 'Consider merging these packages or reorganizing dependencies'
-        });
-        // For now, we'll proceed but warn - in production we might want to auto-merge
-    }
-    // Build reverse lookup
-    const changeToPackage = new Map();
-    for (const [pkg, changes] of assignments) {
-        for (const change of changes) {
-            changeToPackage.set(change, pkg);
-        }
-    }
-    // Compute deploy order
-    const deployOrder = computeDeployOrder(packageDeps);
-    // Generate packages
-    const packages = [];
-    for (const pkgName of deployOrder) {
-        const changes = assignments.get(pkgName);
-        if (!changes || changes.size === 0)
-            continue;
-        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;
-        let totalDeps = 0;
-        for (const change of changes) {
-            const deps = graph.edges.get(change) || new Set();
-            for (const dep of deps) {
-                totalDeps++;
-                const depPkg = changeToPackage.get(dep);
-                if (depPkg && depPkg !== pkgName) {
-                    crossDeps++;
-                }
-            }
-        }
-        const ratio = totalDeps > 0 ? crossDeps / totalDeps : 0;
-        if (ratio > 0.5) {
-            warnings.push({
-                type: 'heavy_cross_deps',
-                message: `Package "${pkgName}" has ${Math.round(ratio * 100)}% cross-package dependencies`,
-                suggestedAction: 'Consider merging with dependent packages or reorganizing'
-            });
-        }
-    }
-    // Calculate stats
-    let internalEdges = 0;
-    let crossPackageEdges = 0;
-    for (const [change, deps] of graph.edges) {
-        const myPkg = changeToPackage.get(change);
-        for (const dep of deps) {
-            const depPkg = changeToPackage.get(dep);
-            if (depPkg === myPkg) {
-                internalEdges++;
-            }
-            else if (depPkg) {
-                crossPackageEdges++;
-            }
-        }
-    }
-    const totalEdges = internalEdges + crossPackageEdges;
-    return {
-        packages,
-        workspace: {
-            packages: deployOrder,
-            deployOrder,
-            dependencies: Object.fromEntries([...packageDeps.entries()].map(([k, v]) => [k, [...v].sort()]))
-        },
-        warnings,
-        stats: {
-            totalChanges: graph.nodes.size,
-            packagesCreated: packages.length,
-            internalEdges,
-            crossPackageEdges,
-            crossPackageRatio: totalEdges > 0 ? crossPackageEdges / totalEdges : 0
-        }
-    };
-}

package/esm/slice/types.js

@@ -1 +0,0 @@
-export {};

package/slice/index.d.ts

@@ -1,3 +0,0 @@
-export * from './types';
-export * from './slice';
-export * from './output';

package/slice/index.js

@@ -1,19 +0,0 @@
-"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("./types"), exports);
-__exportStar(require("./slice"), exports);
-__exportStar(require("./output"), exports);

package/slice/output.d.ts

@@ -1,22 +0,0 @@
-import { SliceResult } from './types';
-/**
- * Options for writing sliced packages to disk
- */
-export interface WriteSliceOptions {
-    /** Base output directory */
-    outputDir: string;
-    /** Whether to overwrite existing packages */
-    overwrite?: boolean;
-    /** Whether to copy SQL files from source */
-    copySourceFiles?: boolean;
-    /** Source directory containing deploy/revert/verify folders */
-    sourceDir?: string;
-}
-/**
- * Write sliced packages to disk
- */
-export declare function writeSliceResult(result: SliceResult, options: WriteSliceOptions): void;
-/**
- * Generate a dry-run report of what would be created
- */
-export declare function generateDryRunReport(result: SliceResult): string;

package/slice/output.js

@@ -1,124 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.writeSliceResult = writeSliceResult;
-exports.generateDryRunReport = generateDryRunReport;
-const fs_1 = __importDefault(require("fs"));
-const path_1 = __importDefault(require("path"));
-/**
- * Write sliced packages to disk
- */
-function writeSliceResult(result, options) {
-    const { outputDir, overwrite = false, copySourceFiles = false, sourceDir } = options;
-    // Create output directory
-    fs_1.default.mkdirSync(outputDir, { recursive: true });
-    // Write each package
-    for (const pkg of result.packages) {
-        writePackage(pkg, outputDir, overwrite, copySourceFiles, sourceDir);
-    }
-    // Write workspace manifest
-    const manifestPath = path_1.default.join(outputDir, 'pgpm-workspace.json');
-    const manifestContent = JSON.stringify({
-        packages: result.workspace.packages.map(p => `packages/${p}`),
-        slicing: {
-            deployOrder: result.workspace.deployOrder,
-            dependencies: result.workspace.dependencies
-        },
-        stats: result.stats
-    }, null, 2);
-    fs_1.default.writeFileSync(manifestPath, manifestContent);
-}
-/**
- * Write a single package to disk
- */
-function writePackage(pkg, outputDir, overwrite, copySourceFiles, sourceDir) {
-    const pkgDir = path_1.default.join(outputDir, 'packages', pkg.name);
-    // Check if package already exists
-    if (fs_1.default.existsSync(pkgDir) && !overwrite) {
-        throw new Error(`Package directory already exists: ${pkgDir}. Use --overwrite to replace.`);
-    }
-    // Create package directory structure
-    fs_1.default.mkdirSync(pkgDir, { recursive: true });
-    fs_1.default.mkdirSync(path_1.default.join(pkgDir, 'deploy'), { recursive: true });
-    fs_1.default.mkdirSync(path_1.default.join(pkgDir, 'revert'), { recursive: true });
-    fs_1.default.mkdirSync(path_1.default.join(pkgDir, 'verify'), { recursive: true });
-    // Write plan file
-    fs_1.default.writeFileSync(path_1.default.join(pkgDir, 'pgpm.plan'), pkg.planContent);
-    // Write control file
-    fs_1.default.writeFileSync(path_1.default.join(pkgDir, `${pkg.name}.control`), pkg.controlContent);
-    // Copy SQL files if requested
-    if (copySourceFiles && sourceDir) {
-        for (const change of pkg.changes) {
-            copyChangeFiles(change.name, sourceDir, pkgDir);
-        }
-    }
-}
-/**
- * Copy deploy/revert/verify SQL files for a change
- */
-function copyChangeFiles(changeName, sourceDir, targetDir) {
-    const types = ['deploy', 'revert', 'verify'];
-    for (const type of types) {
-        const sourceFile = path_1.default.join(sourceDir, type, `${changeName}.sql`);
-        const targetFile = path_1.default.join(targetDir, type, `${changeName}.sql`);
-        if (fs_1.default.existsSync(sourceFile)) {
-            // Create target directory if needed
-            const targetSubDir = path_1.default.dirname(targetFile);
-            fs_1.default.mkdirSync(targetSubDir, { recursive: true });
-            // Copy file
-            fs_1.default.copyFileSync(sourceFile, targetFile);
-        }
-    }
-}
-/**
- * Generate a dry-run report of what would be created
- */
-function generateDryRunReport(result) {
-    const lines = [];
-    lines.push('=== PGPM Slice Dry Run Report ===\n');
-    // Statistics
-    lines.push('Statistics:');
-    lines.push(`  Total changes: ${result.stats.totalChanges}`);
-    lines.push(`  Packages to create: ${result.stats.packagesCreated}`);
-    lines.push(`  Internal edges: ${result.stats.internalEdges}`);
-    lines.push(`  Cross-package edges: ${result.stats.crossPackageEdges}`);
-    lines.push(`  Cross-package ratio: ${(result.stats.crossPackageRatio * 100).toFixed(1)}%`);
-    lines.push('');
-    // Warnings
-    if (result.warnings.length > 0) {
-        lines.push('Warnings:');
-        for (const warning of result.warnings) {
-            lines.push(`  [${warning.type}] ${warning.message}`);
-            if (warning.suggestedAction) {
-                lines.push(`    Suggestion: ${warning.suggestedAction}`);
-            }
-        }
-        lines.push('');
-    }
-    // Deploy order
-    lines.push('Deploy Order:');
-    for (let i = 0; i < result.workspace.deployOrder.length; i++) {
-        const pkg = result.workspace.deployOrder[i];
-        const deps = result.workspace.dependencies[pkg] || [];
-        const depStr = deps.length > 0 ? ` (depends on: ${deps.join(', ')})` : '';
-        lines.push(`  ${i + 1}. ${pkg}${depStr}`);
-    }
-    lines.push('');
-    // Package details
-    lines.push('Packages:');
-    for (const pkg of result.packages) {
-        lines.push(`\n  ${pkg.name}/`);
-        lines.push(`    Changes: ${pkg.changes.length}`);
-        lines.push(`    Dependencies: ${pkg.packageDependencies.join(', ') || 'none'}`);
-        lines.push('    Contents:');
-        for (const change of pkg.changes.slice(0, 5)) {
-            lines.push(`      - ${change.name}`);
-        }
-        if (pkg.changes.length > 5) {
-            lines.push(`      ... and ${pkg.changes.length - 5} more`);
-        }
-    }
-    return lines.join('\n');
-}