pgpm 1.1.4 → 1.2.0

package/README.md

@@ -90,6 +90,10 @@ Here are some useful commands for reference:
 - `pgpm plan` - Generate deployment plans for your modules
 - `pgpm package` - Package your module for distribution
 
+### Testing
+
+- `pgpm test-packages` - Run integration tests on all modules in a workspace
+
 ### Utilities
 
 - `pgpm add` - Add a new database change
@@ -302,6 +306,43 @@ pgpm kill
 pgpm kill --no-drop
 ```
 
+### Testing
+
+#### `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.
+
+```bash
+# Test all modules in workspace (deploy only)
+pgpm test-packages
+
+# Run full deploy/verify/revert/deploy cycle
+pgpm test-packages --full-cycle
+
+# Stop on first failure
+pgpm test-packages --stop-on-fail
+
+# Exclude specific modules
+pgpm test-packages --exclude my-module,another-module
+
+# Combine options
+pgpm test-packages --full-cycle --stop-on-fail --exclude legacy-module
+```
+
+**Options:**
+
+- `--full-cycle` - Run full deploy/verify/revert/deploy cycle (default: deploy only)
+- `--stop-on-fail` - Stop testing immediately when a module fails
+- `--exclude <modules>` - Comma-separated module names to exclude
+- `--cwd <directory>` - Working directory (default: current directory)
+
+**Notes:**
+
+- Discovers modules from workspace `pgpm.json` configuration
+- Creates isolated test databases (`test_<module_name>`) for each module
+- Automatically cleans up test databases after each test
+- Uses internal APIs for deploy/verify/revert operations
+
 ## ⚙️ Configuration
 
 ### Environment Variables

package/commands/test-packages.d.ts

@@ -0,0 +1,4 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+import { ParsedArgs } from 'minimist';
+declare const _default: (argv: Partial<ParsedArgs>, _prompter: Inquirerer, _options: CLIOptions) => Promise<never>;
+export default _default;

package/commands/test-packages.js

@@ -0,0 +1,320 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@pgpmjs/core");
+const env_1 = require("@pgpmjs/env");
+const logger_1 = require("@pgpmjs/logger");
+const path_1 = __importDefault(require("path"));
+const pg_env_1 = require("pg-env");
+const pg_cache_1 = require("pg-cache");
+const log = new logger_1.Logger('test-packages');
+// ANSI color codes
+const RED = '\x1b[0;31m';
+const GREEN = '\x1b[0;32m';
+const YELLOW = '\x1b[1;33m';
+const NC = '\x1b[0m'; // No Color
+const testPackagesUsageText = `
+Test Packages Command:
+
+  pgpm test-packages [OPTIONS]
+
+  Run integration tests on all PGPM packages in a workspace.
+  Tests each package with a deploy/verify/revert/deploy cycle.
+
+Options:
+  --help, -h           Show this help message
+  --exclude <pkgs>     Comma-separated module names to exclude
+  --stop-on-fail       Stop testing immediately when a package fails
+  --full-cycle         Run full deploy/verify/revert/deploy cycle (default: deploy only)
+  --cwd <directory>    Working directory (default: current directory)
+
+Examples:
+  pgpm test-packages                              Test all packages in workspace
+  pgpm test-packages --full-cycle                Run full test cycle with verify/revert
+  pgpm test-packages --stop-on-fail              Stop on first failure
+  pgpm test-packages --exclude my-module         Exclude specific modules
+`;
+function dbSafeName(moduleName) {
+    return `test_${moduleName}`.replace(/[^a-zA-Z0-9]/g, '_').toLowerCase();
+}
+async function createDatabase(dbname, adminDb = 'postgres') {
+    try {
+        const pgEnv = (0, pg_env_1.getPgEnvOptions)({ database: adminDb });
+        const pool = (0, pg_cache_1.getPgPool)(pgEnv);
+        // Sanitize database name (only allow alphanumeric and underscore)
+        const safeName = dbname.replace(/[^a-zA-Z0-9_]/g, '_');
+        await pool.query(`CREATE DATABASE "${safeName}"`);
+        log.debug(`Created database: ${safeName}`);
+        return true;
+    }
+    catch (error) {
+        if (error.code === '42P04') {
+            // Database already exists, that's fine
+            log.debug(`Database ${dbname} already exists`);
+            return true;
+        }
+        log.error(`Failed to create database ${dbname}: ${error.message}`);
+        return false;
+    }
+}
+async function dropDatabase(dbname, adminDb = 'postgres') {
+    try {
+        const pgEnv = (0, pg_env_1.getPgEnvOptions)({ database: adminDb });
+        const pool = (0, pg_cache_1.getPgPool)(pgEnv);
+        // Sanitize database name
+        const safeName = dbname.replace(/[^a-zA-Z0-9_]/g, '_');
+        // Terminate all connections to the database first
+        await pool.query(`
+      SELECT pg_terminate_backend(pid) 
+      FROM pg_stat_activity 
+      WHERE datname = $1 AND pid <> pg_backend_pid()
+    `, [safeName]);
+        await pool.query(`DROP DATABASE IF EXISTS "${safeName}"`);
+        log.debug(`Dropped database: ${safeName}`);
+    }
+    catch (error) {
+        // Ignore errors when dropping (database might not exist)
+        log.debug(`Could not drop database ${dbname}: ${error.message}`);
+    }
+}
+async function checkPostgresConnection() {
+    try {
+        const pgEnv = (0, pg_env_1.getPgEnvOptions)({ database: 'postgres' });
+        const pool = (0, pg_cache_1.getPgPool)(pgEnv);
+        await pool.query('SELECT 1');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function testModule(workspacePkg, modulePkg, fullCycle) {
+    const moduleName = modulePkg.getModuleName();
+    const modulePath = modulePkg.getModulePath() || '';
+    const dbname = dbSafeName(moduleName);
+    console.log(`${YELLOW}Testing module: ${moduleName}${NC}`);
+    console.log(`  Module path: ${modulePath}`);
+    console.log(`  Database name: ${dbname}`);
+    // Clean up any existing test database
+    await dropDatabase(dbname);
+    // Create fresh test database
+    console.log(`  Creating database: ${dbname}`);
+    if (!await createDatabase(dbname)) {
+        return {
+            moduleName,
+            modulePath,
+            success: false,
+            error: `Could not create database ${dbname}`
+        };
+    }
+    try {
+        // Create options for this test database
+        const opts = (0, env_1.getEnvOptions)({
+            pg: (0, pg_env_1.getPgEnvOptions)({ database: dbname }),
+            deployment: {
+                useTx: true,
+                fast: false,
+                usePlan: true,
+                cache: false,
+                logOnly: false
+            }
+        });
+        // Deploy
+        console.log('  Running deploy...');
+        try {
+            await workspacePkg.deploy(opts, moduleName, true);
+        }
+        catch (error) {
+            await dropDatabase(dbname);
+            return {
+                moduleName,
+                modulePath,
+                success: false,
+                error: `Deploy failed: ${error.message}`
+            };
+        }
+        if (fullCycle) {
+            // Verify
+            console.log('  Running verify...');
+            try {
+                await workspacePkg.verify(opts, moduleName, true);
+            }
+            catch (error) {
+                await dropDatabase(dbname);
+                return {
+                    moduleName,
+                    modulePath,
+                    success: false,
+                    error: `Verify failed: ${error.message}`
+                };
+            }
+            // Revert
+            console.log('  Running revert...');
+            try {
+                await workspacePkg.revert(opts, moduleName, true);
+            }
+            catch (error) {
+                await dropDatabase(dbname);
+                return {
+                    moduleName,
+                    modulePath,
+                    success: false,
+                    error: `Revert failed: ${error.message}`
+                };
+            }
+            // Deploy again
+            console.log('  Running deploy (second time)...');
+            try {
+                await workspacePkg.deploy(opts, moduleName, true);
+            }
+            catch (error) {
+                await dropDatabase(dbname);
+                return {
+                    moduleName,
+                    modulePath,
+                    success: false,
+                    error: `Deploy (second time) failed: ${error.message}`
+                };
+            }
+        }
+        // Clean up test database
+        await dropDatabase(dbname);
+        console.log(`${GREEN}SUCCESS: Module ${moduleName} passed all tests${NC}`);
+        return {
+            moduleName,
+            modulePath,
+            success: true
+        };
+    }
+    catch (error) {
+        // Ensure cleanup on any unexpected error
+        await dropDatabase(dbname);
+        return {
+            moduleName,
+            modulePath,
+            success: false,
+            error: `Unexpected error: ${error.message}`
+        };
+    }
+}
+exports.default = async (argv, _prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(testPackagesUsageText);
+        process.exit(0);
+    }
+    // Parse options
+    const stopOnFail = argv['stop-on-fail'] === true || argv.stopOnFail === true;
+    const fullCycle = argv['full-cycle'] === true || argv.fullCycle === true;
+    const cwd = argv.cwd || process.cwd();
+    // Parse excludes
+    let excludes = [];
+    if (argv.exclude) {
+        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'}`);
+    if (stopOnFail) {
+        console.log('Mode: Stop on first failure');
+    }
+    else {
+        console.log('Mode: Test all packages (collect all failures)');
+    }
+    console.log('');
+    // Check PostgreSQL connection
+    console.log('Checking PostgreSQL connection...');
+    if (!await checkPostgresConnection()) {
+        log.error('PostgreSQL not accessible.');
+        console.log('Ensure PostgreSQL is running and connection settings are correct.');
+        console.log('For local development: docker-compose up -d');
+        console.log('For CI: ensure PostgreSQL service is running');
+        process.exit(1);
+    }
+    console.log('PostgreSQL connection successful');
+    console.log('');
+    // Initialize workspace package
+    const projectRoot = path_1.default.resolve(cwd);
+    const workspacePkg = new core_1.PgpmPackage(projectRoot);
+    if (!workspacePkg.getWorkspacePath()) {
+        log.error('Not in a PGPM workspace. Run this command from a workspace root.');
+        process.exit(1);
+    }
+    // Get all modules from workspace using internal API
+    console.log('Finding all PGPM modules in workspace...');
+    const modules = await workspacePkg.getModules();
+    if (modules.length === 0) {
+        log.warn('No modules found in workspace.');
+        process.exit(0);
+    }
+    // Filter out excluded modules
+    let filteredModules = modules;
+    if (excludes.length > 0) {
+        filteredModules = modules.filter(mod => {
+            const moduleName = mod.getModuleName();
+            return !excludes.includes(moduleName);
+        });
+        console.log(`Excluding: ${excludes.join(', ')}`);
+    }
+    console.log(`Found ${filteredModules.length} modules to test:`);
+    for (const mod of filteredModules) {
+        console.log(`  - ${mod.getModuleName()}`);
+    }
+    console.log('');
+    const failedPackages = [];
+    const successfulPackages = [];
+    for (const modulePkg of filteredModules) {
+        const result = await testModule(workspacePkg, modulePkg, fullCycle);
+        if (result.success) {
+            successfulPackages.push(result);
+        }
+        else {
+            failedPackages.push(result);
+            if (stopOnFail) {
+                console.log('');
+                console.error(`${RED}STOPPING: Test failed for module ${result.moduleName} and --stop-on-fail was specified${NC}`);
+                console.log('');
+                console.log('=== TEST SUMMARY (PARTIAL) ===');
+                if (successfulPackages.length > 0) {
+                    console.log(`${GREEN}Successful modules before failure (${successfulPackages.length}):${NC}`);
+                    for (const pkg of successfulPackages) {
+                        console.log(`  ${GREEN}✓${NC} ${pkg.moduleName}`);
+                    }
+                    console.log('');
+                }
+                console.error(`${RED}Failed module: ${result.moduleName}${NC}`);
+                if (result.error) {
+                    console.error(`  Error: ${result.error}`);
+                }
+                console.log('');
+                console.error(`${RED}OVERALL RESULT: FAILED (stopped on first failure)${NC}`);
+                process.exit(1);
+            }
+        }
+        console.log('');
+    }
+    console.log('=== TEST SUMMARY ===');
+    console.log(`${GREEN}Successful modules (${successfulPackages.length}):${NC}`);
+    for (const pkg of successfulPackages) {
+        console.log(`  ${GREEN}✓${NC} ${pkg.moduleName}`);
+    }
+    if (failedPackages.length > 0) {
+        console.log('');
+        console.error(`${RED}Failed modules (${failedPackages.length}):${NC}`);
+        for (const pkg of failedPackages) {
+            console.error(`  ${RED}✗${NC} ${pkg.moduleName}`);
+            if (pkg.error) {
+                console.error(`    Error: ${pkg.error}`);
+            }
+        }
+        console.log('');
+        console.error(`${RED}OVERALL RESULT: FAILED${NC}`);
+        process.exit(1);
+    }
+    else {
+        console.log('');
+        console.log(`${GREEN}OVERALL RESULT: ALL MODULES PASSED${NC}`);
+        process.exit(0);
+    }
+};

package/commands.js

@@ -27,6 +27,7 @@ const remove_1 = __importDefault(require("./commands/remove"));
 const rename_1 = __importDefault(require("./commands/rename"));
 const revert_1 = __importDefault(require("./commands/revert"));
 const tag_1 = __importDefault(require("./commands/tag"));
+const test_packages_1 = __importDefault(require("./commands/test-packages"));
 const verify_1 = __importDefault(require("./commands/verify"));
 const utils_1 = require("./utils");
 const cli_error_1 = require("./utils/cli-error");
@@ -64,6 +65,7 @@ const createPgpmCommandMap = (skipPgTeardown = false) => {
         migrate: pgt(migrate_1.default),
         analyze: pgt(analyze_1.default),
         rename: pgt(rename_1.default),
+        'test-packages': pgt(test_packages_1.default),
         cache: cache_1.default,
         update: update_1.default
     };

package/esm/commands/test-packages.js

@@ -0,0 +1,315 @@
+import { PgpmPackage } from '@pgpmjs/core';
+import { getEnvOptions } from '@pgpmjs/env';
+import { Logger } from '@pgpmjs/logger';
+import path from 'path';
+import { getPgEnvOptions } from 'pg-env';
+import { getPgPool } from 'pg-cache';
+const log = new Logger('test-packages');
+// ANSI color codes
+const RED = '\x1b[0;31m';
+const GREEN = '\x1b[0;32m';
+const YELLOW = '\x1b[1;33m';
+const NC = '\x1b[0m'; // No Color
+const testPackagesUsageText = `
+Test Packages Command:
+
+  pgpm test-packages [OPTIONS]
+
+  Run integration tests on all PGPM packages in a workspace.
+  Tests each package with a deploy/verify/revert/deploy cycle.
+
+Options:
+  --help, -h           Show this help message
+  --exclude <pkgs>     Comma-separated module names to exclude
+  --stop-on-fail       Stop testing immediately when a package fails
+  --full-cycle         Run full deploy/verify/revert/deploy cycle (default: deploy only)
+  --cwd <directory>    Working directory (default: current directory)
+
+Examples:
+  pgpm test-packages                              Test all packages in workspace
+  pgpm test-packages --full-cycle                Run full test cycle with verify/revert
+  pgpm test-packages --stop-on-fail              Stop on first failure
+  pgpm test-packages --exclude my-module         Exclude specific modules
+`;
+function dbSafeName(moduleName) {
+    return `test_${moduleName}`.replace(/[^a-zA-Z0-9]/g, '_').toLowerCase();
+}
+async function createDatabase(dbname, adminDb = 'postgres') {
+    try {
+        const pgEnv = getPgEnvOptions({ database: adminDb });
+        const pool = getPgPool(pgEnv);
+        // Sanitize database name (only allow alphanumeric and underscore)
+        const safeName = dbname.replace(/[^a-zA-Z0-9_]/g, '_');
+        await pool.query(`CREATE DATABASE "${safeName}"`);
+        log.debug(`Created database: ${safeName}`);
+        return true;
+    }
+    catch (error) {
+        if (error.code === '42P04') {
+            // Database already exists, that's fine
+            log.debug(`Database ${dbname} already exists`);
+            return true;
+        }
+        log.error(`Failed to create database ${dbname}: ${error.message}`);
+        return false;
+    }
+}
+async function dropDatabase(dbname, adminDb = 'postgres') {
+    try {
+        const pgEnv = getPgEnvOptions({ database: adminDb });
+        const pool = getPgPool(pgEnv);
+        // Sanitize database name
+        const safeName = dbname.replace(/[^a-zA-Z0-9_]/g, '_');
+        // Terminate all connections to the database first
+        await pool.query(`
+      SELECT pg_terminate_backend(pid) 
+      FROM pg_stat_activity 
+      WHERE datname = $1 AND pid <> pg_backend_pid()
+    `, [safeName]);
+        await pool.query(`DROP DATABASE IF EXISTS "${safeName}"`);
+        log.debug(`Dropped database: ${safeName}`);
+    }
+    catch (error) {
+        // Ignore errors when dropping (database might not exist)
+        log.debug(`Could not drop database ${dbname}: ${error.message}`);
+    }
+}
+async function checkPostgresConnection() {
+    try {
+        const pgEnv = getPgEnvOptions({ database: 'postgres' });
+        const pool = getPgPool(pgEnv);
+        await pool.query('SELECT 1');
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function testModule(workspacePkg, modulePkg, fullCycle) {
+    const moduleName = modulePkg.getModuleName();
+    const modulePath = modulePkg.getModulePath() || '';
+    const dbname = dbSafeName(moduleName);
+    console.log(`${YELLOW}Testing module: ${moduleName}${NC}`);
+    console.log(`  Module path: ${modulePath}`);
+    console.log(`  Database name: ${dbname}`);
+    // Clean up any existing test database
+    await dropDatabase(dbname);
+    // Create fresh test database
+    console.log(`  Creating database: ${dbname}`);
+    if (!await createDatabase(dbname)) {
+        return {
+            moduleName,
+            modulePath,
+            success: false,
+            error: `Could not create database ${dbname}`
+        };
+    }
+    try {
+        // Create options for this test database
+        const opts = getEnvOptions({
+            pg: getPgEnvOptions({ database: dbname }),
+            deployment: {
+                useTx: true,
+                fast: false,
+                usePlan: true,
+                cache: false,
+                logOnly: false
+            }
+        });
+        // Deploy
+        console.log('  Running deploy...');
+        try {
+            await workspacePkg.deploy(opts, moduleName, true);
+        }
+        catch (error) {
+            await dropDatabase(dbname);
+            return {
+                moduleName,
+                modulePath,
+                success: false,
+                error: `Deploy failed: ${error.message}`
+            };
+        }
+        if (fullCycle) {
+            // Verify
+            console.log('  Running verify...');
+            try {
+                await workspacePkg.verify(opts, moduleName, true);
+            }
+            catch (error) {
+                await dropDatabase(dbname);
+                return {
+                    moduleName,
+                    modulePath,
+                    success: false,
+                    error: `Verify failed: ${error.message}`
+                };
+            }
+            // Revert
+            console.log('  Running revert...');
+            try {
+                await workspacePkg.revert(opts, moduleName, true);
+            }
+            catch (error) {
+                await dropDatabase(dbname);
+                return {
+                    moduleName,
+                    modulePath,
+                    success: false,
+                    error: `Revert failed: ${error.message}`
+                };
+            }
+            // Deploy again
+            console.log('  Running deploy (second time)...');
+            try {
+                await workspacePkg.deploy(opts, moduleName, true);
+            }
+            catch (error) {
+                await dropDatabase(dbname);
+                return {
+                    moduleName,
+                    modulePath,
+                    success: false,
+                    error: `Deploy (second time) failed: ${error.message}`
+                };
+            }
+        }
+        // Clean up test database
+        await dropDatabase(dbname);
+        console.log(`${GREEN}SUCCESS: Module ${moduleName} passed all tests${NC}`);
+        return {
+            moduleName,
+            modulePath,
+            success: true
+        };
+    }
+    catch (error) {
+        // Ensure cleanup on any unexpected error
+        await dropDatabase(dbname);
+        return {
+            moduleName,
+            modulePath,
+            success: false,
+            error: `Unexpected error: ${error.message}`
+        };
+    }
+}
+export default async (argv, _prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(testPackagesUsageText);
+        process.exit(0);
+    }
+    // Parse options
+    const stopOnFail = argv['stop-on-fail'] === true || argv.stopOnFail === true;
+    const fullCycle = argv['full-cycle'] === true || argv.fullCycle === true;
+    const cwd = argv.cwd || process.cwd();
+    // Parse excludes
+    let excludes = [];
+    if (argv.exclude) {
+        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'}`);
+    if (stopOnFail) {
+        console.log('Mode: Stop on first failure');
+    }
+    else {
+        console.log('Mode: Test all packages (collect all failures)');
+    }
+    console.log('');
+    // Check PostgreSQL connection
+    console.log('Checking PostgreSQL connection...');
+    if (!await checkPostgresConnection()) {
+        log.error('PostgreSQL not accessible.');
+        console.log('Ensure PostgreSQL is running and connection settings are correct.');
+        console.log('For local development: docker-compose up -d');
+        console.log('For CI: ensure PostgreSQL service is running');
+        process.exit(1);
+    }
+    console.log('PostgreSQL connection successful');
+    console.log('');
+    // Initialize workspace package
+    const projectRoot = path.resolve(cwd);
+    const workspacePkg = new PgpmPackage(projectRoot);
+    if (!workspacePkg.getWorkspacePath()) {
+        log.error('Not in a PGPM workspace. Run this command from a workspace root.');
+        process.exit(1);
+    }
+    // Get all modules from workspace using internal API
+    console.log('Finding all PGPM modules in workspace...');
+    const modules = await workspacePkg.getModules();
+    if (modules.length === 0) {
+        log.warn('No modules found in workspace.');
+        process.exit(0);
+    }
+    // Filter out excluded modules
+    let filteredModules = modules;
+    if (excludes.length > 0) {
+        filteredModules = modules.filter(mod => {
+            const moduleName = mod.getModuleName();
+            return !excludes.includes(moduleName);
+        });
+        console.log(`Excluding: ${excludes.join(', ')}`);
+    }
+    console.log(`Found ${filteredModules.length} modules to test:`);
+    for (const mod of filteredModules) {
+        console.log(`  - ${mod.getModuleName()}`);
+    }
+    console.log('');
+    const failedPackages = [];
+    const successfulPackages = [];
+    for (const modulePkg of filteredModules) {
+        const result = await testModule(workspacePkg, modulePkg, fullCycle);
+        if (result.success) {
+            successfulPackages.push(result);
+        }
+        else {
+            failedPackages.push(result);
+            if (stopOnFail) {
+                console.log('');
+                console.error(`${RED}STOPPING: Test failed for module ${result.moduleName} and --stop-on-fail was specified${NC}`);
+                console.log('');
+                console.log('=== TEST SUMMARY (PARTIAL) ===');
+                if (successfulPackages.length > 0) {
+                    console.log(`${GREEN}Successful modules before failure (${successfulPackages.length}):${NC}`);
+                    for (const pkg of successfulPackages) {
+                        console.log(`  ${GREEN}✓${NC} ${pkg.moduleName}`);
+                    }
+                    console.log('');
+                }
+                console.error(`${RED}Failed module: ${result.moduleName}${NC}`);
+                if (result.error) {
+                    console.error(`  Error: ${result.error}`);
+                }
+                console.log('');
+                console.error(`${RED}OVERALL RESULT: FAILED (stopped on first failure)${NC}`);
+                process.exit(1);
+            }
+        }
+        console.log('');
+    }
+    console.log('=== TEST SUMMARY ===');
+    console.log(`${GREEN}Successful modules (${successfulPackages.length}):${NC}`);
+    for (const pkg of successfulPackages) {
+        console.log(`  ${GREEN}✓${NC} ${pkg.moduleName}`);
+    }
+    if (failedPackages.length > 0) {
+        console.log('');
+        console.error(`${RED}Failed modules (${failedPackages.length}):${NC}`);
+        for (const pkg of failedPackages) {
+            console.error(`  ${RED}✗${NC} ${pkg.moduleName}`);
+            if (pkg.error) {
+                console.error(`    Error: ${pkg.error}`);
+            }
+        }
+        console.log('');
+        console.error(`${RED}OVERALL RESULT: FAILED${NC}`);
+        process.exit(1);
+    }
+    else {
+        console.log('');
+        console.log(`${GREEN}OVERALL RESULT: ALL MODULES PASSED${NC}`);
+        process.exit(0);
+    }
+};

package/esm/commands.js

@@ -21,6 +21,7 @@ import remove from './commands/remove';
 import renameCmd from './commands/rename';
 import revert from './commands/revert';
 import tag from './commands/tag';
+import testPackages from './commands/test-packages';
 import verify from './commands/verify';
 import { extractFirst, usageText } from './utils';
 import { cliExitWithError } from './utils/cli-error';
@@ -58,6 +59,7 @@ export const createPgpmCommandMap = (skipPgTeardown = false) => {
         migrate: pgt(migrate),
         analyze: pgt(analyze),
         rename: pgt(renameCmd),
+        'test-packages': pgt(testPackages),
         cache,
         update: updateCmd
     };

package/esm/index.js

@@ -23,6 +23,7 @@ export { default as remove } from './commands/remove';
 export { default as renameCmd } from './commands/rename';
 export { default as revert } from './commands/revert';
 export { default as tag } from './commands/tag';
+export { default as testPackages } from './commands/test-packages';
 export { default as verify } from './commands/verify';
 export * from './utils';
 export const options = {

package/index.d.ts

@@ -21,6 +21,7 @@ export { default as remove } from './commands/remove';
 export { default as renameCmd } from './commands/rename';
 export { default as revert } from './commands/revert';
 export { default as tag } from './commands/tag';
+export { default as testPackages } from './commands/test-packages';
 export { default as verify } from './commands/verify';
 export * from './utils';
 export declare const options: Partial<CLIOptions>;

package/index.js

@@ -18,7 +18,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.options = exports.verify = exports.tag = exports.revert = exports.renameCmd = exports.remove = exports.plan = exports._package = exports.migrate = exports.kill = exports.install = exports.extension = exports._export = exports.env = exports.docker = exports.deploy = exports.clear = exports.analyze = exports.adminUsers = exports.add = exports.createPgpmCommandMap = exports.createInitUsageText = void 0;
+exports.options = exports.verify = exports.testPackages = exports.tag = exports.revert = exports.renameCmd = exports.remove = exports.plan = exports._package = exports.migrate = exports.kill = exports.install = exports.extension = exports._export = exports.env = exports.docker = exports.deploy = exports.clear = exports.analyze = exports.adminUsers = exports.add = exports.createPgpmCommandMap = exports.createInitUsageText = void 0;
 const fs_1 = require("fs");
 const inquirerer_1 = require("inquirerer");
 const path_1 = require("path");
@@ -62,6 +62,8 @@ var revert_1 = require("./commands/revert");
 Object.defineProperty(exports, "revert", { enumerable: true, get: function () { return __importDefault(revert_1).default; } });
 var tag_1 = require("./commands/tag");
 Object.defineProperty(exports, "tag", { enumerable: true, get: function () { return __importDefault(tag_1).default; } });
+var test_packages_1 = require("./commands/test-packages");
+Object.defineProperty(exports, "testPackages", { enumerable: true, get: function () { return __importDefault(test_packages_1).default; } });
 var verify_1 = require("./commands/verify");
 Object.defineProperty(exports, "verify", { enumerable: true, get: function () { return __importDefault(verify_1).default; } });
 __exportStar(require("./utils"), exports);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pgpm",
-  "version": "1.1.4",
+  "version": "1.2.0",
   "author": "Constructive <developers@constructive.io>",
   "description": "PostgreSQL Package Manager - Database migration and package management CLI",
   "main": "index.js",
@@ -45,7 +45,7 @@
     "ts-node": "^10.9.2"
   },
   "dependencies": {
-    "@pgpmjs/core": "^3.1.2",
+    "@pgpmjs/core": "^3.1.3",
     "@pgpmjs/env": "^2.8.8",
     "@pgpmjs/logger": "^1.3.5",
     "@pgpmjs/types": "^2.12.6",
@@ -73,5 +73,5 @@
     "pg",
     "pgsql"
   ],
-  "gitHead": "deb816f0fb9aad6cef1accf0dc603e016e48d335"
+  "gitHead": "baf8d2ffc48a6792573cd613bba0b108574b9477"
 }