pgpm 0.0.1

package/esm/commands/migrate.js

@@ -0,0 +1,64 @@
+import { extractFirst } from '../utils';
+import deps from './migrate/deps';
+// Migrate subcommands
+import init from './migrate/init';
+import list from './migrate/list';
+import status from './migrate/status';
+const subcommandMap = {
+    init,
+    status,
+    list,
+    deps
+};
+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)
+`;
+export default async (argv, prompter, options) => {
+    let { first: subcommand, newArgv } = 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/esm/commands/package.js

@@ -0,0 +1,63 @@
+import { LaunchQLPackage, writePackage } from '@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
+`;
+export 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 LaunchQLPackage(cwd);
+    project.ensureModule();
+    const info = project.getModuleInfo();
+    info.version;
+    await writePackage({
+        version: info.version,
+        extension: true,
+        usePlan: plan,
+        packageDir: project.modulePath,
+        pretty,
+        functionDelimiter
+    });
+    return argv;
+};

package/esm/commands/plan.js

@@ -0,0 +1,60 @@
+import { LaunchQLPackage } from '@launchql/core';
+import { Logger } from '@launchql/logger';
+const log = new 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
+`;
+export 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 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/esm/commands/remove.js

@@ -0,0 +1,40 @@
+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 { cliExitWithError } from '../utils/cli-error';
+const log = new Logger('remove');
+export default async (argv, prompter, _options) => {
+    if (!argv.to) {
+        await cliExitWithError('No change specified. Usage: lql remove --to <change>');
+    }
+    const database = await 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 LaunchQLPackage(cwd);
+    if (!pkg.isInModule()) {
+        throw new Error('Not in a LaunchQL module directory. Please run this command from within a module.');
+    }
+    const opts = getEnvOptions({
+        pg: getPgEnvOptions({ database })
+    });
+    const toChange = argv.to;
+    await pkg.removeFromPlan(toChange);
+    log.success(`✅ Successfully removed changes from '${toChange}' to end of plan.`);
+    return argv;
+};

package/esm/commands/rename.js

@@ -0,0 +1,30 @@
+import path from 'path';
+import { LaunchQLPackage } from '@launchql/core';
+import { cliExitWithError } from '../utils/cli-error';
+export default async (argv, _prompter) => {
+    const cwd = argv.cwd || process.cwd();
+    const to = argv.to || (argv._ && argv._[0]);
+    if (!to) {
+        await 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 LaunchQLPackage(path.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/esm/commands/revert.js

@@ -0,0 +1,105 @@
+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('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
+`;
+export default async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(revertUsageText);
+        process.exit(0);
+    }
+    const 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
+        }
+    ];
+    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 selectDeployedPackage(database, argv, prompter, log, 'revert');
+        if (!packageName) {
+            await cliExitWithError('No package found to revert');
+        }
+    }
+    const pkg = new LaunchQLPackage(cwd);
+    const opts = getEnvOptions({
+        pg: getPgEnvOptions({ database }),
+        deployment: {
+            useTx: tx
+        }
+    });
+    let target;
+    if (argv.to === true) {
+        target = await selectDeployedChange(database, argv, prompter, log, 'revert');
+        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 pkg.revert(opts, target, recursive);
+    log.success('Revert complete.');
+    return argv;
+};

package/esm/commands/server.js

@@ -0,0 +1,185 @@
+import { Logger } from '@launchql/logger';
+import { LaunchQLServer as server } from '@launchql/server';
+import { getEnvOptions } from '@launchql/env';
+import { getPgPool } from 'pg-cache';
+const log = new Logger('server');
+const serverUsageText = `
+LaunchQL Server Command:
+
+  lql server [OPTIONS]
+
+  Start LaunchQL GraphQL development server.
+
+Options:
+  --help, -h              Show this help message
+  --port <number>         Server port (default: 5555)
+  --simpleInflection      Use simple inflection (default: true)
+  --oppositeBaseNames     Use opposite base names (default: false)
+  --postgis               Enable PostGIS extension (default: true)
+  --metaApi               Enable Meta API (default: true)
+  --cwd <directory>       Working directory (default: current directory)
+
+Examples:
+  lql server                    Start server with defaults
+  lql server --port 8080        Start server on custom port
+  lql server --no-postgis       Start server without PostGIS
+`;
+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: 'metaApi',
+        message: 'Enable Meta API?',
+        type: 'confirm',
+        required: false,
+        default: true,
+        useDefault: true
+    },
+    {
+        name: 'origin',
+        message: 'CORS origin (exact URL or *)',
+        type: 'text',
+        required: false,
+        // no default to avoid accidentally opening up CORS; pass explicitly or via env
+    },
+    {
+        name: 'port',
+        message: 'Development server port',
+        type: 'number',
+        required: false,
+        default: 5555,
+        useDefault: true
+    }
+];
+export default async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(serverUsageText);
+        process.exit(0);
+    }
+    log.info('🔧 LaunchQL Server Configuration:\n');
+    let selectedDb = process.env.PGDATABASE;
+    if (!selectedDb) {
+        const db = await getPgPool({ database: 'postgres' });
+        const result = await db.query(`
+      SELECT datname FROM pg_database
+      WHERE datistemplate = false AND datname NOT IN ('postgres')
+        AND datname !~ '^pg_'
+      ORDER BY datname;
+    `);
+        const dbChoices = result.rows.map(row => row.datname);
+        const { database } = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'database',
+                message: 'Select the database to use',
+                options: dbChoices,
+                required: true
+            }
+        ]);
+        selectedDb = database;
+        log.info(`📌 Using database: "${selectedDb}"`);
+    }
+    const { oppositeBaseNames, port, postgis, simpleInflection, metaApi, origin } = await prompter.prompt(argv, questions);
+    // Warn when passing CORS override via CLI, especially in production
+    if (origin && origin.trim().length) {
+        const env = (process.env.NODE_ENV || 'development').toLowerCase();
+        if (env === 'production') {
+            if (origin.trim() === '*') {
+                log.warn('CORS wildcard ("*") provided via --origin in production: this effectively disables CORS and is not recommended. Prefer per-API CORS via meta schema.');
+            }
+            else {
+                log.warn(`CORS override (origin=${origin.trim()}) provided via --origin in production. Prefer per-API CORS via meta schema.`);
+            }
+        }
+    }
+    let selectedSchemas = [];
+    let authRole;
+    let roleName;
+    if (!metaApi) {
+        const db = await getPgPool({ database: selectedDb });
+        const result = await db.query(`
+      SELECT nspname 
+      FROM pg_namespace 
+      WHERE nspname NOT IN ('pg_catalog', 'information_schema')
+      ORDER BY nspname;
+    `);
+        const schemaChoices = result.rows.map(row => ({
+            name: row.nspname,
+            value: row.nspname,
+            selected: true
+        }));
+        const { schemas } = await prompter.prompt(argv, [
+            {
+                type: 'checkbox',
+                name: 'schemas',
+                message: 'Select schemas to expose',
+                options: schemaChoices,
+                required: true
+            }
+        ]);
+        selectedSchemas = schemas.filter(s => s.selected).map(s => s.value);
+        const { authRole: selectedAuthRole, roleName: selectedRoleName } = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'authRole',
+                message: 'Select the authentication role',
+                options: ['postgres', 'authenticated', 'anonymous'],
+                required: true
+            },
+            {
+                type: 'autocomplete',
+                name: 'roleName',
+                message: 'Enter the default role name:',
+                options: ['postgres', 'authenticated', 'anonymous'],
+                required: true
+            }
+        ]);
+        authRole = selectedAuthRole;
+        roleName = selectedRoleName;
+    }
+    const options = getEnvOptions({
+        pg: { database: selectedDb },
+        features: {
+            oppositeBaseNames,
+            simpleInflection,
+            postgis
+        },
+        api: {
+            enableMetaApi: metaApi,
+            ...(metaApi === false && { exposedSchemas: selectedSchemas, authRole, roleName })
+        },
+        server: {
+            port,
+            ...(origin ? { origin } : {})
+        }
+    });
+    log.success('✅ Selected Configuration:');
+    for (const [key, value] of Object.entries(options)) {
+        log.debug(`${key}: ${JSON.stringify(value)}`);
+    }
+    log.success('🚀 Launching Server...\n');
+    server(options);
+};

package/esm/commands/tag.js

@@ -0,0 +1,133 @@
+import { LaunchQLPackage } from '@launchql/core';
+import { Logger } from '@launchql/logger';
+import { errors } from '@launchql/types';
+import { extractFirst } from '../utils/argv';
+import { selectPackage } from '../utils/module-utils';
+import * as path from 'path';
+const log = new Logger('tag');
+const tagUsageText = `
+LaunchQL Tag Command:
+
+  lql tag [tag_name] [OPTIONS]
+
+  Add tags to changes for versioning.
+
+Arguments:
+  tag_name                Name of the tag to create
+
+Options:
+  --help, -h              Show this help message
+  --package <name>        Target specific package
+  --changeName <name>     Target specific change (default: latest)
+  --comment <text>        Optional tag comment
+  --cwd <directory>       Working directory (default: current directory)
+
+Examples:
+  lql tag v1.0.0                                    Add tag to latest change
+  lql tag v1.0.0 --comment "Initial release"       Add tag with comment
+  lql tag v1.1.0 --package mypackage --changeName my-change  Tag specific change in package
+`;
+export default async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(tagUsageText);
+        process.exit(0);
+    }
+    const { first: tagName, newArgv } = extractFirst(argv);
+    const cwdResult = await prompter.prompt(newArgv, [
+        {
+            type: 'text',
+            name: 'cwd',
+            message: 'Working directory',
+            required: false,
+            default: process.cwd(),
+            useDefault: true
+        }
+    ]);
+    const cwd = cwdResult.cwd || process.cwd();
+    const pkg = new LaunchQLPackage(cwd);
+    let packageName;
+    if (argv.package) {
+        packageName = argv.package;
+        log.info(`Using specified package: ${packageName}`);
+    }
+    else if (pkg.isInModule()) {
+        packageName = pkg.getModuleName();
+        log.info(`Using current module: ${packageName}`);
+    }
+    else if (pkg.isInWorkspace()) {
+        packageName = await selectPackage(newArgv, prompter, cwd, 'add tag to', log);
+        if (!packageName) {
+            throw new Error('No package selected. Cannot add tag without specifying a target package.');
+        }
+    }
+    else {
+        throw new Error('This command must be run inside a LaunchQL workspace or module.');
+    }
+    const questions = [];
+    if (!tagName) {
+        questions.push({
+            type: 'text',
+            name: 'tagName',
+            message: 'Tag name',
+            required: true,
+            validate: (value) => {
+                if (!value || value.trim().length === 0) {
+                    return false;
+                }
+                if (value.includes('/')) {
+                    return false;
+                }
+                if (value.includes('@')) {
+                    return false;
+                }
+                return true;
+            }
+        });
+    }
+    questions.push({
+        type: 'text',
+        name: 'changeName',
+        message: 'Target change name (leave empty for latest change)',
+        required: false
+    }, {
+        type: 'text',
+        name: 'comment',
+        message: 'Tag comment (optional)',
+        required: false
+    });
+    const answers = await prompter.prompt(newArgv, questions);
+    const finalTagName = tagName || answers.tagName;
+    const changeName = answers.changeName;
+    const comment = answers.comment;
+    try {
+        if (argv.package || !pkg.isInModule()) {
+            const moduleMap = pkg.getModuleMap();
+            const module = moduleMap[packageName];
+            if (!module) {
+                throw errors.MODULE_NOT_FOUND({ name: packageName });
+            }
+            const workspacePath = pkg.getWorkspacePath();
+            const absoluteModulePath = path.resolve(workspacePath, module.path);
+            const originalCwd = process.cwd();
+            process.chdir(absoluteModulePath);
+            try {
+                const modulePkg = new LaunchQLPackage(absoluteModulePath);
+                modulePkg.addTag(finalTagName.trim(), changeName?.trim() || undefined, comment?.trim() || undefined);
+                log.info(`Successfully added tag '${finalTagName}' to ${changeName || 'latest change'} in package '${packageName}'`);
+            }
+            finally {
+                process.chdir(originalCwd);
+            }
+        }
+        else {
+            pkg.addTag(finalTagName.trim(), changeName?.trim() || undefined, comment?.trim() || undefined);
+            log.info(`Successfully added tag '${finalTagName}' to ${changeName || 'latest change'}`);
+        }
+    }
+    catch (error) {
+        log.error(`Failed to add tag: ${error instanceof Error ? error.message : String(error)}`);
+        throw error;
+    }
+    return newArgv;
+};