@constructive-io/cli 0.0.2

package/esm/utils/display.js

@@ -0,0 +1,58 @@
+import chalk from 'chalk';
+import { readAndParsePackageJson } from '../package';
+// Function to display the version information
+export function displayVersion() {
+    const pkg = readAndParsePackageJson();
+    console.log(chalk.green(`Name: ${pkg.name}`));
+    console.log(chalk.blue(`Version: ${pkg.version}`));
+}
+export const usageText = `
+  Usage: constructive <command> [options]
+
+  Core Database Operations:
+    add                Add database changes to plans and create SQL files
+    deploy             Deploy database changes and migrations
+    verify             Verify database state and migrations
+    revert             Revert database changes and migrations
+
+  Project Management:
+    init               Initialize workspace or module
+    extension          Manage module dependencies
+    plan               Generate module deployment plans
+    package            Package module for distribution
+    export             Export database migrations from existing databases
+
+  Database Administration:
+    kill               Terminate database connections and optionally drop databases
+    install            Install database modules
+    tag                Add tags to changes for versioning
+    clear              Clear database state
+    remove             Remove database changes
+    analyze            Analyze database structure
+    rename             Rename database changes
+    admin-users        Manage admin users
+
+  Migration Tools:
+    migrate            Migration management subcommands
+      init             Initialize migration tracking
+      status           Show migration status
+      list             List all changes
+      deps             Show change dependencies
+
+  Global Options:
+    -h, --help         Display this help information
+    -v, --version      Display version information
+    --cwd <directory>  Working directory (default: current directory)
+
+  Individual Command Help:
+    constructive <command> --help    Display detailed help for specific command
+    constructive <command> -h        Display detailed help for specific command
+
+  Examples:
+    constructive deploy --help       Show deploy command options
+    constructive init --workspace    Initialize new workspace
+    constructive install @pgpm/base32  Install a database module
+  `;
+export function displayUsage() {
+    console.log(usageText);
+}

package/esm/utils/index.js

@@ -0,0 +1,6 @@
+export * from './argv';
+export * from './database';
+export * from './display';
+export * from './cli-error';
+export * from './deployed-changes';
+export * from './module-utils';

package/esm/utils/module-utils.js

@@ -0,0 +1,51 @@
+import { LaunchQLPackage } from '@launchql/core';
+import { errors } from '@launchql/types';
+/**
+ * Handle package selection for operations that need a specific package
+ * Returns the selected package name, or undefined if validation fails or no packages exist
+ */
+export async function selectPackage(argv, prompter, cwd, operationName, log) {
+    const pkg = new LaunchQLPackage(cwd);
+    const modules = await pkg.getModules();
+    const moduleNames = modules.map(mod => mod.getModuleName());
+    // Check if any modules exist
+    if (!moduleNames.length) {
+        const errorMsg = 'No modules found in the specified directory.';
+        if (log) {
+            log.error(errorMsg);
+            return undefined;
+        }
+        else {
+            prompter.close();
+            throw errors.NOT_FOUND({}, errorMsg);
+        }
+    }
+    // If a specific package was provided, validate it
+    if (argv.package) {
+        const packageName = argv.package;
+        if (log)
+            log.info(`Using specified package: ${packageName}`);
+        if (!moduleNames.includes(packageName)) {
+            const errorMsg = `Package '${packageName}' not found. Available packages: ${moduleNames.join(', ')}`;
+            if (log) {
+                log.error(errorMsg);
+                return undefined;
+            }
+            else {
+                throw errors.NOT_FOUND({}, errorMsg);
+            }
+        }
+        return packageName;
+    }
+    // Interactive selection
+    const { package: selectedPackage } = await prompter.prompt(argv, [{
+            type: 'autocomplete',
+            name: 'package',
+            message: `Choose a package to ${operationName}`,
+            options: moduleNames,
+            required: true
+        }]);
+    if (log)
+        log.info(`Selected package: ${selectedPackage}`);
+    return selectedPackage;
+}

package/index.d.ts

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import { CLIOptions } from 'inquirerer';
+import { createConstructiveCommandMap } from './commands';
+export { createConstructiveCommandMap };
+export { default as add } from './commands/add';
+export { default as adminUsers } from './commands/admin-users';
+export { default as analyze } from './commands/analyze';
+export { default as clear } from './commands/clear';
+export { default as deploy } from './commands/deploy';
+export { default as docker } from './commands/docker';
+export { default as env } from './commands/env';
+export { default as _export } from './commands/export';
+export { default as extension } from './commands/extension';
+export { default as install } from './commands/install';
+export { default as kill } from './commands/kill';
+export { default as migrate } from './commands/migrate';
+export { default as _package } from './commands/package';
+export { default as plan } from './commands/plan';
+export { default as remove } from './commands/remove';
+export { default as renameCmd } from './commands/rename';
+export { default as revert } from './commands/revert';
+export { default as tag } from './commands/tag';
+export { default as verify } from './commands/verify';
+export * from './utils';
+export declare const options: Partial<CLIOptions>;

package/index.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+"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 __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.options = exports.verify = exports.tag = exports.revert = exports.renameCmd = exports.remove = exports.plan = exports._package = exports.migrate = exports.kill = exports.install = exports.extension = exports._export = exports.env = exports.docker = exports.deploy = exports.clear = exports.analyze = exports.adminUsers = exports.add = exports.createConstructiveCommandMap = void 0;
+const fs_1 = require("fs");
+const inquirerer_1 = require("inquirerer");
+const path_1 = require("path");
+const commands_1 = require("./commands");
+Object.defineProperty(exports, "createConstructiveCommandMap", { enumerable: true, get: function () { return commands_1.createConstructiveCommandMap; } });
+var add_1 = require("./commands/add");
+Object.defineProperty(exports, "add", { enumerable: true, get: function () { return __importDefault(add_1).default; } });
+var admin_users_1 = require("./commands/admin-users");
+Object.defineProperty(exports, "adminUsers", { enumerable: true, get: function () { return __importDefault(admin_users_1).default; } });
+var analyze_1 = require("./commands/analyze");
+Object.defineProperty(exports, "analyze", { enumerable: true, get: function () { return __importDefault(analyze_1).default; } });
+var clear_1 = require("./commands/clear");
+Object.defineProperty(exports, "clear", { enumerable: true, get: function () { return __importDefault(clear_1).default; } });
+var deploy_1 = require("./commands/deploy");
+Object.defineProperty(exports, "deploy", { enumerable: true, get: function () { return __importDefault(deploy_1).default; } });
+var docker_1 = require("./commands/docker");
+Object.defineProperty(exports, "docker", { enumerable: true, get: function () { return __importDefault(docker_1).default; } });
+var env_1 = require("./commands/env");
+Object.defineProperty(exports, "env", { enumerable: true, get: function () { return __importDefault(env_1).default; } });
+var export_1 = require("./commands/export");
+Object.defineProperty(exports, "_export", { enumerable: true, get: function () { return __importDefault(export_1).default; } });
+var extension_1 = require("./commands/extension");
+Object.defineProperty(exports, "extension", { enumerable: true, get: function () { return __importDefault(extension_1).default; } });
+var install_1 = require("./commands/install");
+Object.defineProperty(exports, "install", { enumerable: true, get: function () { return __importDefault(install_1).default; } });
+var kill_1 = require("./commands/kill");
+Object.defineProperty(exports, "kill", { enumerable: true, get: function () { return __importDefault(kill_1).default; } });
+var migrate_1 = require("./commands/migrate");
+Object.defineProperty(exports, "migrate", { enumerable: true, get: function () { return __importDefault(migrate_1).default; } });
+var package_1 = require("./commands/package");
+Object.defineProperty(exports, "_package", { enumerable: true, get: function () { return __importDefault(package_1).default; } });
+var plan_1 = require("./commands/plan");
+Object.defineProperty(exports, "plan", { enumerable: true, get: function () { return __importDefault(plan_1).default; } });
+var remove_1 = require("./commands/remove");
+Object.defineProperty(exports, "remove", { enumerable: true, get: function () { return __importDefault(remove_1).default; } });
+var rename_1 = require("./commands/rename");
+Object.defineProperty(exports, "renameCmd", { enumerable: true, get: function () { return __importDefault(rename_1).default; } });
+var revert_1 = require("./commands/revert");
+Object.defineProperty(exports, "revert", { enumerable: true, get: function () { return __importDefault(revert_1).default; } });
+var tag_1 = require("./commands/tag");
+Object.defineProperty(exports, "tag", { enumerable: true, get: function () { return __importDefault(tag_1).default; } });
+var verify_1 = require("./commands/verify");
+Object.defineProperty(exports, "verify", { enumerable: true, get: function () { return __importDefault(verify_1).default; } });
+__exportStar(require("./utils"), exports);
+exports.options = {
+    minimistOpts: {
+        alias: {
+            v: 'version',
+            h: 'help'
+        }
+    }
+};
+if (require.main === module) {
+    if (process.argv.includes('--version') || process.argv.includes('-v')) {
+        const pkgPath = (0, path_1.join)(__dirname, 'package.json');
+        const pkg = JSON.parse((0, fs_1.readFileSync)(pkgPath, 'utf8'));
+        console.log(pkg.version);
+        process.exit(0);
+    }
+    const app = new inquirerer_1.CLI(commands_1.commands, exports.options);
+    app.run().then(() => {
+    }).catch(error => {
+        console.error('Unexpected error:', error);
+        process.exit(1);
+    });
+}

package/package.d.ts

@@ -0,0 +1 @@
+export declare function readAndParsePackageJson(): any;

package/package.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readAndParsePackageJson = readAndParsePackageJson;
+const fs_1 = require("fs");
+const path_1 = require("path");
+// need to search due to the dist/ folder and src/, etc.
+function findPackageJson(currentDir) {
+    const filePath = (0, path_1.join)(currentDir, 'package.json');
+    // Check if package.json exists in the current directory
+    if ((0, fs_1.existsSync)(filePath)) {
+        return filePath;
+    }
+    // Get the parent directory
+    const parentDir = (0, path_1.dirname)(currentDir);
+    // If reached the root directory, package.json is not found
+    if (parentDir === currentDir) {
+        throw new Error('package.json not found in any parent directory');
+    }
+    // Recursively look in the parent directory
+    return findPackageJson(parentDir);
+}
+function readAndParsePackageJson() {
+    // Start searching from the current directory
+    const pkgPath = findPackageJson(__dirname);
+    // Read and parse the package.json
+    const str = (0, fs_1.readFileSync)(pkgPath, 'utf8');
+    const pkg = JSON.parse(str);
+    return pkg;
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@constructive-io/cli",
+  "version": "0.0.2",
+  "description": "Platform for schemas, APIs, and application programming",
+  "main": "index.js",
+  "module": "esm/index.js",
+  "types": "index.d.ts",
+  "license": "SEE LICENSE IN LICENSE",
+  "publishConfig": {
+    "access": "public",
+    "directory": "dist"
+  },
+  "bin": {
+    "constructive": "index.js"
+  },
+  "scripts": {
+    "copy": "copyfiles -f ../../LICENSE README.md package.json dist",
+    "clean": "rimraf dist/**",
+    "prepack": "npm run build",
+    "build": "npm run clean; tsc -p tsconfig.json; tsc -p tsconfig.esm.json; npm run copy",
+    "build:dev": "npm run clean; tsc -p tsconfig.json --declarationMap; tsc -p tsconfig.esm.json; npm run copy",
+    "dev": "ts-node ./src/index.ts",
+    "lint": "eslint . --fix",
+    "test": "jest",
+    "test:watch": "jest --watch"
+  },
+  "devDependencies": {
+    "@types/glob": "^8.1.0",
+    "@types/js-yaml": "^4.0.9",
+    "@types/minimist": "^1.2.5",
+    "@types/node": "^20.12.7",
+    "@types/pg": "^8.15.2",
+    "@types/shelljs": "^0.8.16",
+    "glob": "^11.0.2",
+    "pg": "^8.16.0",
+    "ts-node": "^10.9.2"
+  },
+  "dependencies": {
+    "@launchql/core": "2.15.4",
+    "@launchql/env": "2.5.1",
+    "@launchql/logger": "1.1.6",
+    "@launchql/templatizer": "2.5.1",
+    "@launchql/types": "2.8.1",
+    "chalk": "^4.1.0",
+    "inquirerer": "^2.0.8",
+    "js-yaml": "^4.1.0",
+    "minimist": "^1.2.8",
+    "pg-cache": "1.4.2",
+    "pg-env": "1.1.3",
+    "shelljs": "^0.9.2"
+  },
+  "keywords": [
+    "cli",
+    "command-line",
+    "tool",
+    "postgres",
+    "postgresql",
+    "migration",
+    "package-manager",
+    "database",
+    "pg",
+    "pgsql"
+  ]
+}

package/utils/argv.d.ts

@@ -0,0 +1,46 @@
+import { ParsedArgs } from 'minimist';
+export declare const extractFirst: (argv: Partial<ParsedArgs>) => {
+    first: string;
+    newArgv: {
+        _: string[];
+        "--"?: string[] | undefined;
+    };
+};
+/**
+ * Common CLI argument validation and processing utilities
+ */
+export interface ValidatedArgv extends ParsedArgs {
+    cwd: string;
+    database?: string;
+    package?: string;
+    to?: string;
+    recursive?: boolean;
+    yes?: boolean;
+    tx?: boolean;
+    fast?: boolean;
+    logOnly?: boolean;
+    createdb?: boolean;
+    usePlan?: boolean;
+    cache?: boolean;
+    drop?: boolean;
+    all?: boolean;
+    summary?: boolean;
+    help?: boolean;
+    h?: boolean;
+}
+/**
+ * Validates and normalizes common CLI arguments
+ */
+export declare function validateCommonArgs(argv: Partial<ParsedArgs>): ValidatedArgv;
+/**
+ * Checks if required flags are provided when certain conditions are met
+ */
+export declare function validateFlagDependencies(argv: ValidatedArgv): void;
+/**
+ * Logs the effective CLI arguments for debugging
+ */
+export declare function logEffectiveArgs(argv: ValidatedArgv, commandName: string): void;
+/**
+ * Constructs a deployment target string from package and to arguments
+ */
+export declare function constructTarget(argv: ValidatedArgv, packageName?: string): string | undefined;

package/utils/argv.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractFirst = void 0;
+exports.validateCommonArgs = validateCommonArgs;
+exports.validateFlagDependencies = validateFlagDependencies;
+exports.logEffectiveArgs = logEffectiveArgs;
+exports.constructTarget = constructTarget;
+const logger_1 = require("@launchql/logger");
+const log = new logger_1.Logger('argv-utils');
+const extractFirst = (argv) => {
+    const first = argv._?.[0];
+    const newArgv = {
+        ...argv,
+        _: argv._?.slice(1) ?? []
+    };
+    return { first, newArgv };
+};
+exports.extractFirst = extractFirst;
+/**
+ * Validates and normalizes common CLI arguments
+ */
+function validateCommonArgs(argv) {
+    const validated = {
+        ...argv,
+        cwd: argv.cwd || process.cwd(),
+        _: argv._ || []
+    };
+    const booleanFlags = ['recursive', 'yes', 'tx', 'fast', 'logOnly', 'createdb', 'usePlan', 'cache', 'drop', 'all', 'summary', 'help', 'h'];
+    for (const flag of booleanFlags) {
+        if (argv[flag] !== undefined && typeof argv[flag] !== 'boolean') {
+            log.warn(`--${flag} flag should be boolean, converting to true`);
+            validated[flag] = true;
+        }
+    }
+    const stringFlags = ['package', 'to', 'database'];
+    for (const flag of stringFlags) {
+        if (argv[flag] !== undefined && typeof argv[flag] !== 'string') {
+            log.warn(`--${flag} should be a string, converting`);
+            validated[flag] = String(argv[flag]);
+        }
+    }
+    return validated;
+}
+/**
+ * Checks if required flags are provided when certain conditions are met
+ */
+function validateFlagDependencies(argv) {
+    if (argv.to && !argv.package && !argv.recursive) {
+        log.warn('--to flag provided without --package or --recursive. Target may not work as expected.');
+    }
+    if (argv.package && argv.recursive) {
+        if (argv.package.includes(':')) {
+            log.warn('--package should not contain ":" when using --recursive. Use --to for target specification.');
+        }
+    }
+}
+/**
+ * Logs the effective CLI arguments for debugging
+ */
+function logEffectiveArgs(argv, commandName) {
+    const relevantArgs = {
+        cwd: argv.cwd,
+        database: argv.database,
+        package: argv.package,
+        to: argv.to,
+        recursive: argv.recursive,
+        yes: argv.yes,
+        tx: argv.tx,
+        fast: argv.fast,
+        logOnly: argv.logOnly,
+        createdb: argv.createdb,
+        usePlan: argv.usePlan,
+        cache: argv.cache,
+        drop: argv.drop,
+        all: argv.all,
+        summary: argv.summary
+    };
+    const definedArgs = Object.fromEntries(Object.entries(relevantArgs).filter(([_, value]) => value !== undefined));
+    if (Object.keys(definedArgs).length > 1) { // More than just cwd
+        log.debug(`${commandName} effective arguments:`, definedArgs);
+    }
+}
+/**
+ * Constructs a deployment target string from package and to arguments
+ */
+function constructTarget(argv, packageName) {
+    if (packageName && argv.to) {
+        return `${packageName}:${argv.to}`;
+    }
+    else if (packageName) {
+        return packageName;
+    }
+    else if (argv.package && argv.to) {
+        return `${argv.package}:${argv.to}`;
+    }
+    else if (argv.package) {
+        return argv.package;
+    }
+    return undefined;
+}

package/utils/cli-error.d.ts

@@ -0,0 +1,8 @@
+import { LaunchQLError } from '@launchql/types';
+/**
+ * CLI error utility that logs error information and exits with code 1.
+ * Provides consistent error handling and user experience across all CLI commands.
+ *
+ * IMPORTANT: This function properly cleans up PostgreSQL connections before exiting.
+ */
+export declare const cliExitWithError: (error: LaunchQLError | Error | string, context?: Record<string, any>) => Promise<never>;

package/utils/cli-error.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cliExitWithError = void 0;
+const logger_1 = require("@launchql/logger");
+const types_1 = require("@launchql/types");
+const pg_cache_1 = require("pg-cache");
+const log = new logger_1.Logger('cli');
+/**
+ * CLI error utility that logs error information and exits with code 1.
+ * Provides consistent error handling and user experience across all CLI commands.
+ *
+ * IMPORTANT: This function properly cleans up PostgreSQL connections before exiting.
+ */
+const cliExitWithError = async (error, context) => {
+    if (error instanceof types_1.LaunchQLError) {
+        // For LaunchQLError instances, use structured logging
+        log.error(`Error: ${error.message}`);
+        // Log additional context if available
+        if (error.context && Object.keys(error.context).length > 0) {
+            log.debug('Error context:', error.context);
+        }
+        // Log any additional context provided
+        if (context) {
+            log.debug('Additional context:', context);
+        }
+    }
+    else if (error instanceof Error) {
+        // For generic Error instances
+        log.error(`Error: ${error.message}`);
+        if (context) {
+            log.debug('Context:', context);
+        }
+    }
+    else if (typeof error === 'string') {
+        // For simple string messages
+        log.error(`Error: ${error}`);
+        if (context) {
+            log.debug('Context:', context);
+        }
+    }
+    // Perform cleanup before exiting
+    try {
+        await (0, pg_cache_1.teardownPgPools)();
+        log.debug('Database connections cleaned up');
+    }
+    catch (cleanupError) {
+        log.warn('Failed to cleanup database connections:', cleanupError);
+        // Don't let cleanup errors prevent the exit
+    }
+    process.exit(1);
+};
+exports.cliExitWithError = cliExitWithError;

package/utils/database.d.ts

@@ -0,0 +1,21 @@
+import { Inquirerer } from 'inquirerer';
+import { ParsedArgs } from 'minimist';
+export interface DatabaseSelectionOptions {
+    message?: string;
+    excludeTemplates?: boolean;
+    excludePostgres?: boolean;
+    excludeSystemDbs?: boolean;
+    multiple?: boolean;
+}
+/**
+ * Get list of available databases from PostgreSQL
+ */
+export declare function getAvailableDatabases(options?: DatabaseSelectionOptions): Promise<string[]>;
+/**
+ * Prompt user to select a database
+ */
+export declare function selectDatabase(argv: Partial<ParsedArgs>, prompter: Inquirerer, options?: DatabaseSelectionOptions): Promise<string>;
+/**
+ * Get target database with fallback to environment
+ */
+export declare function getTargetDatabase(argv: Partial<ParsedArgs>, prompter: Inquirerer, options?: DatabaseSelectionOptions): Promise<string>;

package/utils/database.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAvailableDatabases = getAvailableDatabases;
+exports.selectDatabase = selectDatabase;
+exports.getTargetDatabase = getTargetDatabase;
+const pg_cache_1 = require("pg-cache");
+const pg_env_1 = require("pg-env");
+/**
+ * Get list of available databases from PostgreSQL
+ */
+async function getAvailableDatabases(options = {}) {
+    const { excludeTemplates = true, excludePostgres = true, excludeSystemDbs = true } = options;
+    const db = await (0, pg_cache_1.getPgPool)({
+        database: 'postgres'
+    });
+    let query = `
+    SELECT datname FROM pg_catalog.pg_database
+    WHERE 1=1
+  `;
+    if (excludeTemplates) {
+        query += ` AND datistemplate = FALSE`;
+    }
+    if (excludePostgres) {
+        query += ` AND datname NOT IN ('postgres')`;
+    }
+    if (excludeSystemDbs) {
+        query += ` AND datname !~ '^pg_'`;
+    }
+    query += ` ORDER BY datname`;
+    const result = await db.query(query);
+    return result.rows.map((row) => row.datname);
+}
+/**
+ * Prompt user to select a database
+ */
+async function selectDatabase(argv, prompter, options = {}) {
+    const { message = 'Select target database', multiple = false } = options;
+    // Check if database is already specified
+    if (!multiple && (argv.db || argv.database)) {
+        return argv.db || argv.database;
+    }
+    // Get available databases
+    const databases = await getAvailableDatabases(options);
+    if (databases.length === 0) {
+        throw new Error('No databases found');
+    }
+    // If only one database and not forcing selection, use it
+    if (!multiple && databases.length === 1 && !argv.interactive) {
+        return databases[0];
+    }
+    // Prompt for selection
+    const answer = await prompter.prompt(argv, [
+        {
+            type: multiple ? 'checkbox' : 'autocomplete',
+            name: 'database',
+            message,
+            options: databases,
+            required: true
+        }
+    ]);
+    return answer.database;
+}
+/**
+ * Get target database with fallback to environment
+ */
+async function getTargetDatabase(argv, prompter, options = {}) {
+    // If database is specified in args, use it
+    if (argv.db || argv.database) {
+        return argv.db || argv.database;
+    }
+    // Try to select from available databases
+    try {
+        return await selectDatabase(argv, prompter, options);
+    }
+    catch (error) {
+        // Fall back to environment database
+        const pgEnv = (0, pg_env_1.getPgEnvOptions)();
+        if (pgEnv.database) {
+            return pgEnv.database;
+        }
+        throw new Error('No database specified and no default database found');
+    }
+}

package/utils/deployed-changes.d.ts

@@ -0,0 +1,4 @@
+import { Logger } from '@launchql/logger';
+import { Inquirerer } from 'inquirerer';
+export declare function selectDeployedChange(database: string, argv: Partial<Record<string, any>>, prompter: Inquirerer, log: Logger, action?: 'revert' | 'verify'): Promise<string | undefined>;
+export declare function selectDeployedPackage(database: string, argv: Partial<Record<string, any>>, prompter: Inquirerer, log: Logger, action?: 'revert' | 'verify'): Promise<string | undefined>;