pgpm 0.0.1

package/esm/commands/verify.js

@@ -0,0 +1,83 @@
+import { LaunchQLPackage } from '@launchql/core';
+import { Logger } from '@launchql/logger';
+import { getEnvOptions } from '@launchql/env';
+import { getPgEnvOptions } from 'pg-env';
+import { getTargetDatabase } from '../utils';
+import { selectDeployedChange, selectDeployedPackage } from '../utils/deployed-changes';
+import { cliExitWithError } from '../utils/cli-error';
+const log = new Logger('verify');
+const verifyUsageText = `
+LaunchQL Verify Command:
+
+  lql verify [OPTIONS]
+
+  Verify database state matches expected migrations.
+
+Options:
+  --help, -h         Show this help message
+  --recursive        Verify recursively through dependencies
+  --package <name>   Verify specific package
+  --to <target>      Verify up to specific change or tag
+  --to               Interactive selection of deployed changes
+  --cwd <directory>  Working directory (default: current directory)
+
+Examples:
+  lql verify                    Verify current database state
+  lql verify --package mypackage  Verify specific package
+  lql verify --to              Interactive selection from deployed changes
+`;
+export default async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(verifyUsageText);
+        process.exit(0);
+    }
+    const database = await getTargetDatabase(argv, prompter, {
+        message: 'Select database'
+    });
+    const questions = [
+        {
+            name: 'recursive',
+            type: 'confirm',
+            message: 'Deploy recursively through dependencies?',
+            useDefault: true,
+            default: true,
+            required: false
+        },
+    ];
+    let { recursive, cwd } = await prompter.prompt(argv, questions);
+    log.debug(`Using current directory: ${cwd}`);
+    let packageName;
+    if (recursive && argv.to !== true) {
+        packageName = await selectDeployedPackage(database, argv, prompter, log, 'verify');
+        if (!packageName) {
+            await cliExitWithError('No package found to verify');
+        }
+    }
+    const project = new LaunchQLPackage(cwd);
+    const opts = getEnvOptions({
+        pg: getPgEnvOptions({ database })
+    });
+    let target;
+    if (argv.to === true) {
+        target = await selectDeployedChange(database, argv, prompter, log, 'verify');
+        if (!target) {
+            await cliExitWithError('No target selected, operation cancelled');
+        }
+    }
+    else if (packageName && argv.to) {
+        target = `${packageName}:${argv.to}`;
+    }
+    else if (packageName) {
+        target = packageName;
+    }
+    else if (argv.package && argv.to) {
+        target = `${argv.package}:${argv.to}`;
+    }
+    else if (argv.package) {
+        target = argv.package;
+    }
+    await project.verify(opts, target, recursive);
+    log.success('Verify complete.');
+    return argv;
+};

package/esm/commands.js

@@ -0,0 +1,111 @@
+import { teardownPgPools } from 'pg-cache';
+// Commands
+import add from './commands/add';
+import adminUsers from './commands/admin-users';
+import clear from './commands/clear';
+import deploy from './commands/deploy';
+import explorer from './commands/explorer';
+import _export from './commands/export';
+import extension from './commands/extension';
+import init from './commands/init';
+import install from './commands/install';
+import kill from './commands/kill';
+import migrate from './commands/migrate';
+import _package from './commands/package';
+import plan from './commands/plan';
+import remove from './commands/remove';
+import revert from './commands/revert';
+import server from './commands/server';
+import tag from './commands/tag';
+import verify from './commands/verify';
+import analyze from './commands/analyze';
+import renameCmd from './commands/rename';
+import { readAndParsePackageJson } from './package';
+import { extractFirst, usageText } from './utils';
+import { cliExitWithError } from './utils/cli-error';
+const withPgTeardown = (fn, skipTeardown = false) => async (...args) => {
+    try {
+        await fn(...args);
+    }
+    finally {
+        if (!skipTeardown) {
+            await teardownPgPools();
+        }
+    }
+};
+const createCommandMap = (skipPgTeardown = false) => {
+    const pgt = (fn) => withPgTeardown(fn, skipPgTeardown);
+    return {
+        add,
+        'admin-users': pgt(adminUsers),
+        clear: pgt(clear),
+        deploy: pgt(deploy),
+        verify: pgt(verify),
+        revert: pgt(revert),
+        remove: pgt(remove),
+        init: pgt(init),
+        extension: pgt(extension),
+        plan: pgt(plan),
+        export: pgt(_export),
+        package: pgt(_package),
+        tag: pgt(tag),
+        kill: pgt(kill),
+        install: pgt(install),
+        migrate: pgt(migrate),
+        analyze: pgt(analyze),
+        rename: pgt(renameCmd),
+        // These manage their own connection lifecycles
+        server,
+        explorer
+    };
+};
+export const commands = async (argv, prompter, options) => {
+    if (argv.version || argv.v) {
+        const pkg = readAndParsePackageJson();
+        console.log(pkg.version);
+        process.exit(0);
+    }
+    let { first: command, newArgv } = extractFirst(argv);
+    // Show usage if explicitly requested but no command specified
+    if ((argv.help || argv.h || command === 'help') && !command) {
+        console.log(usageText);
+        process.exit(0);
+    }
+    // Show usage for help command specifically
+    if (command === 'help') {
+        console.log(usageText);
+        process.exit(0);
+    }
+    const commandMap = createCommandMap(options?.skipPgTeardown);
+    // Prompt if no command provided
+    if (!command) {
+        const answer = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'command',
+                message: 'What do you want to do?',
+                options: Object.keys(commandMap)
+            }
+        ]);
+        command = answer.command;
+    }
+    // Prompt for working directory
+    newArgv = await prompter.prompt(newArgv, [
+        {
+            type: 'text',
+            name: 'cwd',
+            message: 'Working directory',
+            required: false,
+            default: process.cwd(),
+            useDefault: true
+        }
+    ]);
+    const commandFn = commandMap[command];
+    if (!commandFn) {
+        console.log(usageText);
+        await cliExitWithError(`Unknown command: ${command}`);
+    }
+    await commandFn(newArgv, prompter, options);
+    prompter.close();
+    return argv;
+};

package/esm/index.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { CLI } from 'inquirerer';
+import { commands } from './commands';
+export const options = {
+    minimistOpts: {
+        alias: {
+            v: 'version',
+            h: 'help'
+        }
+    }
+};
+const app = new CLI(commands, options);
+app.run().then(() => {
+    // all done!
+}).catch(error => {
+    // Should not reach here with the new CLI error handling pattern
+    // But keep as fallback for unexpected errors
+    console.error('Unexpected error:', error);
+    process.exit(1);
+});

package/esm/package.js

@@ -0,0 +1,26 @@
+import { existsSync, readFileSync } from 'fs';
+import { dirname, join } from 'path';
+// need to search due to the dist/ folder and src/, etc.
+function findPackageJson(currentDir) {
+    const filePath = join(currentDir, 'package.json');
+    // Check if package.json exists in the current directory
+    if (existsSync(filePath)) {
+        return filePath;
+    }
+    // Get the parent directory
+    const parentDir = dirname(currentDir);
+    // If reached the root directory, package.json is not found
+    if (parentDir === currentDir) {
+        throw new Error('package.json not found in any parent directory');
+    }
+    // Recursively look in the parent directory
+    return findPackageJson(parentDir);
+}
+export function readAndParsePackageJson() {
+    // Start searching from the current directory
+    const pkgPath = findPackageJson(__dirname);
+    // Read and parse the package.json
+    const str = readFileSync(pkgPath, 'utf8');
+    const pkg = JSON.parse(str);
+    return pkg;
+}

package/esm/utils/argv.js

@@ -0,0 +1,92 @@
+import { Logger } from '@launchql/logger';
+const log = new Logger('argv-utils');
+export const extractFirst = (argv) => {
+    const first = argv._?.[0];
+    const newArgv = {
+        ...argv,
+        _: argv._?.slice(1) ?? []
+    };
+    return { first, newArgv };
+};
+/**
+ * Validates and normalizes common CLI arguments
+ */
+export function validateCommonArgs(argv) {
+    const validated = {
+        ...argv,
+        cwd: argv.cwd || process.cwd(),
+        _: argv._ || []
+    };
+    const booleanFlags = ['recursive', 'yes', 'tx', 'fast', 'logOnly', 'createdb', 'usePlan', 'cache', 'drop', 'all', 'summary', 'help', 'h'];
+    for (const flag of booleanFlags) {
+        if (argv[flag] !== undefined && typeof argv[flag] !== 'boolean') {
+            log.warn(`--${flag} flag should be boolean, converting to true`);
+            validated[flag] = true;
+        }
+    }
+    const stringFlags = ['package', 'to', 'database'];
+    for (const flag of stringFlags) {
+        if (argv[flag] !== undefined && typeof argv[flag] !== 'string') {
+            log.warn(`--${flag} should be a string, converting`);
+            validated[flag] = String(argv[flag]);
+        }
+    }
+    return validated;
+}
+/**
+ * Checks if required flags are provided when certain conditions are met
+ */
+export function validateFlagDependencies(argv) {
+    if (argv.to && !argv.package && !argv.recursive) {
+        log.warn('--to flag provided without --package or --recursive. Target may not work as expected.');
+    }
+    if (argv.package && argv.recursive) {
+        if (argv.package.includes(':')) {
+            log.warn('--package should not contain ":" when using --recursive. Use --to for target specification.');
+        }
+    }
+}
+/**
+ * Logs the effective CLI arguments for debugging
+ */
+export function logEffectiveArgs(argv, commandName) {
+    const relevantArgs = {
+        cwd: argv.cwd,
+        database: argv.database,
+        package: argv.package,
+        to: argv.to,
+        recursive: argv.recursive,
+        yes: argv.yes,
+        tx: argv.tx,
+        fast: argv.fast,
+        logOnly: argv.logOnly,
+        createdb: argv.createdb,
+        usePlan: argv.usePlan,
+        cache: argv.cache,
+        drop: argv.drop,
+        all: argv.all,
+        summary: argv.summary
+    };
+    const definedArgs = Object.fromEntries(Object.entries(relevantArgs).filter(([_, value]) => value !== undefined));
+    if (Object.keys(definedArgs).length > 1) { // More than just cwd
+        log.debug(`${commandName} effective arguments:`, definedArgs);
+    }
+}
+/**
+ * Constructs a deployment target string from package and to arguments
+ */
+export function constructTarget(argv, packageName) {
+    if (packageName && argv.to) {
+        return `${packageName}:${argv.to}`;
+    }
+    else if (packageName) {
+        return packageName;
+    }
+    else if (argv.package && argv.to) {
+        return `${argv.package}:${argv.to}`;
+    }
+    else if (argv.package) {
+        return argv.package;
+    }
+    return undefined;
+}

package/esm/utils/cli-error.js

@@ -0,0 +1,48 @@
+import { LaunchQLError } from '@launchql/types';
+import { Logger } from '@launchql/logger';
+import { teardownPgPools } from 'pg-cache';
+const log = new Logger('cli');
+/**
+ * CLI error utility that logs error information and exits with code 1.
+ * Provides consistent error handling and user experience across all CLI commands.
+ *
+ * IMPORTANT: This function properly cleans up PostgreSQL connections before exiting.
+ */
+export const cliExitWithError = async (error, context) => {
+    if (error instanceof LaunchQLError) {
+        // For LaunchQLError instances, use structured logging
+        log.error(`Error: ${error.message}`);
+        // Log additional context if available
+        if (error.context && Object.keys(error.context).length > 0) {
+            log.debug('Error context:', error.context);
+        }
+        // Log any additional context provided
+        if (context) {
+            log.debug('Additional context:', context);
+        }
+    }
+    else if (error instanceof Error) {
+        // For generic Error instances
+        log.error(`Error: ${error.message}`);
+        if (context) {
+            log.debug('Context:', context);
+        }
+    }
+    else if (typeof error === 'string') {
+        // For simple string messages
+        log.error(`Error: ${error}`);
+        if (context) {
+            log.debug('Context:', context);
+        }
+    }
+    // Perform cleanup before exiting
+    try {
+        await teardownPgPools();
+        log.debug('Database connections cleaned up');
+    }
+    catch (cleanupError) {
+        log.warn('Failed to cleanup database connections:', cleanupError);
+        // Don't let cleanup errors prevent the exit
+    }
+    process.exit(1);
+};

package/esm/utils/database.js

@@ -0,0 +1,78 @@
+import { getPgPool } from 'pg-cache';
+import { getPgEnvOptions } from 'pg-env';
+/**
+ * Get list of available databases from PostgreSQL
+ */
+export async function getAvailableDatabases(options = {}) {
+    const { excludeTemplates = true, excludePostgres = true, excludeSystemDbs = true } = options;
+    const db = await getPgPool({
+        database: 'postgres'
+    });
+    let query = `
+    SELECT datname FROM pg_catalog.pg_database
+    WHERE 1=1
+  `;
+    if (excludeTemplates) {
+        query += ` AND datistemplate = FALSE`;
+    }
+    if (excludePostgres) {
+        query += ` AND datname NOT IN ('postgres')`;
+    }
+    if (excludeSystemDbs) {
+        query += ` AND datname !~ '^pg_'`;
+    }
+    query += ` ORDER BY datname`;
+    const result = await db.query(query);
+    return result.rows.map((row) => row.datname);
+}
+/**
+ * Prompt user to select a database
+ */
+export async function selectDatabase(argv, prompter, options = {}) {
+    const { message = 'Select target database', multiple = false } = options;
+    // Check if database is already specified
+    if (!multiple && (argv.db || argv.database)) {
+        return argv.db || argv.database;
+    }
+    // Get available databases
+    const databases = await getAvailableDatabases(options);
+    if (databases.length === 0) {
+        throw new Error('No databases found');
+    }
+    // If only one database and not forcing selection, use it
+    if (!multiple && databases.length === 1 && !argv.interactive) {
+        return databases[0];
+    }
+    // Prompt for selection
+    const answer = await prompter.prompt(argv, [
+        {
+            type: multiple ? 'checkbox' : 'autocomplete',
+            name: 'database',
+            message,
+            options: databases,
+            required: true
+        }
+    ]);
+    return answer.database;
+}
+/**
+ * Get target database with fallback to environment
+ */
+export async function getTargetDatabase(argv, prompter, options = {}) {
+    // If database is specified in args, use it
+    if (argv.db || argv.database) {
+        return argv.db || argv.database;
+    }
+    // Try to select from available databases
+    try {
+        return await selectDatabase(argv, prompter, options);
+    }
+    catch (error) {
+        // Fall back to environment database
+        const pgEnv = getPgEnvOptions();
+        if (pgEnv.database) {
+            return pgEnv.database;
+        }
+        throw new Error('No database specified and no default database found');
+    }
+}

package/esm/utils/deployed-changes.js

@@ -0,0 +1,68 @@
+import { LaunchQLMigrate } from '@launchql/core';
+import { getPgEnvOptions } from 'pg-env';
+export async function selectDeployedChange(database, argv, prompter, log, action = 'revert') {
+    const pgEnv = getPgEnvOptions({ database });
+    const client = new LaunchQLMigrate(pgEnv);
+    let selectedPackage;
+    if (argv.package) {
+        selectedPackage = argv.package;
+    }
+    else {
+        const packageStatuses = await client.status();
+        if (packageStatuses.length === 0) {
+            log.warn('No deployed packages found in database');
+            return undefined;
+        }
+        const packageAnswer = await prompter.prompt(argv, [{
+                type: 'autocomplete',
+                name: 'package',
+                message: `Select package to ${action} from:`,
+                options: packageStatuses.map(status => ({
+                    name: status.package,
+                    value: status.package,
+                    description: `${status.totalDeployed} changes, last: ${status.lastChange}`
+                }))
+            }]);
+        selectedPackage = packageAnswer.package;
+    }
+    const deployedChanges = await client.getDeployedChanges(database, selectedPackage);
+    if (deployedChanges.length === 0) {
+        log.warn(`No deployed changes found for package ${selectedPackage}`);
+        return undefined;
+    }
+    const changeAnswer = await prompter.prompt(argv, [{
+            type: 'autocomplete',
+            name: 'change',
+            message: `Select change to ${action} to in ${selectedPackage}:`,
+            options: deployedChanges.map(change => ({
+                name: change.change_name,
+                value: change.change_name,
+                description: `Deployed: ${new Date(change.deployed_at).toLocaleString()}`
+            }))
+        }]);
+    const selectedChange = changeAnswer.change;
+    return `${selectedPackage}:${selectedChange}`;
+}
+export async function selectDeployedPackage(database, argv, prompter, log, action = 'revert') {
+    if (argv.package) {
+        return argv.package;
+    }
+    const pgEnv = getPgEnvOptions({ database });
+    const client = new LaunchQLMigrate(pgEnv);
+    const packageStatuses = await client.status();
+    if (packageStatuses.length === 0) {
+        log.warn('No deployed packages found in database');
+        return undefined;
+    }
+    const packageAnswer = await prompter.prompt(argv, [{
+            type: 'autocomplete',
+            name: 'package',
+            message: `Select package to ${action}:`,
+            options: packageStatuses.map(status => ({
+                name: status.package,
+                value: status.package,
+                description: `${status.totalDeployed} changes, last: ${status.lastChange}`
+            }))
+        }]);
+    return packageAnswer.package;
+}

package/esm/utils/display.js

@@ -0,0 +1,58 @@
+import chalk from 'chalk';
+import { readAndParsePackageJson } from '../package';
+// Function to display the version information
+export function displayVersion() {
+    const pkg = readAndParsePackageJson();
+    console.log(chalk.green(`Name: ${pkg.name}`));
+    console.log(chalk.blue(`Version: ${pkg.version}`));
+}
+export const usageText = `
+  Usage: lql <command> [options]
+         launchql <command> [options]
+  
+  Core Database Operations:
+    add                Add database changes to plans and create SQL files
+    deploy             Deploy database changes and migrations
+    verify             Verify database state and migrations
+    revert             Revert database changes and migrations
+  
+  Project Management:
+    init               Initialize LaunchQL workspace or module
+    extension          Manage module dependencies
+    plan               Generate module deployment plans
+    package            Package module for distribution
+  
+  Development Tools:
+    server             Start LaunchQL GraphQL server
+    explorer           Launch GraphiQL explorer interface
+    export             Export database migrations from existing databases
+  
+  Database Administration:
+    kill               Terminate database connections and optionally drop databases
+    install            Install LaunchQL modules
+    tag                Add tags to changes for versioning
+  
+  Migration Tools:
+    migrate            Migration management subcommands
+      init             Initialize migration tracking
+      status           Show migration status
+      list             List all changes
+      deps             Show change dependencies
+  
+  Global Options:
+    -h, --help         Display this help information
+    -v, --version      Display version information
+    --cwd <directory>  Working directory (default: current directory)
+  
+  Individual Command Help:
+    lql <command> --help    Display detailed help for specific command
+    lql <command> -h        Display detailed help for specific command
+  
+  Examples:
+    lql deploy --help       Show deploy command options
+    lql server --port 8080  Start server on port 8080
+    lql init --workspace    Initialize new workspace
+  `;
+export function displayUsage() {
+    console.log(usageText);
+}

package/esm/utils/index.js

@@ -0,0 +1,3 @@
+export * from './argv';
+export * from './database';
+export * from './display';

package/esm/utils/module-utils.js

@@ -0,0 +1,51 @@
+import { LaunchQLPackage } from '@launchql/core';
+import { errors } from '@launchql/types';
+/**
+ * Handle package selection for operations that need a specific package
+ * Returns the selected package name, or undefined if validation fails or no packages exist
+ */
+export async function selectPackage(argv, prompter, cwd, operationName, log) {
+    const pkg = new LaunchQLPackage(cwd);
+    const modules = await pkg.getModules();
+    const moduleNames = modules.map(mod => mod.getModuleName());
+    // Check if any modules exist
+    if (!moduleNames.length) {
+        const errorMsg = 'No modules found in the specified directory.';
+        if (log) {
+            log.error(errorMsg);
+            return undefined;
+        }
+        else {
+            prompter.close();
+            throw errors.NOT_FOUND({}, errorMsg);
+        }
+    }
+    // If a specific package was provided, validate it
+    if (argv.package) {
+        const packageName = argv.package;
+        if (log)
+            log.info(`Using specified package: ${packageName}`);
+        if (!moduleNames.includes(packageName)) {
+            const errorMsg = `Package '${packageName}' not found. Available packages: ${moduleNames.join(', ')}`;
+            if (log) {
+                log.error(errorMsg);
+                return undefined;
+            }
+            else {
+                throw errors.NOT_FOUND({}, errorMsg);
+            }
+        }
+        return packageName;
+    }
+    // Interactive selection
+    const { package: selectedPackage } = await prompter.prompt(argv, [{
+            type: 'autocomplete',
+            name: 'package',
+            message: `Choose a package to ${operationName}`,
+            options: moduleNames,
+            required: true
+        }]);
+    if (log)
+        log.info(`Selected package: ${selectedPackage}`);
+    return selectedPackage;
+}

package/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { CLIOptions } from 'inquirerer';
+export declare const options: Partial<CLIOptions>;

package/index.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.options = void 0;
+const inquirerer_1 = require("inquirerer");
+const commands_1 = require("./commands");
+exports.options = {
+    minimistOpts: {
+        alias: {
+            v: 'version',
+            h: 'help'
+        }
+    }
+};
+const app = new inquirerer_1.CLI(commands_1.commands, exports.options);
+app.run().then(() => {
+    // all done!
+}).catch(error => {
+    // Should not reach here with the new CLI error handling pattern
+    // But keep as fallback for unexpected errors
+    console.error('Unexpected error:', error);
+    process.exit(1);
+});

package/package.d.ts

@@ -0,0 +1 @@
+export declare function readAndParsePackageJson(): any;