@constructive-io/cli 0.0.3 → 5.1.1

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

@@ -1,80 +0,0 @@
-import { LaunchQLInit } from '@launchql/core';
-import { Logger } from '@launchql/logger';
-import { getPgEnvOptions } from 'pg-env';
-const log = new 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
-`;
-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 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

@@ -1,63 +0,0 @@
-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 = `
-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)
-`;
-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 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/esm/commands/analyze.js

@@ -1,16 +0,0 @@
-import { LaunchQLPackage } from '@launchql/core';
-import path from 'path';
-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

@@ -1,54 +0,0 @@
-import { LaunchQLPackage } from '@launchql/core';
-import { parsePlanFile } from '@launchql/core';
-import { getEnvOptions } from '@launchql/env';
-import { Logger } from '@launchql/logger';
-import { errors } from '@launchql/types';
-import path from 'path';
-import { getPgEnvOptions } from 'pg-env';
-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, 'pgpm.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

@@ -1,144 +0,0 @@
-import { LaunchQLPackage } from '@launchql/core';
-import { getEnvOptions } from '@launchql/env';
-import { Logger } from '@launchql/logger';
-import { execSync } from 'child_process';
-import { getPgEnvOptions, getSpawnEnvWithPg, } from 'pg-env';
-import { getTargetDatabase } from '../utils';
-import { selectPackage } from '../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
-`;
-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/docker.js

@@ -1,192 +0,0 @@
-import { spawn } from 'child_process';
-import { cliExitWithError, extractFirst } from '../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 = 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 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 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 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 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 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 cliExitWithError(`Failed to stop container "${name}"`);
-    }
-}
-export default async (argv, _prompter, _options) => {
-    if (argv.help || argv.h) {
-        console.log(dockerUsageText);
-        process.exit(0);
-    }
-    const { first: subcommand, newArgv } = extractFirst(argv);
-    const args = newArgv;
-    if (!subcommand) {
-        console.log(dockerUsageText);
-        await 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 cliExitWithError(`Unknown subcommand: ${subcommand}. Use "start" or "stop".`);
-    }
-};

package/esm/commands/env.js

@@ -1,122 +0,0 @@
-import { spawn } from 'child_process';
-import { defaultPgConfig } from 'pg-env';
-const envUsageText = `
-Environment Command:
-
-  constructive env [OPTIONS] [COMMAND...]
-
-  Manage PostgreSQL environment variables with profile support.
-
-Profiles:
-  (default)          Use local Postgres development profile
-  --supabase         Use Supabase local development profile
-
-Modes:
-  No command         Print export statements for shell evaluation
-  With command       Execute command with environment variables applied
-
-Options:
-  --help, -h         Show this help message
-  --supabase         Use Supabase profile instead of default Postgres
-
-Examples:
-  constructive env                                    Print default Postgres env exports
-  constructive env --supabase                         Print Supabase env exports
-  eval "$(constructive env)"                          Load default Postgres env into shell
-  eval "$(constructive env --supabase)"               Load Supabase env into shell
-  constructive env lql deploy --database db1          Run command with default Postgres env
-  constructive env createdb mydb                      Run command with default Postgres env
-  constructive env --supabase lql deploy --database db1  Run command with Supabase env
-  constructive env --supabase createdb mydb           Run command with Supabase env
-`;
-const SUPABASE_PROFILE = {
-    host: 'localhost',
-    port: 54322,
-    user: 'supabase_admin',
-    password: 'postgres',
-    database: 'postgres'
-};
-const DEFAULT_PROFILE = {
-    ...defaultPgConfig
-};
-function configToEnvVars(config) {
-    return {
-        PGHOST: config.host,
-        PGPORT: String(config.port),
-        PGUSER: config.user,
-        PGPASSWORD: config.password,
-        PGDATABASE: config.database
-    };
-}
-function printExports(config) {
-    const envVars = configToEnvVars(config);
-    for (const [key, value] of Object.entries(envVars)) {
-        const escapedValue = value.replace(/\\/g, '\\\\').replace(/"/g, '\\"');
-        console.log(`export ${key}="${escapedValue}"`);
-    }
-}
-function executeCommand(config, command, args) {
-    return new Promise((resolve, reject) => {
-        const envVars = configToEnvVars(config);
-        const env = {
-            ...process.env,
-            ...envVars
-        };
-        const child = spawn(command, args, {
-            env,
-            stdio: 'inherit',
-            shell: false
-        });
-        child.on('error', (error) => {
-            reject(error);
-        });
-        child.on('close', (code) => {
-            resolve(code ?? 0);
-        });
-    });
-}
-export default async (argv, _prompter) => {
-    if (argv.help || argv.h) {
-        console.log(envUsageText);
-        process.exit(0);
-    }
-    const useSupabase = argv.supabase === true || typeof argv.supabase === 'string';
-    const profile = useSupabase ? SUPABASE_PROFILE : DEFAULT_PROFILE;
-    const rawArgs = process.argv.slice(2);
-    let envIndex = rawArgs.findIndex(arg => arg === 'env');
-    if (envIndex === -1) {
-        envIndex = 0;
-    }
-    const argsAfterEnv = rawArgs.slice(envIndex + 1);
-    const supabaseIndex = argsAfterEnv.findIndex(arg => arg === '--supabase');
-    let commandArgs;
-    if (supabaseIndex !== -1) {
-        commandArgs = argsAfterEnv.slice(supabaseIndex + 1);
-    }
-    else {
-        commandArgs = argsAfterEnv;
-    }
-    commandArgs = commandArgs.filter(arg => arg !== '--cwd' && !arg.startsWith('--cwd='));
-    const cwdIndex = commandArgs.findIndex(arg => arg === '--cwd');
-    if (cwdIndex !== -1 && cwdIndex + 1 < commandArgs.length) {
-        commandArgs.splice(cwdIndex, 2);
-    }
-    if (commandArgs.length === 0) {
-        printExports(profile);
-        return;
-    }
-    const [command, ...args] = commandArgs;
-    try {
-        const exitCode = await executeCommand(profile, command, args);
-        process.exit(exitCode);
-    }
-    catch (error) {
-        if (error instanceof Error) {
-            console.error(`Error executing command: ${error.message}`);
-        }
-        else {
-            console.error(`Error executing command: ${String(error)}`);
-        }
-        process.exit(1);
-    }
-};