pgpm 0.0.1

package/commands/server.js

@@ -0,0 +1,187 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("@launchql/logger");
+const server_1 = require("@launchql/server");
+const env_1 = require("@launchql/env");
+const pg_cache_1 = require("pg-cache");
+const log = new logger_1.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
+    }
+];
+exports.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 (0, pg_cache_1.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 (0, pg_cache_1.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 = (0, env_1.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');
+    (0, server_1.LaunchQLServer)(options);
+};

package/commands/tag.d.ts

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

package/commands/tag.js

@@ -0,0 +1,168 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const logger_1 = require("@launchql/logger");
+const types_1 = require("@launchql/types");
+const argv_1 = require("../utils/argv");
+const module_utils_1 = require("../utils/module-utils");
+const path = __importStar(require("path"));
+const log = new logger_1.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
+`;
+exports.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 } = (0, argv_1.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 core_1.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 (0, module_utils_1.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 types_1.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 core_1.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;
+};

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

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

package/commands.d.ts

@@ -0,0 +1,5 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+import { ParsedArgs } from 'minimist';
+export declare const commands: (argv: Partial<ParsedArgs>, prompter: Inquirerer, options: CLIOptions & {
+    skipPgTeardown?: boolean;
+}) => Promise<Partial<ParsedArgs>>;

package/commands.js

@@ -0,0 +1,118 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commands = void 0;
+const pg_cache_1 = require("pg-cache");
+// Commands
+const add_1 = __importDefault(require("./commands/add"));
+const admin_users_1 = __importDefault(require("./commands/admin-users"));
+const clear_1 = __importDefault(require("./commands/clear"));
+const deploy_1 = __importDefault(require("./commands/deploy"));
+const explorer_1 = __importDefault(require("./commands/explorer"));
+const export_1 = __importDefault(require("./commands/export"));
+const extension_1 = __importDefault(require("./commands/extension"));
+const init_1 = __importDefault(require("./commands/init"));
+const install_1 = __importDefault(require("./commands/install"));
+const kill_1 = __importDefault(require("./commands/kill"));
+const migrate_1 = __importDefault(require("./commands/migrate"));
+const package_1 = __importDefault(require("./commands/package"));
+const plan_1 = __importDefault(require("./commands/plan"));
+const remove_1 = __importDefault(require("./commands/remove"));
+const revert_1 = __importDefault(require("./commands/revert"));
+const server_1 = __importDefault(require("./commands/server"));
+const tag_1 = __importDefault(require("./commands/tag"));
+const verify_1 = __importDefault(require("./commands/verify"));
+const analyze_1 = __importDefault(require("./commands/analyze"));
+const rename_1 = __importDefault(require("./commands/rename"));
+const package_2 = require("./package");
+const utils_1 = require("./utils");
+const cli_error_1 = require("./utils/cli-error");
+const withPgTeardown = (fn, skipTeardown = false) => async (...args) => {
+    try {
+        await fn(...args);
+    }
+    finally {
+        if (!skipTeardown) {
+            await (0, pg_cache_1.teardownPgPools)();
+        }
+    }
+};
+const createCommandMap = (skipPgTeardown = false) => {
+    const pgt = (fn) => withPgTeardown(fn, skipPgTeardown);
+    return {
+        add: add_1.default,
+        'admin-users': pgt(admin_users_1.default),
+        clear: pgt(clear_1.default),
+        deploy: pgt(deploy_1.default),
+        verify: pgt(verify_1.default),
+        revert: pgt(revert_1.default),
+        remove: pgt(remove_1.default),
+        init: pgt(init_1.default),
+        extension: pgt(extension_1.default),
+        plan: pgt(plan_1.default),
+        export: pgt(export_1.default),
+        package: pgt(package_1.default),
+        tag: pgt(tag_1.default),
+        kill: pgt(kill_1.default),
+        install: pgt(install_1.default),
+        migrate: pgt(migrate_1.default),
+        analyze: pgt(analyze_1.default),
+        rename: pgt(rename_1.default),
+        // These manage their own connection lifecycles
+        server: server_1.default,
+        explorer: explorer_1.default
+    };
+};
+const commands = async (argv, prompter, options) => {
+    if (argv.version || argv.v) {
+        const pkg = (0, package_2.readAndParsePackageJson)();
+        console.log(pkg.version);
+        process.exit(0);
+    }
+    let { first: command, newArgv } = (0, utils_1.extractFirst)(argv);
+    // Show usage if explicitly requested but no command specified
+    if ((argv.help || argv.h || command === 'help') && !command) {
+        console.log(utils_1.usageText);
+        process.exit(0);
+    }
+    // Show usage for help command specifically
+    if (command === 'help') {
+        console.log(utils_1.usageText);
+        process.exit(0);
+    }
+    const commandMap = createCommandMap(options?.skipPgTeardown);
+    // Prompt if no command provided
+    if (!command) {
+        const answer = await prompter.prompt(argv, [
+            {
+                type: 'autocomplete',
+                name: 'command',
+                message: 'What do you want to do?',
+                options: Object.keys(commandMap)
+            }
+        ]);
+        command = answer.command;
+    }
+    // Prompt for working directory
+    newArgv = await prompter.prompt(newArgv, [
+        {
+            type: 'text',
+            name: 'cwd',
+            message: 'Working directory',
+            required: false,
+            default: process.cwd(),
+            useDefault: true
+        }
+    ]);
+    const commandFn = commandMap[command];
+    if (!commandFn) {
+        console.log(utils_1.usageText);
+        await (0, cli_error_1.cliExitWithError)(`Unknown command: ${command}`);
+    }
+    await commandFn(newArgv, prompter, options);
+    prompter.close();
+    return argv;
+};
+exports.commands = commands;