@pgpmjs/core 5.0.1 → 5.1.1

package/esm/slice/slice.js

@@ -0,0 +1,520 @@
+import { parsePlanFile } from '../files/plan/parser';
+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`;
+    for (const entry of entries) {
+        let line = entry.name;
+        if (entry.dependencies && entry.dependencies.length > 0) {
+            line += ` [${entry.dependencies.join(' ')}]`;
+        }
+        if (entry.timestamp) {
+            line += ` ${entry.timestamp}`;
+            if (entry.planner) {
+                line += ` ${entry.planner}`;
+                if (entry.email) {
+                    line += ` <${entry.email}>`;
+                }
+            }
+        }
+        if (entry.comment) {
+            line += ` # ${entry.comment}`;
+        }
+        content += line + '\n';
+        // Add tags associated with this change
+        const changeTags = tags.filter(t => t.change === entry.name);
+        for (const tag of changeTags) {
+            let tagLine = `@${tag.name}`;
+            if (tag.timestamp) {
+                tagLine += ` ${tag.timestamp}`;
+                if (tag.planner) {
+                    tagLine += ` ${tag.planner}`;
+                    if (tag.email) {
+                        tagLine += ` <${tag.email}>`;
+                    }
+                }
+            }
+            if (tag.comment) {
+                tagLine += ` # ${tag.comment}`;
+            }
+            content += tagLine + '\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, useTagsForCrossPackageDeps = false) {
+    // 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 (useTagsForCrossPackageDeps) {
+                    // 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.useTagsForCrossPackageDeps || false);
+        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

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

package/export/export-meta.js

@@ -446,7 +446,8 @@ const config = {
             api_id: 'uuid',
             schema_id: 'uuid',
             private_schema_id: 'uuid',
-            tokens_table_id: 'uuid',
+            session_credentials_table_id: 'uuid',
+            sessions_table_id: 'uuid',
             users_table_id: 'uuid',
             authenticate: 'text',
             authenticate_strict: 'text',
@@ -465,7 +466,10 @@ const config = {
             users_table_id: 'uuid',
             secrets_table_id: 'uuid',
             encrypted_table_id: 'uuid',
-            tokens_table_id: 'uuid',
+            sessions_table_id: 'uuid',
+            session_credentials_table_id: 'uuid',
+            audits_table_id: 'uuid',
+            audits_table_name: 'text',
             sign_in_function: 'text',
             sign_up_function: 'text',
             sign_out_function: 'text',
@@ -478,7 +482,9 @@ const config = {
             reset_password_function: 'text',
             forgot_password_function: 'text',
             send_verification_email_function: 'text',
-            verify_email_function: 'text'
+            verify_email_function: 'text',
+            verify_password_function: 'text',
+            check_password_function: 'text'
         }
     },
     memberships_module: {
@@ -680,17 +686,21 @@ const config = {
             table_name: 'text'
         }
     },
-    tokens_module: {
+    sessions_module: {
         schema: 'metaschema_modules_public',
-        table: 'tokens_module',
+        table: 'sessions_module',
         fields: {
             id: 'uuid',
             database_id: 'uuid',
             schema_id: 'uuid',
-            table_id: 'uuid',
-            owned_table_id: 'uuid',
-            tokens_default_expiration: 'interval',
-            tokens_table: 'text'
+            sessions_table_id: 'uuid',
+            session_credentials_table_id: 'uuid',
+            auth_settings_table_id: 'uuid',
+            users_table_id: 'uuid',
+            sessions_default_expiration: 'interval',
+            sessions_table: 'text',
+            session_credentials_table: 'text',
+            auth_settings_table: 'text'
         }
     },
     secrets_module: {
@@ -788,7 +798,8 @@ const config = {
             database_id: 'uuid',
             schema_id: 'uuid',
             users_table_id: 'uuid',
-            tokens_table_id: 'uuid',
+            sessions_table_id: 'uuid',
+            session_credentials_table_id: 'uuid',
             secrets_table_id: 'uuid',
             addresses_table_id: 'uuid',
             user_field: 'text',
@@ -983,7 +994,7 @@ const exportMeta = async ({ opts, dbname, database_id }) => {
     await queryAndParse('membership_types_module', `SELECT * FROM metaschema_modules_public.membership_types_module WHERE database_id = $1`);
     await queryAndParse('invites_module', `SELECT * FROM metaschema_modules_public.invites_module WHERE database_id = $1`);
     await queryAndParse('emails_module', `SELECT * FROM metaschema_modules_public.emails_module WHERE database_id = $1`);
-    await queryAndParse('tokens_module', `SELECT * FROM metaschema_modules_public.tokens_module WHERE database_id = $1`);
+    await queryAndParse('sessions_module', `SELECT * FROM metaschema_modules_public.sessions_module WHERE database_id = $1`);
     await queryAndParse('secrets_module', `SELECT * FROM metaschema_modules_public.secrets_module WHERE database_id = $1`);
     await queryAndParse('profiles_module', `SELECT * FROM metaschema_modules_public.profiles_module WHERE database_id = $1`);
     await queryAndParse('encrypted_secrets_module', `SELECT * FROM metaschema_modules_public.encrypted_secrets_module WHERE database_id = $1`);

package/export/export-migrations.js

@@ -255,7 +255,7 @@ SET session_replication_role TO DEFAULT;`;
             'membership_types_module',
             'invites_module',
             'emails_module',
-            'tokens_module',
+            'sessions_module',
             'secrets_module',
             'profiles_module',
             'encrypted_secrets_module',

package/index.d.ts

@@ -1,6 +1,7 @@
 export * from './core/class/pgpm';
 export * from './export/export-meta';
 export * from './export/export-migrations';
+export * from './slice';
 export * from './extensions/extensions';
 export * from './modules/modules';
 export * from './packaging/package';

package/index.js

@@ -18,6 +18,7 @@ exports.withTransaction = exports.executeQuery = exports.hashString = exports.ha
 __exportStar(require("./core/class/pgpm"), exports);
 __exportStar(require("./export/export-meta"), exports);
 __exportStar(require("./export/export-migrations"), exports);
+__exportStar(require("./slice"), exports);
 __exportStar(require("./extensions/extensions"), exports);
 __exportStar(require("./modules/modules"), exports);
 __exportStar(require("./packaging/package"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgpmjs/core",
-  "version": "5.0.1",
+  "version": "5.1.1",
   "author": "Constructive <developers@constructive.io>",
   "description": "PGPM Package and Migration Tools",
   "main": "index.js",
@@ -56,6 +56,7 @@
     "genomic": "^5.3.0",
     "glob": "^13.0.0",
     "komoji": "^0.8.0",
+    "minimatch": "^10.1.1",
     "parse-package-name": "^1.0.0",
     "pg": "^8.17.1",
     "pg-cache": "^2.0.0",
@@ -64,5 +65,5 @@
     "pgsql-parser": "^17.9.11",
     "yanse": "^0.2.0"
   },
-  "gitHead": "b7b9bf9712a5d48619d6b19be6361251468e1bda"
+  "gitHead": "27b059d8fb062729f697cd3d3415a57de28a0975"
 }

package/slice/index.d.ts

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

package/slice/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 });
+__exportStar(require("./types"), exports);
+__exportStar(require("./slice"), exports);
+__exportStar(require("./output"), exports);