pgpm 0.0.1

package/esm/commands/admin-users/remove.js

@@ -0,0 +1,80 @@
+import { LaunchQLInit } from '@launchql/core';
+import { Logger } from '@launchql/logger';
+import { getPgEnvOptions } from 'pg-env';
+const log = new Logger('admin-users-remove');
+const removeUsageText = `
+LaunchQL Admin Users Remove Command:
+
+  lql admin-users remove [OPTIONS]
+
+  Remove database users and revoke their LaunchQL roles.
+
+Options:
+  --help, -h              Show this help message
+  --username <username>   Username for the database user to remove
+  --test                  Remove test users (app_user, app_admin)
+  --cwd <directory>       Working directory (default: current directory)
+
+Examples:
+  lql admin-users remove --username myuser
+  lql admin-users remove --test             # Remove test users
+  lql admin-users remove                    # Will prompt for username
+`;
+export default async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(removeUsageText);
+        process.exit(0);
+    }
+    const pgEnv = getPgEnvOptions();
+    const isTest = argv.test;
+    const init = new LaunchQLInit(pgEnv);
+    try {
+        if (isTest) {
+            const { yes: confirmTest } = await prompter.prompt(argv, [
+                {
+                    type: 'confirm',
+                    name: 'yes',
+                    message: 'Are you sure you want to remove LaunchQL test users (app_user, app_admin)?',
+                    default: false
+                }
+            ]);
+            if (!confirmTest) {
+                log.info('Operation cancelled.');
+                return;
+            }
+            await init.removeDbRoles('app_user');
+            await init.removeDbRoles('app_admin');
+            log.success('Test users removed successfully.');
+        }
+        else {
+            const prompts = [
+                {
+                    type: 'text',
+                    name: 'username',
+                    message: 'Enter username for database user to remove:',
+                    validate: (input) => input && input.trim().length > 0
+                }
+            ];
+            const { username } = await prompter.prompt(argv, prompts);
+            const { yes } = await prompter.prompt(argv, [
+                {
+                    type: 'confirm',
+                    name: 'yes',
+                    message: `Are you sure you want to remove database user "${username}"?`,
+                    default: false
+                }
+            ]);
+            if (!yes) {
+                log.info('Operation cancelled.');
+                return;
+            }
+            await init.removeDbRoles(username);
+            log.success(`Database user "${username}" removed successfully.`);
+        }
+    }
+    finally {
+        await init.close();
+    }
+    return argv;
+};

package/esm/commands/admin-users.js

@@ -0,0 +1,63 @@
+import { extractFirst } from '../utils';
+import add from './admin-users/add';
+import bootstrap from './admin-users/bootstrap';
+import remove from './admin-users/remove';
+const subcommandMap = {
+    add,
+    bootstrap,
+    remove
+};
+const adminUsersUsageText = `
+LaunchQL Admin Users Commands:
+
+  lql admin-users bootstrap    Initialize LaunchQL roles and permissions (must be run first)
+  lql admin-users add          Add database users with roles
+  lql admin-users remove       Remove database users and revoke roles
+
+Options:
+  --help, -h     Show this help message
+  --cwd          Working directory (default: current directory)
+`;
+export default async (argv, prompter, options) => {
+    let { first: subcommand, newArgv } = extractFirst(argv);
+    // Prompt if no subcommand provided
+    if (!subcommand) {
+        // Show usage if explicitly requested and no subcommand provided
+        if (argv.help || argv.h) {
+            console.log(adminUsersUsageText);
+            process.exit(0);
+        }
+        const answer = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'subcommand',
+                message: 'What admin users operation do you want to perform?',
+                options: Object.keys(subcommandMap).map(cmd => ({
+                    name: cmd,
+                    value: cmd,
+                    description: getSubcommandDescription(cmd)
+                }))
+            }
+        ]);
+        subcommand = answer.subcommand;
+    }
+    if (subcommand === 'help') {
+        console.log(adminUsersUsageText);
+        process.exit(0);
+    }
+    const subcommandFn = subcommandMap[subcommand];
+    if (!subcommandFn) {
+        console.error(`Unknown admin-users subcommand: ${subcommand}`);
+        console.log(adminUsersUsageText);
+        process.exit(1);
+    }
+    await subcommandFn(newArgv, prompter, options);
+};
+function getSubcommandDescription(cmd) {
+    const descriptions = {
+        bootstrap: 'Initialize LaunchQL roles and permissions (must be run first)',
+        add: 'Add database users with roles',
+        remove: 'Remove database users and revoke roles'
+    };
+    return descriptions[cmd] || '';
+}

package/esm/commands/analyze.js

@@ -0,0 +1,16 @@
+import path from 'path';
+import { LaunchQLPackage } from '@launchql/core';
+export default async (argv, _prompter) => {
+    const cwd = argv.cwd || process.cwd();
+    const proj = new LaunchQLPackage(path.resolve(cwd));
+    const result = proj.analyzeModule();
+    if (result.ok) {
+        console.log(`OK ${result.name}`);
+        return;
+    }
+    console.log(`NOT OK ${result.name}`);
+    for (const issue of result.issues) {
+        const loc = issue.file ? ` (${issue.file})` : '';
+        console.log(`- [${issue.code}] ${issue.message}${loc}`);
+    }
+};

package/esm/commands/clear.js

@@ -0,0 +1,54 @@
+import { LaunchQLPackage } from '@launchql/core';
+import { Logger } from '@launchql/logger';
+import { getEnvOptions } from '@launchql/env';
+import { getPgEnvOptions } from 'pg-env';
+import { parsePlanFile } from '@launchql/core';
+import { errors } from '@launchql/types';
+import path from 'path';
+import { getTargetDatabase } from '../utils';
+const log = new Logger('clear');
+export default async (argv, prompter, _options) => {
+    const database = await getTargetDatabase(argv, prompter, {
+        message: 'Select database'
+    });
+    const questions = [
+        {
+            name: 'yes',
+            type: 'confirm',
+            message: 'Are you sure you want to clear ALL changes from the plan? This will remove all changes and their associated files.',
+            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 LaunchQLPackage(cwd);
+    if (!pkg.isInModule()) {
+        throw new Error('Not in a LaunchQL module directory. Please run this command from within a module.');
+    }
+    const modulePath = pkg.getModulePath();
+    if (!modulePath) {
+        throw new Error('Could not resolve module path');
+    }
+    const planPath = path.join(modulePath, 'launchql.plan');
+    const result = parsePlanFile(planPath);
+    if (result.errors.length > 0) {
+        throw errors.PLAN_PARSE_ERROR({ planPath, errors: result.errors.map(e => e.message).join(', ') });
+    }
+    const plan = result.data;
+    if (plan.changes.length === 0) {
+        log.info('Plan is already empty - nothing to clear.');
+        return;
+    }
+    const firstChange = plan.changes[0].name;
+    log.info(`Found ${plan.changes.length} changes in plan. Clearing from first change: ${firstChange}`);
+    const opts = getEnvOptions({
+        pg: getPgEnvOptions({ database })
+    });
+    await pkg.removeFromPlan(firstChange);
+    log.success(`✅ Successfully cleared all changes from the plan.`);
+    return argv;
+};

package/esm/commands/deploy.js

@@ -0,0 +1,144 @@
+import { LaunchQLPackage } from '@launchql/core';
+import { Logger } from '@launchql/logger';
+import { getEnvOptions } from '@launchql/env';
+import { execSync } from 'child_process';
+import { getPgEnvOptions, getSpawnEnvWithPg, } from 'pg-env';
+import { getTargetDatabase } from '../utils';
+import { selectPackage } from '../utils/module-utils';
+const deployUsageText = `
+LaunchQL Deploy Command:
+
+  lql deploy [OPTIONS]
+
+  Deploy database changes and migrations to target database.
+
+Options:
+  --help, -h         Show this help message
+  --createdb         Create database if it doesn't exist
+  --recursive        Deploy recursively through dependencies
+  --package <name>   Target specific package
+  --to <target>      Deploy to specific change or tag
+  --tx               Use transactions (default: true)
+  --fast             Use fast deployment strategy
+  --logOnly          Log-only mode, skip script execution
+  --usePlan          Use deployment plan
+  --cache            Enable caching
+  --cwd <directory>  Working directory (default: current directory)
+
+Examples:
+  lql deploy                              Deploy to selected database
+  lql deploy --createdb                   Deploy with database creation
+  lql deploy --package mypackage --to @v1.0.0  Deploy specific package to tag
+  lql deploy --fast --no-tx              Fast deployment without transactions
+`;
+export default async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(deployUsageText);
+        process.exit(0);
+    }
+    const pgEnv = getPgEnvOptions();
+    const log = new Logger('cli');
+    // Get target database
+    let database;
+    if (argv.createdb) {
+        // Prompt for selection
+        ({ database } = await prompter.prompt(argv, [
+            {
+                type: 'text',
+                name: 'database',
+                message: 'Database name',
+                required: true
+            }
+        ]));
+    }
+    else {
+        database = await 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
+        },
+        {
+            name: 'fast',
+            type: 'confirm',
+            message: 'Use Fast Deployment?',
+            useDefault: true,
+            default: false,
+            required: false
+        },
+        {
+            name: 'logOnly',
+            type: 'confirm',
+            message: 'Log-only mode (skip script execution)?',
+            useDefault: true,
+            default: false,
+            required: false
+        }
+    ];
+    let { yes, recursive, createdb, cwd, tx, fast, logOnly } = await prompter.prompt(argv, questions);
+    if (!yes) {
+        log.info('Operation cancelled.');
+        return;
+    }
+    log.debug(`Using current directory: ${cwd}`);
+    if (createdb) {
+        log.info(`Creating database ${database}...`);
+        execSync(`createdb ${database}`, {
+            env: getSpawnEnvWithPg(pgEnv)
+        });
+    }
+    let packageName;
+    if (recursive) {
+        packageName = await selectPackage(argv, prompter, cwd, 'deploy', log);
+    }
+    const cliOverrides = {
+        pg: getPgEnvOptions({ database }),
+        deployment: {
+            useTx: tx !== false,
+            fast: fast !== false,
+            usePlan: argv.usePlan !== false,
+            cache: argv.cache !== false,
+            logOnly: argv.logOnly !== false,
+        }
+    };
+    const opts = getEnvOptions(cliOverrides);
+    const project = new LaunchQLPackage(cwd);
+    let target;
+    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.deploy(opts, target, recursive);
+    log.success('Deployment complete.');
+    return argv;
+};

package/esm/commands/explorer.js

@@ -0,0 +1,92 @@
+import { LaunchQLExplorer as explorer } from '@launchql/explorer';
+import { Logger } from '@launchql/logger';
+import { getEnvOptions } from '@launchql/env';
+const log = new Logger('explorer');
+const explorerUsageText = `
+LaunchQL Explorer Command:
+
+  lql explorer [OPTIONS]
+
+  Launch GraphiQL explorer interface.
+
+Options:
+  --help, -h              Show this help message
+  --port <number>         Server port (default: 5555)
+  --origin <url>          CORS origin URL (default: http://localhost:3000)
+  --simpleInflection      Use simple inflection (default: true)
+  --oppositeBaseNames     Use opposite base names (default: false)
+  --postgis               Enable PostGIS extension (default: true)
+  --cwd <directory>       Working directory (default: current directory)
+
+Examples:
+  lql explorer                        Launch explorer with defaults
+  lql explorer --origin http://localhost:4000  Launch explorer with custom origin
+`;
+const questions = [
+    {
+        name: 'simpleInflection',
+        message: 'Use simple inflection?',
+        type: 'confirm',
+        required: false,
+        default: true,
+        useDefault: true
+    },
+    {
+        name: 'oppositeBaseNames',
+        message: 'Use opposite base names?',
+        type: 'confirm',
+        required: false,
+        default: false,
+        useDefault: true
+    },
+    {
+        name: 'postgis',
+        message: 'Enable PostGIS extension?',
+        type: 'confirm',
+        required: false,
+        default: true,
+        useDefault: true
+    },
+    {
+        name: 'port',
+        message: 'Development server port',
+        type: 'number',
+        required: false,
+        default: 5555,
+        useDefault: true
+    },
+    {
+        name: 'origin',
+        message: 'CORS origin URL',
+        type: 'text',
+        required: false,
+        default: 'http://localhost:3000',
+        useDefault: true
+    }
+];
+export default async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(explorerUsageText);
+        process.exit(0);
+    }
+    log.info('🔧 LaunchQL Explorer Configuration:\n');
+    const { oppositeBaseNames, origin, port, postgis, simpleInflection } = await prompter.prompt(argv, questions);
+    const options = getEnvOptions({
+        features: {
+            oppositeBaseNames,
+            simpleInflection,
+            postgis
+        },
+        server: {
+            origin,
+            port
+        }
+    });
+    log.success('✅ Selected Configuration:');
+    for (const [key, value] of Object.entries(options)) {
+        log.debug(`${key}: ${JSON.stringify(value)}`);
+    }
+    log.success('🚀 Launching Explorer...\n');
+    explorer(options);
+};

package/esm/commands/export.js

@@ -0,0 +1,127 @@
+import { exportMigrations, LaunchQLPackage } from '@launchql/core';
+import { getGitConfigInfo } from '@launchql/types';
+import { getEnvOptions } from '@launchql/env';
+import { resolve } from 'path';
+import { getPgPool } from 'pg-cache';
+const exportUsageText = `
+LaunchQL Export Command:
+
+  lql export [OPTIONS]
+
+  Export database migrations from existing databases.
+
+Options:
+  --help, -h              Show this help message
+  --author <name>         Project author (default: from git config)
+  --extensionName <name>  Extension name
+  --metaExtensionName <name>  Meta extension name (default: svc)
+  --cwd <directory>       Working directory (default: current directory)
+
+Examples:
+  lql export              Export migrations from selected database
+`;
+export default async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(exportUsageText);
+        process.exit(0);
+    }
+    const { email, username } = getGitConfigInfo();
+    const cwd = argv.cwd ?? process.cwd();
+    const project = new LaunchQLPackage(cwd);
+    project.ensureWorkspace();
+    project.resetCwd(project.workspacePath);
+    const options = getEnvOptions();
+    const db = await getPgPool({
+        database: 'postgres'
+    });
+    const databasesResult = await db.query(`
+    SELECT datname FROM pg_catalog.pg_database
+    WHERE datistemplate = FALSE AND datname NOT IN ('postgres')
+      AND datname !~ '^pg_';
+  `);
+    let databases;
+    ({ databases } = await prompter.prompt(argv, [
+        {
+            type: 'checkbox',
+            name: 'databases',
+            message: 'Select a database',
+            options: databasesResult.rows.map(row => row.datname),
+            required: true
+        }
+    ]));
+    const dbname = databases.filter(d => d.selected).map(d => d.value)[0];
+    const selectedDb = await getPgPool({
+        database: dbname
+    });
+    const dbsResult = await selectedDb.query(`
+    SELECT id, name FROM collections_public.database;
+  `);
+    let database_ids;
+    ({ database_ids } = await prompter.prompt({}, [
+        {
+            type: 'checkbox',
+            name: 'database_ids',
+            message: 'Select database_id(s)',
+            options: dbsResult.rows.map(db => db.name),
+            required: true
+        }
+    ]));
+    const dbInfo = {
+        dbname,
+        database_ids: database_ids.map(did => dbsResult.rows.find(db => db.name === did.name).id)
+    };
+    const { author, extensionName, metaExtensionName } = await prompter.prompt(argv, [
+        {
+            type: 'text',
+            name: 'author',
+            message: 'Project author',
+            default: `${username} <${email}>`,
+            required: true
+        },
+        {
+            type: 'text',
+            name: 'extensionName',
+            message: 'Extension name',
+            default: dbInfo.database_ids[0],
+            required: true
+        },
+        {
+            type: 'text',
+            name: 'metaExtensionName',
+            message: 'Meta extension name',
+            default: 'svc',
+            required: true
+        }
+    ]);
+    const schemasResult = await selectedDb.query(`SELECT * FROM collections_public.schema WHERE database_id = $1`, [dbInfo.database_ids[0]]);
+    const { schema_names } = await prompter.prompt({}, [
+        {
+            type: 'checkbox',
+            name: 'schema_names',
+            message: 'Select schema_name(s)',
+            options: schemasResult.rows.map(s => s.schema_name),
+            default: schemasResult.rows.map(s => s.schema_name),
+            required: true
+        }
+    ]);
+    const outdir = resolve(project.workspacePath, 'packages/');
+    await exportMigrations({
+        project,
+        options,
+        dbInfo,
+        author,
+        schema_names,
+        outdir,
+        extensionName,
+        metaExtensionName
+    });
+    console.log(`
+
+        |||
+       (o o)
+   ooO--(_)--Ooo-
+
+✨ finished!
+`);
+};

package/esm/commands/extension.js

@@ -0,0 +1,46 @@
+import { LaunchQLPackage } from '@launchql/core';
+const extensionUsageText = `
+LaunchQL Extension Command:
+
+  lql extension [OPTIONS]
+
+  Manage module dependencies.
+
+Options:
+  --help, -h              Show this help message
+  --cwd <directory>       Working directory (default: current directory)
+
+Examples:
+  lql extension           Manage dependencies for current module
+`;
+export default async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(extensionUsageText);
+        process.exit(0);
+    }
+    const { cwd = process.cwd() } = argv;
+    const project = new LaunchQLPackage(cwd);
+    if (!project.isInModule()) {
+        throw new Error('You must run this command inside a LaunchQL module.');
+    }
+    const info = project.getModuleInfo();
+    const installed = project.getRequiredModules();
+    const available = project.getAvailableModules();
+    const filtered = available.filter(name => name !== info.extname);
+    const questions = [
+        {
+            name: 'extensions',
+            message: 'Which modules does this one depend on?',
+            type: 'checkbox',
+            allowCustomOptions: true,
+            options: filtered,
+            default: installed
+        }
+    ];
+    const answers = await prompter.prompt(argv, questions);
+    const selected = answers.extensions
+        .filter(opt => opt.selected)
+        .map(opt => opt.name);
+    project.setModuleDependencies(selected);
+};

package/esm/commands/init/index.js

@@ -0,0 +1,42 @@
+import runModuleSetup from './module';
+import runWorkspaceSetup from './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
+`;
+export 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 runWorkspaceSetup(argv, prompter);
+        case false:
+        default:
+            return runModuleSetup(argv, prompter);
+    }
+}