pgpm 0.0.1

package/commands/init/index.d.ts

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

package/commands/init/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const module_1 = __importDefault(require("./module"));
+const workspace_1 = __importDefault(require("./workspace"));
+const initUsageText = `
+LaunchQL Init Command:
+
+  lql init [OPTIONS]
+
+  Initialize LaunchQL workspace or module.
+
+Options:
+  --help, -h              Show this help message
+  --workspace             Initialize workspace instead of module
+  --cwd <directory>       Working directory (default: current directory)
+  --repo <repo>           Use templates from GitHub repository (e.g., owner/repo)
+  --template-path <path>   Use templates from local path
+  --from-branch <branch>   Specify branch when using --repo (default: main)
+
+Examples:
+  lql init                                  Initialize new module in existing workspace
+  lql init --workspace                       Initialize new workspace
+  lql init --repo owner/repo                Use templates from GitHub repository
+  lql init --template-path ./custom-templates Use templates from local path
+  lql init --repo owner/repo --from-branch develop  Use specific branch
+`;
+exports.default = async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(initUsageText);
+        process.exit(0);
+    }
+    return handlePromptFlow(argv, prompter);
+};
+async function handlePromptFlow(argv, prompter) {
+    const { workspace } = argv;
+    switch (workspace) {
+        case true:
+            return (0, workspace_1.default)(argv, prompter);
+        case false:
+        default:
+            return (0, module_1.default)(argv, prompter);
+    }
+}

package/commands/init/module.d.ts

@@ -0,0 +1,4 @@
+import { Inquirerer } from 'inquirerer';
+export default function runModuleSetup(argv: Partial<Record<string, any>>, prompter: Inquirerer): Promise<{
+    [x: string]: any;
+}>;

package/commands/init/module.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = runModuleSetup;
+const core_1 = require("@launchql/core");
+const logger_1 = require("@launchql/logger");
+const types_1 = require("@launchql/types");
+const log = new logger_1.Logger('module-init');
+async function runModuleSetup(argv, prompter) {
+    const { email, username } = (0, types_1.getGitConfigInfo)();
+    const { cwd = process.cwd() } = argv;
+    const project = new core_1.LaunchQLPackage(cwd);
+    if (!project.workspacePath) {
+        log.error('Not inside a LaunchQL workspace.');
+        throw types_1.errors.NOT_IN_WORKSPACE({});
+    }
+    if (!project.isInsideAllowedDirs(cwd) && !project.isInWorkspace()) {
+        log.error('You must be inside one of the workspace packages.');
+        throw types_1.errors.NOT_IN_WORKSPACE_MODULE({});
+    }
+    const availExtensions = project.getAvailableModules();
+    const moduleQuestions = [
+        {
+            name: 'MODULENAME',
+            message: 'Enter the module name',
+            required: true,
+            type: 'text',
+        },
+        {
+            name: 'extensions',
+            message: 'Which extensions?',
+            options: availExtensions,
+            type: 'checkbox',
+            allowCustomOptions: true,
+            required: true,
+        },
+    ];
+    const answers = await prompter.prompt(argv, moduleQuestions);
+    const modName = (0, core_1.sluggify)(answers.MODULENAME);
+    const extensions = answers.extensions
+        .filter((opt) => opt.selected)
+        .map((opt) => opt.name);
+    // Determine template source
+    let templateSource;
+    if (argv.repo) {
+        templateSource = {
+            type: 'github',
+            path: argv.repo,
+            branch: argv.fromBranch
+        };
+        log.info(`Loading templates from GitHub repository: ${argv.repo}`);
+    }
+    else if (argv.templatePath) {
+        templateSource = {
+            type: 'local',
+            path: argv.templatePath
+        };
+        log.info(`Loading templates from local path: ${argv.templatePath}`);
+    }
+    project.initModule({
+        ...argv,
+        ...answers,
+        name: modName,
+        // @ts-ignore
+        USERFULLNAME: username,
+        USEREMAIL: email,
+        extensions,
+        templateSource
+    });
+    log.success(`Initialized module: ${modName}`);
+    return { ...argv, ...answers };
+}

package/commands/init/workspace.d.ts

@@ -0,0 +1,4 @@
+import { Inquirerer } from 'inquirerer';
+export default function runWorkspaceSetup(argv: Partial<Record<string, any>>, prompter: Inquirerer): Promise<{
+    cwd: string;
+}>;

package/commands/init/workspace.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = runWorkspaceSetup;
+const core_1 = require("@launchql/core");
+const logger_1 = require("@launchql/logger");
+// @ts-ignore - TypeScript module resolution issue with @launchql/templatizer
+const templatizer_1 = require("@launchql/templatizer");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const log = new logger_1.Logger('workspace-init');
+async function runWorkspaceSetup(argv, prompter) {
+    const workspaceQuestions = [
+        {
+            name: 'name',
+            message: 'Enter workspace name',
+            required: true,
+            type: 'text',
+        }
+    ];
+    const answers = await prompter.prompt(argv, workspaceQuestions);
+    const { cwd } = argv;
+    const targetPath = path_1.default.join(cwd, (0, core_1.sluggify)(answers.name));
+    (0, fs_1.mkdirSync)(targetPath, { recursive: true });
+    log.success(`Created workspace directory: ${targetPath}`);
+    // Determine template source
+    let templates = templatizer_1.workspaceTemplate;
+    if (argv.repo) {
+        const source = {
+            type: 'github',
+            path: argv.repo,
+            branch: argv.fromBranch
+        };
+        log.info(`Loading templates from GitHub repository: ${argv.repo}`);
+        const compiledTemplates = (0, templatizer_1.loadTemplates)(source, 'workspace');
+        templates = compiledTemplates.map((t) => t.render);
+    }
+    else if (argv.templatePath) {
+        const source = {
+            type: 'local',
+            path: argv.templatePath
+        };
+        log.info(`Loading templates from local path: ${argv.templatePath}`);
+        const compiledTemplates = (0, templatizer_1.loadTemplates)(source, 'workspace');
+        templates = compiledTemplates.map((t) => t.render);
+    }
+    (0, templatizer_1.writeRenderedTemplates)(templates, targetPath, { ...argv, ...answers });
+    log.success('Workspace templates rendered.');
+    return { ...argv, ...answers, cwd: targetPath };
+}

package/commands/install.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/install.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const installUsageText = `
+LaunchQL Install Command:
+
+  lql install <package>...
+
+  Install LaunchQL modules into current module.
+
+Arguments:
+  package                 One or more package names to install
+
+Options:
+  --help, -h              Show this help message
+  --cwd <directory>       Working directory (default: current directory)
+
+Examples:
+  lql install @launchql/base32                    Install single package
+  lql install @launchql/base32 @launchql/utils   Install multiple packages
+`;
+exports.default = async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(installUsageText);
+        process.exit(0);
+    }
+    const { cwd = process.cwd() } = argv;
+    const project = new core_1.LaunchQLPackage(cwd);
+    if (!project.isInModule()) {
+        throw new Error('You must run this command inside a LaunchQL module.');
+    }
+    if (argv._.length === 0) {
+        throw new Error('You must provide a package name to install, e.g. `@launchql/base32`');
+    }
+    await project.installModules(...argv._);
+};

package/commands/kill.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;

package/commands/kill.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("@launchql/logger");
+const pg_cache_1 = require("pg-cache");
+const log = new logger_1.Logger('db-kill');
+const killUsageText = `
+LaunchQL Kill Command:
+
+  lql kill [OPTIONS]
+
+  Terminate database connections and optionally drop databases.
+
+Options:
+  --help, -h              Show this help message
+  --drop                  Drop databases after killing connections (default: true)
+  --no-drop               Only kill connections, don't drop databases
+  --pattern <pattern>     Pattern to match database names (supports SQL LIKE syntax)
+  --cwd <directory>       Working directory (default: current directory)
+
+Examples:
+  lql kill                Kill connections and drop selected databases (interactive)
+  lql kill --no-drop      Only kill connections, preserve databases (interactive)
+  lql kill --pattern test_%   Kill connections to databases matching 'test_%' pattern
+  lql kill --pattern %dev --no-drop  Kill connections to databases ending with 'dev' but don't drop
+`;
+exports.default = async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(killUsageText);
+        process.exit(0);
+    }
+    const db = await (0, pg_cache_1.getPgPool)({
+        database: 'postgres'
+    });
+    let selectedDbNames;
+    if (argv.pattern) {
+        // Pattern mode: automatically find databases matching the pattern
+        const databasesResult = await db.query(`
+      SELECT datname FROM pg_catalog.pg_database
+      WHERE datistemplate = FALSE AND datname NOT IN ('postgres')
+        AND datname !~ '^pg_' AND datname LIKE $1;
+    `, [argv.pattern]);
+        if (!databasesResult.rows.length) {
+            log.info(`ℹ️  No databases found matching pattern "${argv.pattern}". Exiting.`);
+            return;
+        }
+        selectedDbNames = databasesResult.rows.map(row => row.datname);
+        log.info(`🎯 Found ${selectedDbNames.length} database(s) matching pattern "${argv.pattern}": ${selectedDbNames.join(', ')}`);
+    }
+    else {
+        // Interactive mode: prompt user to select databases
+        const databasesResult = await db.query(`
+      SELECT datname FROM pg_catalog.pg_database
+      WHERE datistemplate = FALSE AND datname NOT IN ('postgres')
+        AND datname !~ '^pg_';
+    `);
+        if (!databasesResult.rows.length) {
+            log.info('ℹ️  No databases found to process. Exiting.');
+            return;
+        }
+        let databases;
+        ({ databases } = await prompter.prompt(argv, [
+            {
+                type: 'checkbox',
+                name: 'databases',
+                message: 'Select database(s) to terminate connections and optionally drop',
+                options: databasesResult.rows.map(row => row.datname),
+                required: true
+            }
+        ]));
+        selectedDbNames = databases.filter(d => d.selected).map(d => d.value);
+    }
+    const actionText = argv.drop === false ? 'kill connections to' : 'kill connections and DROP';
+    const patternText = argv.pattern ? ` (matched by pattern "${argv.pattern}")` : '';
+    const { yes } = await prompter.prompt(argv, [
+        {
+            type: 'confirm',
+            name: 'yes',
+            message: `Are you sure you want to ${actionText}: ${selectedDbNames.join(', ')}${patternText}?`,
+            default: false
+        }
+    ]);
+    if (!yes) {
+        log.info('❌ Aborted. No actions were taken.');
+        return;
+    }
+    for (const dbname of selectedDbNames) {
+        const killResult = await db.query(`
+      SELECT pg_terminate_backend(pid)
+      FROM pg_stat_activity
+      WHERE datname = $1 AND pid <> pg_backend_pid();
+      `, [dbname]);
+        log.warn(`💀 Terminated ${killResult.rowCount} connection(s) to "${dbname}".`);
+        if (argv.drop === false) {
+            log.info(`⚠️  Skipping DROP for "${dbname}" due to --no-drop flag.`);
+            continue;
+        }
+        try {
+            await db.query(`DROP DATABASE "${dbname}";`);
+            log.success(`🗑️  Dropped database "${dbname}" successfully.`);
+        }
+        catch (err) {
+            log.error(`❌ Failed to drop "${dbname}": ${err.message}`);
+        }
+    }
+    log.success('✅ Done processing databases.');
+};

package/commands/migrate/deps.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/deps.js

@@ -0,0 +1,186 @@
+"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-deps');
+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 specific change to analyze
+    let changeName = argv._?.[0] || argv.change;
+    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;
+    // If no change specified, prompt
+    if (!changeName && !argv.all) {
+        const answer = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'change',
+                message: 'Which change do you want to analyze?',
+                options: allChanges.map(c => ({
+                    name: c.name,
+                    value: c.name,
+                    description: c.dependencies.length > 0 ? `Depends on: ${c.dependencies.join(', ')}` : 'No dependencies'
+                }))
+            }
+        ]);
+        changeName = answer.change;
+    }
+    try {
+        if (argv.all) {
+            // Show dependency graph for all changes
+            console.log('\n🔗 Dependency Graph\n');
+            console.log(`Package: ${plan.package}`);
+            console.log(`Total Changes: ${allChanges.length}\n`);
+            // Build dependency tree
+            const dependencyTree = buildDependencyTree(allChanges);
+            // Show changes with no dependencies first (roots)
+            const roots = allChanges.filter(c => c.dependencies.length === 0);
+            console.log('📌 Root Changes (no dependencies):\n');
+            roots.forEach(change => {
+                console.log(`  • ${change.name}`);
+                showDependents(change.name, dependencyTree, '    ');
+            });
+            // Show orphaned changes (have dependencies but aren't depended on)
+            const orphans = allChanges.filter(c => c.dependencies.length > 0 &&
+                !allChanges.some(other => other.dependencies.includes(c.name)));
+            if (orphans.length > 0) {
+                console.log('\n🔸 Leaf Changes (not depended on by others):\n');
+                orphans.forEach(change => {
+                    console.log(`  • ${change.name} → [${change.dependencies.join(', ')}]`);
+                });
+            }
+        }
+        else {
+            // Show dependencies for specific change
+            const change = allChanges.find(c => c.name === changeName);
+            if (!change) {
+                log.error(`Change '${changeName}' not found in plan file`);
+                process.exit(1);
+            }
+            console.log(`\n🔍 Dependency Analysis: ${changeName}\n`);
+            // Direct dependencies
+            if (change.dependencies.length > 0) {
+                console.log('📥 Direct Dependencies:');
+                change.dependencies.forEach(dep => {
+                    console.log(`  • ${dep}`);
+                });
+            }
+            else {
+                console.log('📥 Direct Dependencies: None');
+            }
+            // All dependencies (recursive)
+            const allDeps = getAllDependencies(change.name, allChanges);
+            if (allDeps.size > 0) {
+                console.log(`\n📦 All Dependencies (${allDeps.size} total):`);
+                Array.from(allDeps).forEach(dep => {
+                    console.log(`  • ${dep}`);
+                });
+            }
+            // Dependents (what depends on this)
+            const dependents = allChanges.filter(c => c.dependencies.includes(changeName));
+            if (dependents.length > 0) {
+                console.log(`\n📤 Depended on by (${dependents.length} changes):`);
+                dependents.forEach(dep => {
+                    console.log(`  • ${dep.name}`);
+                });
+            }
+            else {
+                console.log('\n📤 Depended on by: None');
+            }
+            // Check deployment status if connected to database
+            const pgEnv = (0, pg_env_1.getPgEnvOptions)();
+            const targetDatabase = await (0, database_1.getTargetDatabase)(argv, prompter, {
+                message: 'Select database to check deployment status'
+            });
+            const client = new core_1.LaunchQLMigrate({
+                host: pgEnv.host,
+                port: pgEnv.port,
+                user: pgEnv.user,
+                password: pgEnv.password,
+                database: pgEnv.database
+            });
+            try {
+                const deployedChanges = await client.getDeployedChanges(targetDatabase, plan.package);
+                const deployedMap = new Map(deployedChanges.map(c => [c.change_name, c]));
+                console.log('\n📊 Deployment Status:');
+                // Check if this change is deployed
+                const isDeployed = deployedMap.has(changeName);
+                console.log(`  This change: ${isDeployed ? '✅ Deployed' : '⏳ Not deployed'}`);
+                // Check dependencies
+                const undeployedDeps = Array.from(allDeps).filter(dep => !deployedMap.has(dep));
+                if (undeployedDeps.length > 0) {
+                    console.log(`  ⚠️  Undeployed dependencies: ${undeployedDeps.join(', ')}`);
+                }
+                else if (allDeps.size > 0) {
+                    console.log('  ✅ All dependencies deployed');
+                }
+                // Check dependents
+                const deployedDependents = dependents.filter(d => deployedMap.has(d.name));
+                if (deployedDependents.length > 0) {
+                    console.log(`  ⚠️  Deployed dependents: ${deployedDependents.map(d => d.name).join(', ')}`);
+                }
+            }
+            catch (dbError) {
+                // Database connection optional for dependency analysis
+                log.debug('Could not connect to database for deployment status');
+            }
+        }
+    }
+    catch (error) {
+        log.error('Failed to analyze dependencies:', error);
+        process.exit(1);
+    }
+};
+function buildDependencyTree(changes) {
+    const tree = new Map();
+    changes.forEach(change => {
+        change.dependencies.forEach((dep) => {
+            if (!tree.has(dep)) {
+                tree.set(dep, []);
+            }
+            tree.get(dep).push(change.name);
+        });
+    });
+    return tree;
+}
+function showDependents(changeName, tree, indent) {
+    const dependents = tree.get(changeName) || [];
+    dependents.forEach(dep => {
+        console.log(`${indent}└─ ${dep}`);
+        showDependents(dep, tree, indent + '   ');
+    });
+}
+function getAllDependencies(changeName, changes) {
+    const deps = new Set();
+    const change = changes.find(c => c.name === changeName);
+    if (!change)
+        return deps;
+    function addDeps(change) {
+        change.dependencies.forEach((dep) => {
+            if (!deps.has(dep)) {
+                deps.add(dep);
+                const depChange = changes.find(c => c.name === dep);
+                if (depChange) {
+                    addDeps(depChange);
+                }
+            }
+        });
+    }
+    addDeps(change);
+    return deps;
+}

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

package/commands/migrate/init.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const logger_1 = require("@launchql/logger");
+const pg_env_1 = require("pg-env");
+const database_1 = require("../../utils/database");
+const log = new logger_1.Logger('migrate-init');
+exports.default = async (argv, prompter, _options) => {
+    const pgEnv = (0, pg_env_1.getPgEnvOptions)();
+    // Get target database
+    const database = await (0, database_1.getTargetDatabase)(argv, prompter, {
+        message: 'Select database to initialize migration tracking'
+    });
+    const questions = [
+        {
+            name: 'yes',
+            type: 'confirm',
+            message: `Initialize LaunchQL migration schema in database "${database}"?`,
+            required: true
+        }
+    ];
+    const { yes } = await prompter.prompt(argv, questions);
+    if (!yes) {
+        log.info('Operation cancelled.');
+        return;
+    }
+    log.info(`Initializing migration schema in database ${database}...`);
+    const config = {
+        host: pgEnv.host,
+        port: pgEnv.port,
+        user: pgEnv.user,
+        password: pgEnv.password,
+        database
+    };
+    const client = new core_1.LaunchQLMigrate(config);
+    try {
+        await client.initialize();
+        log.success('Migration schema initialized successfully.');
+        // Check if there's an existing Sqitch deployment to import
+        const hasSquitch = await client.hasSqitchTables();
+        if (hasSquitch) {
+            const { importSquitch } = await prompter.prompt(argv, [
+                {
+                    name: 'importSquitch',
+                    type: 'confirm',
+                    message: 'Existing Sqitch deployment detected. Import it?',
+                    required: true
+                }
+            ]);
+            if (importSquitch) {
+                log.info('Importing Sqitch deployment history...');
+                await client.importFromSqitch();
+                log.success('Sqitch deployment imported successfully.');
+            }
+        }
+    }
+    catch (error) {
+        log.error(`Failed to initialize migration schema: ${error instanceof Error ? error.message : error}`);
+        throw error;
+    }
+    finally {
+        await client.close();
+    }
+    return argv;
+};

package/commands/migrate/list.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;