pgpm 0.0.1

package/commands/migrate/list.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const core_2 = require("@launchql/core");
+const logger_1 = require("@launchql/logger");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const pg_env_1 = require("pg-env");
+const database_1 = require("../../utils/database");
+const log = new logger_1.Logger('migrate-list');
+exports.default = async (argv, prompter, options) => {
+    const cwd = argv.cwd || process.cwd();
+    const planPath = (0, path_1.join)(cwd, 'launchql.plan');
+    if (!(0, fs_1.existsSync)(planPath)) {
+        log.error(`No launchql.plan found in ${cwd}`);
+        process.exit(1);
+    }
+    // Get database configuration
+    const pgEnv = (0, pg_env_1.getPgEnvOptions)();
+    const targetDatabase = await (0, database_1.getTargetDatabase)(argv, prompter, {
+        message: 'Select database to list migrations'
+    });
+    const client = new core_1.LaunchQLMigrate({
+        host: pgEnv.host,
+        port: pgEnv.port,
+        user: pgEnv.user,
+        password: pgEnv.password,
+        database: pgEnv.database
+    });
+    try {
+        // Get all changes from plan file
+        const planResult = (0, core_2.parsePlanFile)(planPath);
+        if (!planResult.data || planResult.errors.length > 0) {
+            log.error('Failed to parse plan file:', planResult.errors);
+            process.exit(1);
+        }
+        const plan = planResult.data;
+        const allChanges = plan.changes;
+        // Get deployed changes from database
+        const deployedChanges = await client.getDeployedChanges(targetDatabase, plan.package);
+        console.log('\n📋 All Changes\n');
+        console.log(`Package: ${plan.package}`);
+        console.log(`Total Changes: ${allChanges.length}`);
+        console.log(`Deployed: ${deployedChanges.length}`);
+        console.log(`Pending: ${allChanges.length - deployedChanges.length}\n`);
+        // Create a map for quick lookup
+        const deployedMap = new Map(deployedChanges.map(c => [c.change_name, c]));
+        // List all changes with their status
+        const showAll = argv.all || allChanges.length <= 20;
+        const changesToShow = showAll ? allChanges : allChanges.slice(0, 20);
+        console.log('Status  Change Name                    Dependencies');
+        console.log('------  -----------------------------  --------------------------------');
+        changesToShow.forEach(change => {
+            const deployed = deployedMap.get(change.name);
+            const status = deployed ? '✅' : '⏳';
+            const deps = change.dependencies.length > 0 ? change.dependencies.join(', ') : '-';
+            const depsDisplay = deps.length > 30 ? deps.substring(0, 27) + '...' : deps;
+            console.log(`${status}      ${change.name.padEnd(30)} ${depsDisplay}`);
+        });
+        if (!showAll && allChanges.length > 20) {
+            console.log(`\n... and ${allChanges.length - 20} more changes. Use --all to see all changes.`);
+        }
+        // Show summary by status
+        if (argv.summary !== false) {
+            console.log('\n📊 Summary by Status:\n');
+            const pending = allChanges.filter(c => !deployedMap.has(c.name));
+            const deployed = allChanges.filter(c => deployedMap.has(c.name));
+            console.log(`✅ Deployed: ${deployed.length}`);
+            console.log(`⏳ Pending:  ${pending.length}`);
+            // Show deployment timeline
+            if (deployedChanges.length > 0) {
+                const sortedDeployed = [...deployedChanges].sort((a, b) => new Date(a.deployed_at).getTime() - new Date(b.deployed_at).getTime());
+                const firstDeploy = new Date(sortedDeployed[0].deployed_at);
+                const lastDeploy = new Date(sortedDeployed[sortedDeployed.length - 1].deployed_at);
+                console.log(`\n📅 Deployment Timeline:`);
+                console.log(`   First: ${firstDeploy.toLocaleString()}`);
+                console.log(`   Last:  ${lastDeploy.toLocaleString()}`);
+            }
+        }
+    }
+    catch (error) {
+        log.error('Failed to list changes:', error);
+        process.exit(1);
+    }
+};

package/commands/migrate/status.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<void>;
+export default _default;

package/commands/migrate/status.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const core_2 = require("@launchql/core");
+const logger_1 = require("@launchql/logger");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const pg_env_1 = require("pg-env");
+const database_1 = require("../../utils/database");
+const log = new logger_1.Logger('migrate-status');
+exports.default = async (argv, prompter, options) => {
+    const cwd = argv.cwd || process.cwd();
+    const planPath = (0, path_1.join)(cwd, 'launchql.plan');
+    if (!(0, fs_1.existsSync)(planPath)) {
+        log.error(`No launchql.plan found in ${cwd}`);
+        process.exit(1);
+    }
+    // Get database configuration
+    const pgEnv = (0, pg_env_1.getPgEnvOptions)();
+    const targetDatabase = await (0, database_1.getTargetDatabase)(argv, prompter, {
+        message: 'Select database to check migration status'
+    });
+    const client = new core_1.LaunchQLMigrate({
+        host: pgEnv.host,
+        port: pgEnv.port,
+        user: pgEnv.user,
+        password: pgEnv.password,
+        database: pgEnv.database
+    });
+    try {
+        // Parse plan file to get package name
+        const planResult = (0, core_2.parsePlanFile)(planPath);
+        if (!planResult.data || planResult.errors.length > 0) {
+            log.error('Failed to parse plan file:', planResult.errors);
+            process.exit(1);
+        }
+        const plan = planResult.data;
+        // Switch to target database
+        const targetClient = new core_1.LaunchQLMigrate({
+            host: pgEnv.host,
+            port: pgEnv.port,
+            user: pgEnv.user,
+            password: pgEnv.password,
+            database: targetDatabase
+        });
+        const statusResults = await targetClient.status(plan.package);
+        console.log('\n📊 Migration Status\n');
+        console.log(`Database: ${targetDatabase}`);
+        if (statusResults.length > 0) {
+            const status = statusResults[0];
+            console.log(`Package: ${status.package}`);
+            console.log(`Total Deployed: ${status.totalDeployed}`);
+            if (status.lastChange) {
+                console.log(`Last Change: ${status.lastChange}`);
+                console.log(`Last Deployed: ${status.lastDeployed.toLocaleString()}`);
+            }
+            else {
+                console.log('No changes deployed yet');
+            }
+        }
+        else {
+            console.log(`Package: ${plan.package}`);
+            console.log('No deployment history found');
+        }
+        // Show recent changes
+        const recentChanges = await targetClient.getRecentChanges(targetDatabase, 5);
+        if (recentChanges.length > 0) {
+            console.log('\n📋 Recent Changes:\n');
+            recentChanges.forEach((change) => {
+                const status = change.deployed_at ? '✅' : '⏳';
+                const date = change.deployed_at ? new Date(change.deployed_at).toLocaleString() : 'Not deployed';
+                console.log(`${status} ${change.change_name.padEnd(30)} ${date}`);
+            });
+        }
+        // Show pending changes
+        const pendingChanges = await targetClient.getPendingChanges(planPath, targetDatabase);
+        if (pendingChanges.length > 0) {
+            console.log(`\n⏳ Pending Changes: ${pendingChanges.length}\n`);
+            pendingChanges.slice(0, 5).forEach((change) => {
+                console.log(`   - ${change}`);
+            });
+            if (pendingChanges.length > 5) {
+                console.log(`   ... and ${pendingChanges.length - 5} more`);
+            }
+        }
+        else {
+            console.log('\n✅ All changes deployed');
+        }
+    }
+    catch (error) {
+        log.error('Failed to get migration status:', error);
+        process.exit(1);
+    }
+};

package/commands/migrate.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<void>;
+export default _default;

package/commands/migrate.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const deps_1 = __importDefault(require("./migrate/deps"));
+// Migrate subcommands
+const init_1 = __importDefault(require("./migrate/init"));
+const list_1 = __importDefault(require("./migrate/list"));
+const status_1 = __importDefault(require("./migrate/status"));
+const subcommandMap = {
+    init: init_1.default,
+    status: status_1.default,
+    list: list_1.default,
+    deps: deps_1.default
+};
+const migrateUsageText = `
+LaunchQL Migrate Commands:
+
+  launchql migrate init      Initialize migration tracking in database
+  launchql migrate status    Show current migration status
+  launchql migrate list      List all changes (deployed and pending)
+  launchql migrate deps      Show change dependencies
+
+Options:
+  --help, -h     Show this help message
+  --cwd          Working directory (default: current directory)
+`;
+exports.default = async (argv, prompter, options) => {
+    let { first: subcommand, newArgv } = (0, utils_1.extractFirst)(argv);
+    // Show usage if explicitly requested
+    if (argv.help || argv.h || subcommand === 'help') {
+        console.log(migrateUsageText);
+        process.exit(0);
+    }
+    // Prompt if no subcommand provided
+    if (!subcommand) {
+        const answer = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'subcommand',
+                message: 'What migrate operation do you want to perform?',
+                options: Object.keys(subcommandMap).map(cmd => ({
+                    name: cmd,
+                    value: cmd,
+                    description: getSubcommandDescription(cmd)
+                }))
+            }
+        ]);
+        subcommand = answer.subcommand;
+    }
+    const subcommandFn = subcommandMap[subcommand];
+    if (!subcommandFn) {
+        console.error(`Unknown migrate subcommand: ${subcommand}`);
+        console.log(migrateUsageText);
+        process.exit(1);
+    }
+    await subcommandFn(newArgv, prompter, options);
+};
+function getSubcommandDescription(cmd) {
+    const descriptions = {
+        init: 'Initialize migration tracking in database',
+        status: 'Show current migration status',
+        list: 'List all changes (deployed and pending)',
+        deps: 'Show change dependencies'
+    };
+    return descriptions[cmd] || '';
+}

package/commands/package.d.ts

@@ -0,0 +1,3 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+declare const _default: (argv: Partial<Record<string, any>>, prompter: Inquirerer, _options: CLIOptions) => Promise<Partial<Record<string, any>>>;
+export default _default;

package/commands/package.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const packageUsageText = `
+LaunchQL Package Command:
+
+  lql package [OPTIONS]
+
+  Package module for distribution.
+
+Options:
+  --help, -h                      Show this help message
+  --plan                          Include deployment plan (default: true)
+  --pretty                        Pretty-print output (default: true)
+  --functionDelimiter <delimiter> Function delimiter (default: $EOFCODE$)
+  --cwd <directory>               Working directory (default: current directory)
+
+Examples:
+  lql package                     Package with defaults
+  lql package --no-plan           Package without plan
+`;
+exports.default = async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(packageUsageText);
+        process.exit(0);
+    }
+    const questions = [
+        {
+            type: 'confirm',
+            name: 'plan',
+            default: true,
+            useDefault: true,
+            required: true
+        },
+        {
+            type: 'confirm',
+            name: 'pretty',
+            default: true,
+            useDefault: true,
+            required: true
+        },
+        {
+            type: 'text',
+            name: 'functionDelimiter',
+            default: '$EOFCODE$',
+            useDefault: true,
+            required: false
+        }
+    ];
+    let { cwd, plan, pretty, functionDelimiter } = await prompter.prompt(argv, questions);
+    const project = new core_1.LaunchQLPackage(cwd);
+    project.ensureModule();
+    const info = project.getModuleInfo();
+    info.version;
+    await (0, core_1.writePackage)({
+        version: info.version,
+        extension: true,
+        usePlan: plan,
+        packageDir: project.modulePath,
+        pretty,
+        functionDelimiter
+    });
+    return argv;
+};

package/commands/plan.d.ts

@@ -0,0 +1,3 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+declare const _default: (argv: Partial<Record<string, any>>, prompter: Inquirerer, _options: CLIOptions) => Promise<Partial<Record<string, any>>>;
+export default _default;

package/commands/plan.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const logger_1 = require("@launchql/logger");
+const log = new logger_1.Logger('plan');
+const planUsageText = `
+LaunchQL Plan Command:
+
+  lql plan [OPTIONS]
+
+  Generate module deployment plans.
+
+Options:
+  --help, -h                     Show this help message
+  --includePackages              Include packages in plan (default: true)
+  --includeTags                  Prefer @tag references for external packages when available (default: true)
+  --cwd <directory>              Working directory (default: current directory)
+
+Examples:
+  lql plan                                 Generate deployment plan for current module with defaults
+  lql plan --includePackages false         Disable including external packages
+  lql plan --includeTags false              Do not prefer tags for external packages
+`;
+exports.default = async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(planUsageText);
+        process.exit(0);
+    }
+    const questions = [
+        {
+            type: 'confirm',
+            name: 'includePackages',
+            message: 'Include packages in plan?',
+            useDefault: true,
+            default: true
+        },
+        {
+            type: 'confirm',
+            name: 'includeTags',
+            message: 'Prefer @tag references for external packages when available?',
+            useDefault: true,
+            default: true
+        }
+    ];
+    let { cwd, includePackages, includeTags } = await prompter.prompt(argv, questions);
+    if (!cwd) {
+        cwd = process.cwd();
+        log.info(`Using current directory: ${cwd}`);
+    }
+    const pkg = new core_1.LaunchQLPackage(cwd);
+    if (!pkg.isInModule()) {
+        throw new Error('This command must be run inside a LaunchQL module.');
+    }
+    const includePackagesFlag = typeof includePackages === 'boolean' ? includePackages : true;
+    const includeTagsFlag = typeof includeTags === 'boolean' ? includeTags : true;
+    pkg.writeModulePlan({
+        includePackages: includePackagesFlag,
+        includeTags: includeTagsFlag
+    });
+    return argv;
+};

package/commands/remove.d.ts

@@ -0,0 +1,3 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+declare const _default: (argv: Partial<Record<string, any>>, prompter: Inquirerer, _options: CLIOptions) => Promise<Partial<Record<string, any>>>;
+export default _default;

package/commands/remove.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const logger_1 = require("@launchql/logger");
+const env_1 = require("@launchql/env");
+const pg_env_1 = require("pg-env");
+const utils_1 = require("../utils");
+const cli_error_1 = require("../utils/cli-error");
+const log = new logger_1.Logger('remove');
+exports.default = async (argv, prompter, _options) => {
+    if (!argv.to) {
+        await (0, cli_error_1.cliExitWithError)('No change specified. Usage: lql remove --to <change>');
+    }
+    const database = await (0, utils_1.getTargetDatabase)(argv, prompter, {
+        message: 'Select database'
+    });
+    const questions = [
+        {
+            name: 'yes',
+            type: 'confirm',
+            message: 'Are you sure you want to proceed with removing changes?',
+            required: true
+        }
+    ];
+    let { yes, cwd } = await prompter.prompt(argv, questions);
+    if (!yes) {
+        log.info('Operation cancelled.');
+        return;
+    }
+    log.debug(`Using current directory: ${cwd}`);
+    const pkg = new core_1.LaunchQLPackage(cwd);
+    if (!pkg.isInModule()) {
+        throw new Error('Not in a LaunchQL module directory. Please run this command from within a module.');
+    }
+    const opts = (0, env_1.getEnvOptions)({
+        pg: (0, pg_env_1.getPgEnvOptions)({ database })
+    });
+    const toChange = argv.to;
+    await pkg.removeFromPlan(toChange);
+    log.success(`✅ Successfully removed changes from '${toChange}' to end of plan.`);
+    return argv;
+};

package/commands/rename.d.ts

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

package/commands/rename.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const core_1 = require("@launchql/core");
+const cli_error_1 = require("../utils/cli-error");
+exports.default = async (argv, _prompter) => {
+    const cwd = argv.cwd || process.cwd();
+    const to = argv.to || (argv._ && argv._[0]);
+    if (!to) {
+        await (0, cli_error_1.cliExitWithError)('Missing new name. Use --to <name> or provide as positional argument.');
+    }
+    const dryRun = !!argv['dry-run'] || !!argv.dryRun;
+    const syncPkg = !!argv['sync-pkg-name'] || !!argv.syncPkgName;
+    const proj = new core_1.LaunchQLPackage(path_1.default.resolve(cwd));
+    const res = proj.renameModule(to, { dryRun, syncPackageJsonName: syncPkg });
+    if (dryRun) {
+        console.log('Dry run');
+    }
+    if (res.changed.length > 0) {
+        console.log('Changed:');
+        for (const f of res.changed)
+            console.log(`- ${f}`);
+    }
+    else {
+        console.log('No changes');
+    }
+    if (res.warnings.length > 0) {
+        console.log('Warnings:');
+        for (const w of res.warnings)
+            console.log(`- ${w}`);
+    }
+};

package/commands/revert.d.ts

@@ -0,0 +1,3 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+declare const _default: (argv: Partial<Record<string, any>>, prompter: Inquirerer, _options: CLIOptions) => Promise<Partial<Record<string, any>>>;
+export default _default;

package/commands/revert.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const logger_1 = require("@launchql/logger");
+const env_1 = require("@launchql/env");
+const pg_env_1 = require("pg-env");
+const utils_1 = require("../utils");
+const deployed_changes_1 = require("../utils/deployed-changes");
+const cli_error_1 = require("../utils/cli-error");
+const log = new logger_1.Logger('revert');
+const revertUsageText = `
+LaunchQL Revert Command:
+
+  lql revert [OPTIONS]
+
+  Revert database changes and migrations.
+
+Options:
+  --help, -h         Show this help message
+  --recursive        Revert recursively through dependencies
+  --package <name>   Revert specific package
+  --to <target>      Revert to specific change or tag
+  --to               Interactive selection of deployed changes
+  --tx               Use transactions (default: true)
+  --cwd <directory>  Working directory (default: current directory)
+
+Examples:
+  lql revert                    Revert latest changes
+  lql revert --to @v1.0.0      Revert to specific tag
+  lql revert --to              Interactive selection from deployed changes
+`;
+exports.default = async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(revertUsageText);
+        process.exit(0);
+    }
+    const database = await (0, utils_1.getTargetDatabase)(argv, prompter, {
+        message: 'Select database'
+    });
+    const questions = [
+        {
+            name: 'yes',
+            type: 'confirm',
+            message: 'Are you sure you want to proceed?',
+            required: true
+        },
+        {
+            name: 'recursive',
+            type: 'confirm',
+            message: 'Deploy recursively through dependencies?',
+            useDefault: true,
+            default: true,
+            required: false
+        },
+        {
+            name: 'tx',
+            type: 'confirm',
+            message: 'Use Transaction?',
+            useDefault: true,
+            default: true,
+            required: false
+        }
+    ];
+    let { yes, recursive, cwd, tx } = await prompter.prompt(argv, questions);
+    if (!yes) {
+        log.info('Operation cancelled.');
+        return;
+    }
+    log.debug(`Using current directory: ${cwd}`);
+    let packageName;
+    if (recursive && argv.to !== true) {
+        packageName = await (0, deployed_changes_1.selectDeployedPackage)(database, argv, prompter, log, 'revert');
+        if (!packageName) {
+            await (0, cli_error_1.cliExitWithError)('No package found to revert');
+        }
+    }
+    const pkg = new core_1.LaunchQLPackage(cwd);
+    const opts = (0, env_1.getEnvOptions)({
+        pg: (0, pg_env_1.getPgEnvOptions)({ database }),
+        deployment: {
+            useTx: tx
+        }
+    });
+    let target;
+    if (argv.to === true) {
+        target = await (0, deployed_changes_1.selectDeployedChange)(database, argv, prompter, log, 'revert');
+        if (!target) {
+            await (0, cli_error_1.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 pkg.revert(opts, target, recursive);
+    log.success('Revert complete.');
+    return argv;
+};

package/commands/server.d.ts

@@ -0,0 +1,3 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+declare const _default: (argv: Partial<Record<string, any>>, prompter: Inquirerer, _options: CLIOptions) => Promise<void>;
+export default _default;