@constructive-io/cli 0.0.2

package/commands/remove.js

@@ -0,0 +1,42 @@
+"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 pg_env_1 = require("pg-env");
+const utils_1 = require("../utils");
+const cli_error_1 = require("../utils/cli-error");
+const log = new logger_1.Logger('remove');
+exports.default = async (argv, prompter, _options) => {
+    if (!argv.to) {
+        await (0, cli_error_1.cliExitWithError)('No change specified. Usage: constructive remove --to <change>');
+    }
+    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 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 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 opts = (0, env_1.getEnvOptions)({
+        pg: (0, pg_env_1.getPgEnvOptions)({ database })
+    });
+    const toChange = argv.to;
+    await pkg.removeFromPlan(toChange);
+    log.success(`✅ Successfully removed changes from '${toChange}' to end of plan.`);
+    return argv;
+};

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

@@ -0,0 +1,35 @@
+"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"));
+const cli_error_1 = require("../utils/cli-error");
+exports.default = async (argv, _prompter) => {
+    const cwd = argv.cwd || process.cwd();
+    const to = argv.to || (argv._ && argv._[0]);
+    if (!to) {
+        await (0, cli_error_1.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 core_1.LaunchQLPackage(path_1.default.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/commands/revert.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/revert.js

@@ -0,0 +1,107 @@
+"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 pg_env_1 = require("pg-env");
+const utils_1 = require("../utils");
+const cli_error_1 = require("../utils/cli-error");
+const deployed_changes_1 = require("../utils/deployed-changes");
+const log = new logger_1.Logger('revert');
+const revertUsageText = `
+Revert Command:
+
+  constructive 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:
+  constructive revert                    Revert latest changes
+  constructive revert --to @v1.0.0      Revert to specific tag
+  constructive revert --to              Interactive selection from deployed changes
+`;
+exports.default = async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(revertUsageText);
+        process.exit(0);
+    }
+    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 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 (0, deployed_changes_1.selectDeployedPackage)(database, argv, prompter, log, 'revert');
+        if (!packageName) {
+            await (0, cli_error_1.cliExitWithError)('No package found to revert');
+        }
+    }
+    const pkg = new core_1.LaunchQLPackage(cwd);
+    const opts = (0, env_1.getEnvOptions)({
+        pg: (0, pg_env_1.getPgEnvOptions)({ database }),
+        deployment: {
+            useTx: tx
+        }
+    });
+    let target;
+    if (argv.to === true) {
+        target = await (0, deployed_changes_1.selectDeployedChange)(database, argv, prompter, log, 'revert');
+        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 pkg.revert(opts, target, recursive);
+    log.success('Revert complete.');
+    return argv;
+};

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 path = __importStar(require("path"));
+const argv_1 = require("../utils/argv");
+const module_utils_1 = require("../utils/module-utils");
+const log = new logger_1.Logger('tag');
+const tagUsageText = `
+Tag Command:
+
+  constructive 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:
+  constructive tag v1.0.0                                    Add tag to latest change
+  constructive tag v1.0.0 --comment "Initial release"       Add tag with comment
+  constructive 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 env_1 = require("@launchql/env");
+const logger_1 = require("@launchql/logger");
+const pg_env_1 = require("pg-env");
+const utils_1 = require("../utils");
+const cli_error_1 = require("../utils/cli-error");
+const deployed_changes_1 = require("../utils/deployed-changes");
+const log = new logger_1.Logger('verify');
+const verifyUsageText = `
+Verify Command:
+
+  constructive 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:
+  constructive verify                    Verify current database state
+  constructive verify --package mypackage  Verify specific package
+  constructive 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,6 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+import { ParsedArgs } from 'minimist';
+export declare const createConstructiveCommandMap: (skipPgTeardown?: boolean) => Record<string, Function>;
+export declare const commands: (argv: Partial<ParsedArgs>, prompter: Inquirerer, options: CLIOptions & {
+    skipPgTeardown?: boolean;
+}) => Promise<Partial<ParsedArgs>>;

package/commands.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.commands = exports.createConstructiveCommandMap = void 0;
+const pg_cache_1 = require("pg-cache");
+const add_1 = __importDefault(require("./commands/add"));
+const admin_users_1 = __importDefault(require("./commands/admin-users"));
+const analyze_1 = __importDefault(require("./commands/analyze"));
+const clear_1 = __importDefault(require("./commands/clear"));
+const deploy_1 = __importDefault(require("./commands/deploy"));
+const docker_1 = __importDefault(require("./commands/docker"));
+const env_1 = __importDefault(require("./commands/env"));
+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 rename_1 = __importDefault(require("./commands/rename"));
+const revert_1 = __importDefault(require("./commands/revert"));
+const tag_1 = __importDefault(require("./commands/tag"));
+const verify_1 = __importDefault(require("./commands/verify"));
+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 createConstructiveCommandMap = (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),
+        docker: docker_1.default,
+        env: env_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)
+    };
+};
+exports.createConstructiveCommandMap = createConstructiveCommandMap;
+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);
+    if ((argv.help || argv.h || command === 'help') && !command) {
+        console.log(utils_1.usageText);
+        process.exit(0);
+    }
+    if (command === 'help') {
+        console.log(utils_1.usageText);
+        process.exit(0);
+    }
+    const commandMap = (0, exports.createConstructiveCommandMap)(options?.skipPgTeardown);
+    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;
+    }
+    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;