@constructive-io/cli 0.0.2

package/commands/admin-users/remove.js

@@ -0,0 +1,82 @@
+"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 log = new logger_1.Logger('admin-users-remove');
+const removeUsageText = `
+Admin Users Remove Command:
+
+  constructive admin-users remove [OPTIONS]
+
+  Remove database users and revoke their postgres 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:
+  constructive admin-users remove --username myuser
+  constructive admin-users remove --test             # Remove test users
+  constructive admin-users remove                    # Will prompt for username
+`;
+exports.default = async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(removeUsageText);
+        process.exit(0);
+    }
+    const pgEnv = (0, pg_env_1.getPgEnvOptions)();
+    const isTest = argv.test;
+    const init = new core_1.LaunchQLInit(pgEnv);
+    try {
+        if (isTest) {
+            const { yes: confirmTest } = await prompter.prompt(argv, [
+                {
+                    type: 'confirm',
+                    name: 'yes',
+                    message: 'Are you sure you want to remove 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/commands/admin-users.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/admin-users.js

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const utils_1 = require("../utils");
+const add_1 = __importDefault(require("./admin-users/add"));
+const bootstrap_1 = __importDefault(require("./admin-users/bootstrap"));
+const remove_1 = __importDefault(require("./admin-users/remove"));
+const subcommandMap = {
+    add: add_1.default,
+    bootstrap: bootstrap_1.default,
+    remove: remove_1.default
+};
+const adminUsersUsageText = `
+Admin Users Commands:
+
+  constructive admin-users bootstrap    Initialize postgres roles and permissions (must be run first)
+  constructive admin-users add          Add database users with roles
+  constructive admin-users remove       Remove database users and revoke roles
+
+Options:
+  --help, -h     Show this help message
+  --cwd          Working directory (default: current directory)
+`;
+exports.default = async (argv, prompter, options) => {
+    let { first: subcommand, newArgv } = (0, utils_1.extractFirst)(argv);
+    // 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 postgres roles and permissions (must be run first)',
+        add: 'Add database users with roles',
+        remove: 'Remove database users and revoke roles'
+    };
+    return descriptions[cmd] || '';
+}

package/commands/analyze.d.ts

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

package/commands/analyze.js

@@ -0,0 +1,21 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const path_1 = __importDefault(require("path"));
+exports.default = async (argv, _prompter) => {
+    const cwd = argv.cwd || process.cwd();
+    const proj = new core_1.LaunchQLPackage(path_1.default.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/commands/clear.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/clear.js

@@ -0,0 +1,59 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const core_2 = require("@launchql/core");
+const env_1 = require("@launchql/env");
+const logger_1 = require("@launchql/logger");
+const types_1 = require("@launchql/types");
+const path_1 = __importDefault(require("path"));
+const pg_env_1 = require("pg-env");
+const utils_1 = require("../utils");
+const log = new logger_1.Logger('clear');
+exports.default = async (argv, prompter, _options) => {
+    const database = await (0, utils_1.getTargetDatabase)(argv, prompter, {
+        message: 'Select database'
+    });
+    const questions = [
+        {
+            name: 'yes',
+            type: 'confirm',
+            message: 'Are you sure you want to 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 core_1.LaunchQLPackage(cwd);
+    if (!pkg.isInModule()) {
+        throw new Error('Not in a LaunchQL module directory. Please run this command from within a module.');
+    }
+    const modulePath = pkg.getModulePath();
+    if (!modulePath) {
+        throw new Error('Could not resolve module path');
+    }
+    const planPath = path_1.default.join(modulePath, 'pgpm.plan');
+    const result = (0, core_2.parsePlanFile)(planPath);
+    if (result.errors.length > 0) {
+        throw types_1.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 = (0, env_1.getEnvOptions)({
+        pg: (0, pg_env_1.getPgEnvOptions)({ database })
+    });
+    await pkg.removeFromPlan(firstChange);
+    log.success(`✅ Successfully cleared all changes from the plan.`);
+    return argv;
+};

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

@@ -0,0 +1,146 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const env_1 = require("@launchql/env");
+const logger_1 = require("@launchql/logger");
+const child_process_1 = require("child_process");
+const pg_env_1 = require("pg-env");
+const utils_1 = require("../utils");
+const module_utils_1 = require("../utils/module-utils");
+const deployUsageText = `
+Deploy Command:
+
+  constructive 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:
+  constructive deploy                              Deploy to selected database
+  constructive deploy --createdb                   Deploy with database creation
+  constructive deploy --package mypackage --to @v1.0.0  Deploy specific package to tag
+  constructive deploy --fast --no-tx              Fast deployment without transactions
+`;
+exports.default = async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(deployUsageText);
+        process.exit(0);
+    }
+    const pgEnv = (0, pg_env_1.getPgEnvOptions)();
+    const log = new logger_1.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 (0, utils_1.getTargetDatabase)(argv, prompter, {
+            message: 'Select database'
+        });
+    }
+    const questions = [
+        {
+            name: 'yes',
+            type: 'confirm',
+            message: 'Are you sure you want to proceed?',
+            required: true
+        },
+        {
+            name: 'recursive',
+            type: 'confirm',
+            message: 'Deploy recursively through dependencies?',
+            useDefault: true,
+            default: true,
+            required: false
+        },
+        {
+            name: 'tx',
+            type: 'confirm',
+            message: 'Use Transaction?',
+            useDefault: true,
+            default: true,
+            required: false
+        },
+        {
+            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}...`);
+        (0, child_process_1.execSync)(`createdb ${database}`, {
+            env: (0, pg_env_1.getSpawnEnvWithPg)(pgEnv)
+        });
+    }
+    let packageName;
+    if (recursive) {
+        packageName = await (0, module_utils_1.selectPackage)(argv, prompter, cwd, 'deploy', log);
+    }
+    const cliOverrides = {
+        pg: (0, pg_env_1.getPgEnvOptions)({ database }),
+        deployment: {
+            useTx: tx !== false,
+            fast: fast !== false,
+            usePlan: argv.usePlan !== false,
+            cache: argv.cache !== false,
+            logOnly: argv.logOnly !== false,
+        }
+    };
+    const opts = (0, env_1.getEnvOptions)(cliOverrides);
+    const project = new core_1.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/commands/docker.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/docker.js

@@ -0,0 +1,194 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const utils_1 = require("../utils");
+const dockerUsageText = `
+Docker Command:
+
+  constructive docker <subcommand> [OPTIONS]
+
+  Manage PostgreSQL Docker containers for local development.
+
+Subcommands:
+  start              Start PostgreSQL container
+  stop               Stop PostgreSQL container
+
+Options:
+  --help, -h         Show this help message
+  --name <name>      Container name (default: postgres)
+  --image <image>    Docker image (default: pyramation/pgvector:13.3-alpine)
+  --port <port>      Host port mapping (default: 5432)
+  --user <user>      PostgreSQL user (default: postgres)
+  --password <pass>  PostgreSQL password (default: password)
+  --recreate         Remove and recreate container on start
+
+Examples:
+  constructive docker start                           Start default PostgreSQL container
+  constructive docker start --port 5433               Start on custom port
+  constructive docker start --recreate                Remove and recreate container
+  constructive docker stop                            Stop PostgreSQL container
+`;
+function run(command, args, options = {}) {
+    return new Promise((resolve, reject) => {
+        const stdio = options.stdio || 'pipe';
+        const child = (0, child_process_1.spawn)(command, args, { stdio });
+        let stdout = '';
+        let stderr = '';
+        if (stdio === 'pipe') {
+            child.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            child.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+        }
+        child.on('error', (error) => {
+            reject(error);
+        });
+        child.on('close', (code) => {
+            resolve({
+                code: code ?? 0,
+                stdout: stdout.trim(),
+                stderr: stderr.trim()
+            });
+        });
+    });
+}
+async function checkDockerAvailable() {
+    try {
+        const result = await run('docker', ['--version']);
+        return result.code === 0;
+    }
+    catch (error) {
+        return false;
+    }
+}
+async function isContainerRunning(name) {
+    try {
+        const result = await run('docker', ['inspect', '-f', '{{.State.Running}}', name]);
+        if (result.code === 0) {
+            return result.stdout.trim() === 'true';
+        }
+        return null;
+    }
+    catch (error) {
+        return null;
+    }
+}
+async function containerExists(name) {
+    try {
+        const result = await run('docker', ['inspect', name]);
+        return result.code === 0;
+    }
+    catch (error) {
+        return false;
+    }
+}
+async function startContainer(options) {
+    const { name, image, port, user, password, recreate } = options;
+    const dockerAvailable = await checkDockerAvailable();
+    if (!dockerAvailable) {
+        await (0, utils_1.cliExitWithError)('Docker is not installed or not available in PATH. Please install Docker first.');
+        return;
+    }
+    const exists = await containerExists(name);
+    const running = await isContainerRunning(name);
+    if (running === true) {
+        console.log(`✅ Container "${name}" is already running`);
+        return;
+    }
+    if (recreate && exists) {
+        console.log(`🗑️  Removing existing container "${name}"...`);
+        const removeResult = await run('docker', ['rm', '-f', name], { stdio: 'inherit' });
+        if (removeResult.code !== 0) {
+            await (0, utils_1.cliExitWithError)(`Failed to remove container "${name}"`);
+            return;
+        }
+    }
+    if (exists && running === false) {
+        console.log(`🔄 Starting existing container "${name}"...`);
+        const startResult = await run('docker', ['start', name], { stdio: 'inherit' });
+        if (startResult.code === 0) {
+            console.log(`✅ Container "${name}" started successfully`);
+        }
+        else {
+            await (0, utils_1.cliExitWithError)(`Failed to start container "${name}"`);
+        }
+        return;
+    }
+    console.log(`🚀 Creating and starting new container "${name}"...`);
+    const runArgs = [
+        'run',
+        '-d',
+        '--name', name,
+        '-e', `POSTGRES_USER=${user}`,
+        '-e', `POSTGRES_PASSWORD=${password}`,
+        '-p', `${port}:5432`,
+        image
+    ];
+    const runResult = await run('docker', runArgs, { stdio: 'inherit' });
+    if (runResult.code === 0) {
+        console.log(`✅ Container "${name}" created and started successfully`);
+        console.log(`📌 PostgreSQL is available at localhost:${port}`);
+        console.log(`👤 User: ${user}`);
+        console.log(`🔑 Password: ${password}`);
+    }
+    else {
+        await (0, utils_1.cliExitWithError)(`Failed to create container "${name}". Check if port ${port} is already in use.`);
+    }
+}
+async function stopContainer(name) {
+    const dockerAvailable = await checkDockerAvailable();
+    if (!dockerAvailable) {
+        await (0, utils_1.cliExitWithError)('Docker is not installed or not available in PATH. Please install Docker first.');
+        return;
+    }
+    const exists = await containerExists(name);
+    if (!exists) {
+        console.log(`ℹ️  Container "${name}" not found`);
+        return;
+    }
+    const running = await isContainerRunning(name);
+    if (running === false) {
+        console.log(`ℹ️  Container "${name}" is already stopped`);
+        return;
+    }
+    console.log(`🛑 Stopping container "${name}"...`);
+    const stopResult = await run('docker', ['stop', name], { stdio: 'inherit' });
+    if (stopResult.code === 0) {
+        console.log(`✅ Container "${name}" stopped successfully`);
+    }
+    else {
+        await (0, utils_1.cliExitWithError)(`Failed to stop container "${name}"`);
+    }
+}
+exports.default = async (argv, _prompter, _options) => {
+    if (argv.help || argv.h) {
+        console.log(dockerUsageText);
+        process.exit(0);
+    }
+    const { first: subcommand, newArgv } = (0, utils_1.extractFirst)(argv);
+    const args = newArgv;
+    if (!subcommand) {
+        console.log(dockerUsageText);
+        await (0, utils_1.cliExitWithError)('No subcommand provided. Use "start" or "stop".');
+        return;
+    }
+    const name = args.name || 'postgres';
+    const image = args.image || 'pyramation/pgvector:13.3-alpine';
+    const port = typeof args.port === 'number' ? args.port : 5432;
+    const user = args.user || 'postgres';
+    const password = args.password || 'password';
+    const recreate = args.recreate === true;
+    switch (subcommand) {
+        case 'start':
+            await startContainer({ name, image, port, user, password, recreate });
+            break;
+        case 'stop':
+            await stopContainer(name);
+            break;
+        default:
+            console.log(dockerUsageText);
+            await (0, utils_1.cliExitWithError)(`Unknown subcommand: ${subcommand}. Use "start" or "stop".`);
+    }
+};

package/commands/env.d.ts

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