@launchql/cli/commands/deploy.js

LaunchQL CLI

"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 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 = `
LaunchQL Deploy Command:

  lql deploy [OPTIONS]

  Deploy database changes and migrations to target database.

Options:
  --help, -h         Show this help message
  --createdb         Create database if it doesn't exist
  --recursive        Deploy recursively through dependencies
  --package <name>   Target specific package
  --to <target>      Deploy to specific change or tag
  --tx               Use transactions (default: true)
  --fast             Use fast deployment strategy
  --logOnly          Log-only mode, skip script execution
  --usePlan          Use deployment plan
  --cache            Enable caching
  --cwd <directory>  Working directory (default: current directory)

Examples:
  lql deploy                              Deploy to selected database
  lql deploy --createdb                   Deploy with database creation
  lql deploy --package mypackage --to @v1.0.0  Deploy specific package to tag
  lql deploy --fast --no-tx              Fast deployment without transactions
`;
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: '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;
};