pgpm 5.24.5 → 5.25.0

package/README.md

@@ -376,12 +376,24 @@ pgpm kill --no-drop
 
 #### `pgpm test-packages`
 
-Run integration tests on all modules in a workspace. Creates a temporary database for each module, deploys, and optionally runs verify/revert/deploy cycles.
+Run integration tests on the modules in a workspace. Creates a temporary database per tested module, deploys, and optionally runs verify/revert/deploy cycles.
+
+By default only the **minimal covering set** is tested: the modules nothing else in the
+workspace requires. Testing one of those deploys its whole dependency closure in
+dependency order, so every module is still exercised — once per covering module instead
+of once per module. Excluding a covering module promotes whatever it alone covered.
+
+The property the default trades away is standalone deployability — that a module's own
+`requires` is complete rather than satisfied by a sibling in the same database. Use
+`--force-all` to get it back.
 
 ```bash
-# Test all modules in workspace (deploy only)
+# Test the minimal covering set (deploy only)
 pgpm test-packages
 
+# Test every module in its own database
+pgpm test-packages --force-all
+
 # Run full deploy/verify/revert/deploy cycle
 pgpm test-packages --full-cycle
 
@@ -397,6 +409,7 @@ pgpm test-packages --full-cycle --continue-on-fail --exclude legacy-module
 
 **Options:**
 
+- `--force-all` - Test every module in its own database instead of the minimal covering set
 - `--full-cycle` - Run full deploy/verify/revert/deploy cycle (default: deploy only)
 - `--continue-on-fail` - Continue testing all packages even after failures (default: stop on first failure)
 - `--exclude <modules>` - Comma-separated module names to exclude

package/commands/test-packages.d.ts

@@ -1,3 +1,23 @@
 import { CLIOptions, Inquirerer, ParsedArgs } from 'inquirerer';
+/**
+ * Reduce the module list to a minimal covering set: the modules that no other
+ * candidate requires, transitively.
+ *
+ * Testing a module deploys its whole dependency closure in dependency order, so
+ * a module that some other candidate requires is already deployed, verified,
+ * reverted and re-deployed inside that candidate's database. Selection runs over
+ * the post-exclude candidates, so excluding a covering module promotes whatever
+ * it alone covered rather than dropping it.
+ *
+ * The property this trades away is standalone deployability — that a module's own
+ * `requires` is complete rather than satisfied by a sibling in the same database.
+ * Use --force-all to get it back.
+ */
+export declare function minimalCoveringSet(moduleMap: Record<string, {
+    requires: string[];
+}>, candidateNames: string[]): {
+    selected: string[];
+    coveredBy: Map<string, string>;
+};
 declare const _default: (argv: Partial<ParsedArgs>, _prompter: Inquirerer, _options: CLIOptions) => Promise<never>;
 export default _default;

package/commands/test-packages.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.minimalCoveringSet = minimalCoveringSet;
 const core_1 = require("@pgpmjs/core");
 const env_1 = require("@pgpmjs/env");
 const logger_1 = require("@pgpmjs/logger");
@@ -20,22 +21,85 @@ Test Packages Command:
 
   pgpm test-packages [OPTIONS]
 
-  Run integration tests on all PGPM packages in a workspace.
+  Run integration tests on the PGPM packages in a workspace.
   Tests each package with a deploy/verify/revert/deploy cycle.
 
+  By default only the minimal covering set is tested: the modules nothing else
+  in the workspace requires. Deploying one of those deploys everything it
+  requires first, so every module in the workspace is still exercised — just
+  once per covering module instead of once per module.
+
 Options:
   --help, -h           Show this help message
   --exclude <pkgs>     Comma-separated module names to exclude
   --continue-on-fail   Continue testing all packages even after failures
   --full-cycle         Run full deploy/verify/revert/deploy cycle (default: deploy only)
+  --force-all          Test every module in its own database (pre-minimal-set behavior)
   --cwd <directory>    Working directory (default: current directory)
 
 Examples:
-  pgpm test-packages                              Test all packages (stops on first failure)
+  pgpm test-packages                              Test the minimal covering set
+  pgpm test-packages --force-all                 Test every module in its own database
   pgpm test-packages --full-cycle                Run full test cycle with verify/revert
   pgpm test-packages --continue-on-fail          Test all packages, collect all failures
   pgpm test-packages --exclude my-module         Exclude specific modules
 `;
+/**
+ * Reduce the module list to a minimal covering set: the modules that no other
+ * candidate requires, transitively.
+ *
+ * Testing a module deploys its whole dependency closure in dependency order, so
+ * a module that some other candidate requires is already deployed, verified,
+ * reverted and re-deployed inside that candidate's database. Selection runs over
+ * the post-exclude candidates, so excluding a covering module promotes whatever
+ * it alone covered rather than dropping it.
+ *
+ * The property this trades away is standalone deployability — that a module's own
+ * `requires` is complete rather than satisfied by a sibling in the same database.
+ * Use --force-all to get it back.
+ */
+function minimalCoveringSet(moduleMap, candidateNames) {
+    const candidates = new Set(candidateNames);
+    // name -> its transitive requires, restricted to the candidates
+    const closures = new Map();
+    for (const name of candidates) {
+        const { resolved } = (0, core_1.resolveExtensionDependencies)(name, moduleMap);
+        closures.set(name, resolved.filter((dep) => dep !== name && candidates.has(dep)));
+    }
+    const coveredBy = new Map();
+    for (const [name, deps] of closures) {
+        for (const dep of deps) {
+            if (!coveredBy.has(dep)) {
+                coveredBy.set(dep, name);
+            }
+        }
+    }
+    const selected = candidateNames.filter((name) => !coveredBy.has(name));
+    // Nothing may fall out of the selection. Covering-set membership is derived
+    // from pairwise closures, so assert the union actually reaches every candidate
+    // rather than trusting that argument.
+    const covered = new Set();
+    for (const name of selected) {
+        covered.add(name);
+        for (const dep of closures.get(name) ?? []) {
+            covered.add(dep);
+        }
+    }
+    const uncovered = candidateNames.filter((name) => !covered.has(name));
+    if (uncovered.length > 0) {
+        throw new Error(`Minimal module selection left ${uncovered.length} module(s) untested: ${uncovered.join(', ')}. ` +
+            'Re-run with --force-all and report this as a pgpm bug.');
+    }
+    return { selected, coveredBy };
+}
+function selectMinimalModules(workspacePkg, candidates) {
+    const { selected, coveredBy } = minimalCoveringSet(workspacePkg.getModuleMap(), candidates.map((mod) => mod.getModuleName()));
+    const selectedNames = new Set(selected);
+    return {
+        selected: candidates.filter((mod) => selectedNames.has(mod.getModuleName())),
+        coveredBy
+    };
+}
 function dbSafeName(moduleName) {
     return `test_${moduleName}`.replace(/[^a-zA-Z0-9]/g, '_').toLowerCase();
 }
@@ -209,6 +273,7 @@ exports.default = async (argv, _prompter, _options) => {
     const continueOnFail = argv['continue-on-fail'] === true || argv.continueOnFail === true;
     const stopOnFail = !continueOnFail;
     const fullCycle = argv['full-cycle'] === true || argv.fullCycle === true;
+    const forceAll = argv['force-all'] === true || argv.forceAll === true;
     const cwd = argv.cwd || process.cwd();
     // Parse excludes
     let excludes = [];
@@ -216,7 +281,7 @@ exports.default = async (argv, _prompter, _options) => {
         excludes = argv.exclude.split(',').map(e => e.trim());
     }
     console.log('=== PGPM Package Integration Test ===');
-    console.log(`Testing all packages with ${fullCycle ? 'deploy/verify/revert/deploy cycle' : 'deploy only'}`);
+    console.log(`Testing ${forceAll ? 'all packages' : 'the minimal covering set'} with ${fullCycle ? 'deploy/verify/revert/deploy cycle' : 'deploy only'}`);
     if (!stopOnFail) {
         console.log('Mode: Test all packages (collect all failures)');
     }
@@ -255,14 +320,21 @@ exports.default = async (argv, _prompter, _options) => {
         });
         console.log(`Excluding: ${excludes.join(', ')}`);
     }
-    console.log(`Found ${filteredModules.length} modules to test:`);
-    for (const mod of filteredModules) {
+    let selectedModules = filteredModules;
+    if (!forceAll) {
+        const { selected, coveredBy } = selectMinimalModules(workspacePkg, filteredModules);
+        selectedModules = selected;
+        console.log(`Minimal covering set: ${selected.length} of ${filteredModules.length} modules ` +
+            `(${coveredBy.size} covered transitively; --force-all to test each on its own)`);
+    }
+    console.log(`Found ${selectedModules.length} modules to test:`);
+    for (const mod of selectedModules) {
         console.log(`  - ${mod.getModuleName()}`);
     }
     console.log('');
     const failedPackages = [];
     const successfulPackages = [];
-    for (const modulePkg of filteredModules) {
+    for (const modulePkg of selectedModules) {
         const result = await testModule(workspacePkg, modulePkg, fullCycle);
         if (result.success) {
             successfulPackages.push(result);

package/esm/commands/test-packages.js

@@ -1,4 +1,4 @@
-import { PgpmPackage } from '@pgpmjs/core';
+import { PgpmPackage, resolveExtensionDependencies } from '@pgpmjs/core';
 import { getEnvOptions } from '@pgpmjs/env';
 import { Logger } from '@pgpmjs/logger';
 import path from 'path';
@@ -15,22 +15,85 @@ Test Packages Command:
 
   pgpm test-packages [OPTIONS]
 
-  Run integration tests on all PGPM packages in a workspace.
+  Run integration tests on the PGPM packages in a workspace.
   Tests each package with a deploy/verify/revert/deploy cycle.
 
+  By default only the minimal covering set is tested: the modules nothing else
+  in the workspace requires. Deploying one of those deploys everything it
+  requires first, so every module in the workspace is still exercised — just
+  once per covering module instead of once per module.
+
 Options:
   --help, -h           Show this help message
   --exclude <pkgs>     Comma-separated module names to exclude
   --continue-on-fail   Continue testing all packages even after failures
   --full-cycle         Run full deploy/verify/revert/deploy cycle (default: deploy only)
+  --force-all          Test every module in its own database (pre-minimal-set behavior)
   --cwd <directory>    Working directory (default: current directory)
 
 Examples:
-  pgpm test-packages                              Test all packages (stops on first failure)
+  pgpm test-packages                              Test the minimal covering set
+  pgpm test-packages --force-all                 Test every module in its own database
   pgpm test-packages --full-cycle                Run full test cycle with verify/revert
   pgpm test-packages --continue-on-fail          Test all packages, collect all failures
   pgpm test-packages --exclude my-module         Exclude specific modules
 `;
+/**
+ * Reduce the module list to a minimal covering set: the modules that no other
+ * candidate requires, transitively.
+ *
+ * Testing a module deploys its whole dependency closure in dependency order, so
+ * a module that some other candidate requires is already deployed, verified,
+ * reverted and re-deployed inside that candidate's database. Selection runs over
+ * the post-exclude candidates, so excluding a covering module promotes whatever
+ * it alone covered rather than dropping it.
+ *
+ * The property this trades away is standalone deployability — that a module's own
+ * `requires` is complete rather than satisfied by a sibling in the same database.
+ * Use --force-all to get it back.
+ */
+export function minimalCoveringSet(moduleMap, candidateNames) {
+    const candidates = new Set(candidateNames);
+    // name -> its transitive requires, restricted to the candidates
+    const closures = new Map();
+    for (const name of candidates) {
+        const { resolved } = resolveExtensionDependencies(name, moduleMap);
+        closures.set(name, resolved.filter((dep) => dep !== name && candidates.has(dep)));
+    }
+    const coveredBy = new Map();
+    for (const [name, deps] of closures) {
+        for (const dep of deps) {
+            if (!coveredBy.has(dep)) {
+                coveredBy.set(dep, name);
+            }
+        }
+    }
+    const selected = candidateNames.filter((name) => !coveredBy.has(name));
+    // Nothing may fall out of the selection. Covering-set membership is derived
+    // from pairwise closures, so assert the union actually reaches every candidate
+    // rather than trusting that argument.
+    const covered = new Set();
+    for (const name of selected) {
+        covered.add(name);
+        for (const dep of closures.get(name) ?? []) {
+            covered.add(dep);
+        }
+    }
+    const uncovered = candidateNames.filter((name) => !covered.has(name));
+    if (uncovered.length > 0) {
+        throw new Error(`Minimal module selection left ${uncovered.length} module(s) untested: ${uncovered.join(', ')}. ` +
+            'Re-run with --force-all and report this as a pgpm bug.');
+    }
+    return { selected, coveredBy };
+}
+function selectMinimalModules(workspacePkg, candidates) {
+    const { selected, coveredBy } = minimalCoveringSet(workspacePkg.getModuleMap(), candidates.map((mod) => mod.getModuleName()));
+    const selectedNames = new Set(selected);
+    return {
+        selected: candidates.filter((mod) => selectedNames.has(mod.getModuleName())),
+        coveredBy
+    };
+}
 function dbSafeName(moduleName) {
     return `test_${moduleName}`.replace(/[^a-zA-Z0-9]/g, '_').toLowerCase();
 }
@@ -204,6 +267,7 @@ export default async (argv, _prompter, _options) => {
     const continueOnFail = argv['continue-on-fail'] === true || argv.continueOnFail === true;
     const stopOnFail = !continueOnFail;
     const fullCycle = argv['full-cycle'] === true || argv.fullCycle === true;
+    const forceAll = argv['force-all'] === true || argv.forceAll === true;
     const cwd = argv.cwd || process.cwd();
     // Parse excludes
     let excludes = [];
@@ -211,7 +275,7 @@ export default async (argv, _prompter, _options) => {
         excludes = argv.exclude.split(',').map(e => e.trim());
     }
     console.log('=== PGPM Package Integration Test ===');
-    console.log(`Testing all packages with ${fullCycle ? 'deploy/verify/revert/deploy cycle' : 'deploy only'}`);
+    console.log(`Testing ${forceAll ? 'all packages' : 'the minimal covering set'} with ${fullCycle ? 'deploy/verify/revert/deploy cycle' : 'deploy only'}`);
     if (!stopOnFail) {
         console.log('Mode: Test all packages (collect all failures)');
     }
@@ -250,14 +314,21 @@ export default async (argv, _prompter, _options) => {
         });
         console.log(`Excluding: ${excludes.join(', ')}`);
     }
-    console.log(`Found ${filteredModules.length} modules to test:`);
-    for (const mod of filteredModules) {
+    let selectedModules = filteredModules;
+    if (!forceAll) {
+        const { selected, coveredBy } = selectMinimalModules(workspacePkg, filteredModules);
+        selectedModules = selected;
+        console.log(`Minimal covering set: ${selected.length} of ${filteredModules.length} modules ` +
+            `(${coveredBy.size} covered transitively; --force-all to test each on its own)`);
+    }
+    console.log(`Found ${selectedModules.length} modules to test:`);
+    for (const mod of selectedModules) {
         console.log(`  - ${mod.getModuleName()}`);
     }
     console.log('');
     const failedPackages = [];
     const successfulPackages = [];
-    for (const modulePkg of filteredModules) {
+    for (const modulePkg of selectedModules) {
         const result = await testModule(workspacePkg, modulePkg, fullCycle);
         if (result.success) {
             successfulPackages.push(result);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgpm",
-  "version": "5.24.5",
+  "version": "5.25.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "PostgreSQL Package Manager - Database migration and package management CLI",
   "main": "index.js",
@@ -49,7 +49,7 @@
     "@pgpmjs/core": "^7.25.4",
     "@pgpmjs/diff": "^0.3.5",
     "@pgpmjs/env": "^2.41.3",
-    "@pgpmjs/export": "^1.16.8",
+    "@pgpmjs/export": "^1.16.9",
     "@pgpmjs/import": "^0.3.6",
     "@pgpmjs/logger": "^2.24.1",
     "@pgpmjs/slice": "^0.14.6",
@@ -80,5 +80,5 @@
     "pg",
     "pgsql"
   ],
-  "gitHead": "d6afee66ac3400e78864b9e259cdd6ab9184b251"
+  "gitHead": "44f56ee80a348f649a22e5bd32b35f2822726509"
 }