@constructive-io/cli 0.0.2

package/commands/env.js

@@ -0,0 +1,124 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const pg_env_1 = require("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 = {
+    ...pg_env_1.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 = (0, child_process_1.spawn)(command, args, {
+            env,
+            stdio: 'inherit',
+            shell: false
+        });
+        child.on('error', (error) => {
+            reject(error);
+        });
+        child.on('close', (code) => {
+            resolve(code ?? 0);
+        });
+    });
+}
+exports.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);
+    }
+};

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

@@ -0,0 +1,129 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const env_1 = require("@launchql/env");
+const types_1 = require("@launchql/types");
+const path_1 = require("path");
+const pg_cache_1 = require("pg-cache");
+const exportUsageText = `
+Export Command:
+
+  constructive export [OPTIONS]
+
+  Export database migrations from existing databases.
+
+Options:
+  --help, -h              Show this help message
+  --author <name>         Project author (default: from git config)
+  --extensionName <name>  Extension name
+  --metaExtensionName <name>  Meta extension name (default: svc)
+  --cwd <directory>       Working directory (default: current directory)
+
+Examples:
+  constructive export              Export migrations from selected database
+`;
+exports.default = async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(exportUsageText);
+        process.exit(0);
+    }
+    const { email, username } = (0, types_1.getGitConfigInfo)();
+    const cwd = argv.cwd ?? process.cwd();
+    const project = new core_1.LaunchQLPackage(cwd);
+    project.ensureWorkspace();
+    project.resetCwd(project.workspacePath);
+    const options = (0, env_1.getEnvOptions)();
+    const db = await (0, pg_cache_1.getPgPool)({
+        database: 'postgres'
+    });
+    const databasesResult = await db.query(`
+    SELECT datname FROM pg_catalog.pg_database
+    WHERE datistemplate = FALSE AND datname NOT IN ('postgres')
+      AND datname !~ '^pg_';
+  `);
+    let databases;
+    ({ databases } = await prompter.prompt(argv, [
+        {
+            type: 'checkbox',
+            name: 'databases',
+            message: 'Select a database',
+            options: databasesResult.rows.map(row => row.datname),
+            required: true
+        }
+    ]));
+    const dbname = databases.filter(d => d.selected).map(d => d.value)[0];
+    const selectedDb = await (0, pg_cache_1.getPgPool)({
+        database: dbname
+    });
+    const dbsResult = await selectedDb.query(`
+    SELECT id, name FROM collections_public.database;
+  `);
+    let database_ids;
+    ({ database_ids } = await prompter.prompt({}, [
+        {
+            type: 'checkbox',
+            name: 'database_ids',
+            message: 'Select database_id(s)',
+            options: dbsResult.rows.map(db => db.name),
+            required: true
+        }
+    ]));
+    const dbInfo = {
+        dbname,
+        database_ids: database_ids.map(did => dbsResult.rows.find(db => db.name === did.name).id)
+    };
+    const { author, extensionName, metaExtensionName } = await prompter.prompt(argv, [
+        {
+            type: 'text',
+            name: 'author',
+            message: 'Project author',
+            default: `${username} <${email}>`,
+            required: true
+        },
+        {
+            type: 'text',
+            name: 'extensionName',
+            message: 'Extension name',
+            default: dbInfo.database_ids[0],
+            required: true
+        },
+        {
+            type: 'text',
+            name: 'metaExtensionName',
+            message: 'Meta extension name',
+            default: 'svc',
+            required: true
+        }
+    ]);
+    const schemasResult = await selectedDb.query(`SELECT * FROM collections_public.schema WHERE database_id = $1`, [dbInfo.database_ids[0]]);
+    const { schema_names } = await prompter.prompt({}, [
+        {
+            type: 'checkbox',
+            name: 'schema_names',
+            message: 'Select schema_name(s)',
+            options: schemasResult.rows.map(s => s.schema_name),
+            default: schemasResult.rows.map(s => s.schema_name),
+            required: true
+        }
+    ]);
+    const outdir = (0, path_1.resolve)(project.workspacePath, 'packages/');
+    await (0, core_1.exportMigrations)({
+        project,
+        options,
+        dbInfo,
+        author,
+        schema_names,
+        outdir,
+        extensionName,
+        metaExtensionName
+    });
+    console.log(`
+
+        |||
+       (o o)
+   ooO--(_)--Ooo-
+
+✨ finished!
+`);
+};

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

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const extensionUsageText = `
+Extension Command:
+
+  constructive extension [OPTIONS]
+
+  Manage module dependencies.
+
+Options:
+  --help, -h              Show this help message
+  --cwd <directory>       Working directory (default: current directory)
+
+Examples:
+  constructive extension           Manage dependencies for current module
+`;
+exports.default = async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(extensionUsageText);
+        process.exit(0);
+    }
+    const { cwd = process.cwd() } = argv;
+    const project = new core_1.LaunchQLPackage(cwd);
+    if (!project.isInModule()) {
+        throw new Error('You must run this command inside a LaunchQL module.');
+    }
+    const info = project.getModuleInfo();
+    const installed = project.getRequiredModules();
+    const available = project.getAvailableModules();
+    const filtered = available.filter(name => name !== info.extname);
+    const questions = [
+        {
+            name: 'extensions',
+            message: 'Which modules does this one depend on?',
+            type: 'checkbox',
+            allowCustomOptions: true,
+            options: filtered,
+            default: installed
+        }
+    ];
+    const answers = await prompter.prompt(argv, questions);
+    const selected = answers.extensions
+        .filter(opt => opt.selected)
+        .map(opt => opt.name);
+    project.setModuleDependencies(selected);
+};

package/commands/init/index.d.ts

@@ -0,0 +1,7 @@
+import { CLIOptions, Inquirerer } from 'inquirerer';
+declare const _default: (argv: Partial<Record<string, any>>, prompter: Inquirerer, _options: CLIOptions) => Promise<{
+    [x: string]: any;
+} | {
+    cwd: string;
+}>;
+export default _default;

package/commands/init/index.js

@@ -0,0 +1,47 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const module_1 = __importDefault(require("./module"));
+const workspace_1 = __importDefault(require("./workspace"));
+const initUsageText = `
+Init Command:
+
+  constructive init [OPTIONS]
+
+  Initialize constructive workspace or module.
+
+Options:
+  --help, -h              Show this help message
+  --workspace             Initialize workspace instead of module
+  --cwd <directory>       Working directory (default: current directory)
+  --repo <repo>           Use templates from GitHub repository (e.g., owner/repo)
+  --template-path <path>   Use templates from local path
+  --from-branch <branch>   Specify branch when using --repo (default: main)
+
+Examples:
+  constructive init                                  Initialize new module in existing workspace
+  constructive init --workspace                       Initialize new workspace
+  constructive init --repo owner/repo                Use templates from GitHub repository
+  constructive init --template-path ./custom-templates Use templates from local path
+  constructive init --repo owner/repo --from-branch develop  Use specific branch
+`;
+exports.default = async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(initUsageText);
+        process.exit(0);
+    }
+    return handlePromptFlow(argv, prompter);
+};
+async function handlePromptFlow(argv, prompter) {
+    const { workspace } = argv;
+    switch (workspace) {
+        case true:
+            return (0, workspace_1.default)(argv, prompter);
+        case false:
+        default:
+            return (0, module_1.default)(argv, prompter);
+    }
+}

package/commands/init/module.d.ts

@@ -0,0 +1,4 @@
+import { Inquirerer } from 'inquirerer';
+export default function runModuleSetup(argv: Partial<Record<string, any>>, prompter: Inquirerer): Promise<{
+    [x: string]: any;
+}>;

package/commands/init/module.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = runModuleSetup;
+const core_1 = require("@launchql/core");
+const logger_1 = require("@launchql/logger");
+const types_1 = require("@launchql/types");
+const log = new logger_1.Logger('module-init');
+async function runModuleSetup(argv, prompter) {
+    const { email, username } = (0, types_1.getGitConfigInfo)();
+    const { cwd = process.cwd() } = argv;
+    const project = new core_1.LaunchQLPackage(cwd);
+    if (!project.workspacePath) {
+        log.error('Not inside a LaunchQL workspace.');
+        throw types_1.errors.NOT_IN_WORKSPACE({});
+    }
+    if (!project.isInsideAllowedDirs(cwd) && !project.isInWorkspace() && !project.isParentOfAllowedDirs(cwd)) {
+        log.error('You must be inside the workspace root or a parent directory of modules (like packages/).');
+        throw types_1.errors.NOT_IN_WORKSPACE_MODULE({});
+    }
+    const availExtensions = project.getAvailableModules();
+    const moduleQuestions = [
+        {
+            name: 'MODULENAME',
+            message: 'Enter the module name',
+            required: true,
+            type: 'text',
+        },
+        {
+            name: 'extensions',
+            message: 'Which extensions?',
+            options: availExtensions,
+            type: 'checkbox',
+            allowCustomOptions: true,
+            required: true,
+        },
+    ];
+    const answers = await prompter.prompt(argv, moduleQuestions);
+    const modName = (0, core_1.sluggify)(answers.MODULENAME);
+    const extensions = answers.extensions
+        .filter((opt) => opt.selected)
+        .map((opt) => opt.name);
+    // Determine template source
+    let templateSource;
+    if (argv.repo) {
+        templateSource = {
+            type: 'github',
+            path: argv.repo,
+            branch: argv.fromBranch
+        };
+        log.info(`Loading templates from GitHub repository: ${argv.repo}`);
+    }
+    else if (argv.templatePath) {
+        templateSource = {
+            type: 'local',
+            path: argv.templatePath
+        };
+        log.info(`Loading templates from local path: ${argv.templatePath}`);
+    }
+    project.initModule({
+        ...argv,
+        ...answers,
+        name: modName,
+        // @ts-ignore
+        USERFULLNAME: username,
+        USEREMAIL: email,
+        extensions,
+        templateSource
+    });
+    log.success(`Initialized module: ${modName}`);
+    return { ...argv, ...answers };
+}

package/commands/init/workspace.d.ts

@@ -0,0 +1,4 @@
+import { Inquirerer } from 'inquirerer';
+export default function runWorkspaceSetup(argv: Partial<Record<string, any>>, prompter: Inquirerer): Promise<{
+    cwd: string;
+}>;

package/commands/init/workspace.js

@@ -0,0 +1,52 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = runWorkspaceSetup;
+const core_1 = require("@launchql/core");
+const logger_1 = require("@launchql/logger");
+// @ts-ignore - TypeScript module resolution issue with @launchql/templatizer
+const templatizer_1 = require("@launchql/templatizer");
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const log = new logger_1.Logger('workspace-init');
+async function runWorkspaceSetup(argv, prompter) {
+    const workspaceQuestions = [
+        {
+            name: 'name',
+            message: 'Enter workspace name',
+            required: true,
+            type: 'text',
+        }
+    ];
+    const answers = await prompter.prompt(argv, workspaceQuestions);
+    const { cwd } = argv;
+    const targetPath = path_1.default.join(cwd, (0, core_1.sluggify)(answers.name));
+    (0, fs_1.mkdirSync)(targetPath, { recursive: true });
+    log.success(`Created workspace directory: ${targetPath}`);
+    // Determine template source
+    let templates = templatizer_1.workspaceTemplate;
+    if (argv.repo) {
+        const source = {
+            type: 'github',
+            path: argv.repo,
+            branch: argv.fromBranch
+        };
+        log.info(`Loading templates from GitHub repository: ${argv.repo}`);
+        const compiledTemplates = (0, templatizer_1.loadTemplates)(source, 'workspace');
+        templates = compiledTemplates.map((t) => t.render);
+    }
+    else if (argv.templatePath) {
+        const source = {
+            type: 'local',
+            path: argv.templatePath
+        };
+        log.info(`Loading templates from local path: ${argv.templatePath}`);
+        const compiledTemplates = (0, templatizer_1.loadTemplates)(source, 'workspace');
+        templates = compiledTemplates.map((t) => t.render);
+    }
+    (0, templatizer_1.writeRenderedTemplates)(templates, targetPath, { ...argv, ...answers });
+    log.success('Workspace templates rendered.');
+    return { ...argv, ...answers, cwd: targetPath };
+}

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

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const core_1 = require("@launchql/core");
+const installUsageText = `
+Install Command:
+
+  constructive install <package>...
+
+  Install database modules into current module.
+
+Arguments:
+  package                 One or more package names to install
+
+Options:
+  --help, -h              Show this help message
+  --cwd <directory>       Working directory (default: current directory)
+
+Examples:
+  constructive install @pgpm/base32                    Install single package
+  constructive install @pgpm/base32 @pgpm/utils   Install multiple packages
+`;
+exports.default = async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(installUsageText);
+        process.exit(0);
+    }
+    const { cwd = process.cwd() } = argv;
+    const project = new core_1.LaunchQLPackage(cwd);
+    if (!project.isInModule()) {
+        throw new Error('You must run this command inside a LaunchQL module.');
+    }
+    if (argv._.length === 0) {
+        throw new Error('You must provide a package name to install, e.g. `@pgpm/base32`');
+    }
+    await project.installModules(...argv._);
+};

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

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const logger_1 = require("@launchql/logger");
+const pg_cache_1 = require("pg-cache");
+const log = new logger_1.Logger('db-kill');
+const killUsageText = `
+Kill Command:
+
+  constructive kill [OPTIONS]
+
+  Terminate database connections and optionally drop databases.
+
+Options:
+  --help, -h              Show this help message
+  --drop                  Drop databases after killing connections (default: true)
+  --no-drop               Only kill connections, don't drop databases
+  --pattern <pattern>     Pattern to match database names (supports SQL LIKE syntax)
+  --cwd <directory>       Working directory (default: current directory)
+
+Examples:
+  constructive kill                Kill connections and drop selected databases (interactive)
+  constructive kill --no-drop      Only kill connections, preserve databases (interactive)
+  constructive kill --pattern test_%   Kill connections to databases matching 'test_%' pattern
+  constructive kill --pattern %dev --no-drop  Kill connections to databases ending with 'dev' but don't drop
+`;
+exports.default = async (argv, prompter, _options) => {
+    // Show usage if explicitly requested
+    if (argv.help || argv.h) {
+        console.log(killUsageText);
+        process.exit(0);
+    }
+    const db = await (0, pg_cache_1.getPgPool)({
+        database: 'postgres'
+    });
+    let selectedDbNames;
+    if (argv.pattern) {
+        // Pattern mode: automatically find databases matching the pattern
+        const databasesResult = await db.query(`
+      SELECT datname FROM pg_catalog.pg_database
+      WHERE datistemplate = FALSE AND datname NOT IN ('postgres')
+        AND datname !~ '^pg_' AND datname LIKE $1;
+    `, [argv.pattern]);
+        if (!databasesResult.rows.length) {
+            log.info(`ℹ️  No databases found matching pattern "${argv.pattern}". Exiting.`);
+            return;
+        }
+        selectedDbNames = databasesResult.rows.map(row => row.datname);
+        log.info(`🎯 Found ${selectedDbNames.length} database(s) matching pattern "${argv.pattern}": ${selectedDbNames.join(', ')}`);
+    }
+    else {
+        // Interactive mode: prompt user to select databases
+        const databasesResult = await db.query(`
+      SELECT datname FROM pg_catalog.pg_database
+      WHERE datistemplate = FALSE AND datname NOT IN ('postgres')
+        AND datname !~ '^pg_';
+    `);
+        if (!databasesResult.rows.length) {
+            log.info('ℹ️  No databases found to process. Exiting.');
+            return;
+        }
+        let databases;
+        ({ databases } = await prompter.prompt(argv, [
+            {
+                type: 'checkbox',
+                name: 'databases',
+                message: 'Select database(s) to terminate connections and optionally drop',
+                options: databasesResult.rows.map(row => row.datname),
+                required: true
+            }
+        ]));
+        selectedDbNames = databases.filter(d => d.selected).map(d => d.value);
+    }
+    const actionText = argv.drop === false ? 'kill connections to' : 'kill connections and DROP';
+    const patternText = argv.pattern ? ` (matched by pattern "${argv.pattern}")` : '';
+    const { yes } = await prompter.prompt(argv, [
+        {
+            type: 'confirm',
+            name: 'yes',
+            message: `Are you sure you want to ${actionText}: ${selectedDbNames.join(', ')}${patternText}?`,
+            default: false
+        }
+    ]);
+    if (!yes) {
+        log.info('❌ Aborted. No actions were taken.');
+        return;
+    }
+    for (const dbname of selectedDbNames) {
+        const killResult = await db.query(`
+      SELECT pg_terminate_backend(pid)
+      FROM pg_stat_activity
+      WHERE datname = $1 AND pid <> pg_backend_pid();
+      `, [dbname]);
+        log.warn(`💀 Terminated ${killResult.rowCount} connection(s) to "${dbname}".`);
+        if (argv.drop === false) {
+            log.info(`⚠️  Skipping DROP for "${dbname}" due to --no-drop flag.`);
+            continue;
+        }
+        try {
+            await db.query(`DROP DATABASE "${dbname}";`);
+            log.success(`🗑️  Dropped database "${dbname}" successfully.`);
+        }
+        catch (err) {
+            log.error(`❌ Failed to drop "${dbname}": ${err.message}`);
+        }
+    }
+    log.success('✅ Done processing databases.');
+};

package/commands/migrate/deps.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;