relq 1.0.0

package/dist/cjs/cli/index.cjs

@@ -0,0 +1,275 @@
+#!/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 __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 init_1 = require("./commands/init.cjs");
+const pull_1 = require("./commands/pull.cjs");
+const push_1 = require("./commands/push.cjs");
+const generate_1 = require("./commands/generate.cjs");
+const introspect_1 = require("./commands/introspect.cjs");
+const sync_1 = require("./commands/sync.cjs");
+const status_1 = require("./commands/status.cjs");
+const diff_1 = require("./commands/diff.cjs");
+const log_1 = require("./commands/log.cjs");
+const rollback_1 = require("./commands/rollback.cjs");
+const commit_1 = require("./commands/commit.cjs");
+const fetch_1 = require("./commands/fetch.cjs");
+const add_1 = require("./commands/add.cjs");
+const import_1 = require("./commands/import.cjs");
+const export_1 = require("./commands/export.cjs");
+const VERSION = '1.1.0';
+function parseArgs(argv) {
+    const args = [];
+    const flags = {};
+    let command = '';
+    for (let i = 2; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg.startsWith('--')) {
+            const eqIndex = arg.indexOf('=');
+            if (eqIndex > -1) {
+                flags[arg.slice(2, eqIndex)] = arg.slice(eqIndex + 1);
+            }
+            else {
+                flags[arg.slice(2)] = true;
+            }
+        }
+        else if (arg.startsWith('-') && arg.length === 2) {
+            const flag = arg.slice(1);
+            const nextArg = argv[i + 1];
+            if (nextArg && !nextArg.startsWith('-')) {
+                flags[flag] = nextArg;
+                i++;
+            }
+            else {
+                flags[flag] = true;
+            }
+        }
+        else if (arg.startsWith('-') && arg.length > 2) {
+            const combined = arg.slice(1);
+            const nextArg = argv[i + 1];
+            if (nextArg && !nextArg.startsWith('-')) {
+                flags[combined] = nextArg;
+                i++;
+            }
+            else {
+                for (const char of combined) {
+                    flags[char] = true;
+                }
+            }
+        }
+        else if (!command) {
+            command = arg;
+        }
+        else {
+            args.push(arg);
+        }
+    }
+    return { command, args, flags };
+}
+function printHelp() {
+    console.log(`
+Relq CLI v${VERSION} - Database Schema Version Control
+
+Usage: relq <command> [options]
+
+Schema Commands:
+  init                Initialize relq for your project
+  status [--check]    Show current schema state
+  add <table>|.       Stage changes for commit
+  commit -m "msg"     Record schema snapshot
+  log [--oneline]     Show commit history
+
+Sync Commands:
+  fetch               Download remote commits
+  pull [--force]      Pull schema from database
+  push [--dry-run]    Push commits to database
+  sync                Pull + push in one command
+
+Other Commands:
+  diff [--sql]        Show schema differences
+  generate            Generate TypeScript types
+  introspect          Parse database schema
+  import <sql-file>   Import SQL file to schema
+  export [file]       Export schema to SQL file
+
+Options:
+  --help, -h          Show this help
+  --version, -v       Show version
+  --config <path>     Config file path
+  --dry-run           Preview changes
+  --force             Skip confirmations
+  --force             Skip confirmation prompts
+
+Examples:
+  relq status
+  relq diff --sql
+  relq generate -m "add users table"
+  relq push
+  relq rollback 2
+  relq sync
+
+Environment Variables:
+  DATABASE_CONNECTION_STRING    Full connection URL
+  DATABASE_HOST/PORT/NAME       Individual connection parts
+  DATABASE_USER/PASSWORD        Credentials
+`);
+}
+function printVersion() {
+    console.log(`relq v${VERSION}`);
+}
+function requiresConfig(command) {
+    return !['init', 'introspect', 'import', 'help', 'version'].includes(command);
+}
+function requiresDbConnection(command, flags) {
+    const alwaysNeedDb = ['pull', 'push', 'fetch', 'introspect'];
+    if (alwaysNeedDb.includes(command))
+        return true;
+    if (command === 'export' && flags['db'])
+        return true;
+    return false;
+}
+async function main() {
+    const { command, args, flags } = parseArgs(process.argv);
+    if (flags.help || flags.h || command === 'help') {
+        printHelp();
+        process.exit(0);
+    }
+    if (flags.version || flags.v || command === 'version') {
+        printVersion();
+        process.exit(0);
+    }
+    if (!command) {
+        console.error('Error: No command provided\n');
+        printHelp();
+        process.exit(1);
+    }
+    let config = null;
+    if (requiresConfig(command)) {
+        const configPath = flags.config;
+        try {
+            const { loadConfigWithEnv, findConfigFile } = await Promise.resolve().then(() => __importStar(require("./utils/config-loader.cjs")));
+            const foundConfig = configPath || findConfigFile();
+            if (!foundConfig) {
+                console.error('Error: relq.config.ts not found.');
+                console.error('Run "relq init" to create one or use --config to specify a path.');
+                process.exit(1);
+            }
+            config = await loadConfigWithEnv(configPath);
+            if (requiresDbConnection(command, flags) && !config.connection?.host && !config.connection?.url) {
+                console.error('Error: No database connection configured.');
+                console.error('Run "relq init" or set DATABASE_* environment variables.');
+                process.exit(1);
+            }
+        }
+        catch (error) {
+            console.error('Error loading config:', error instanceof Error ? error.message : error);
+            process.exit(1);
+        }
+    }
+    const context = { config, args, flags };
+    try {
+        switch (command) {
+            case 'init':
+                await (0, init_1.initCommand)(context);
+                break;
+            case 'status':
+                await (0, status_1.statusCommand)(context);
+                break;
+            case 'diff':
+                await (0, diff_1.diffCommand)(context);
+                break;
+            case 'pull':
+                await (0, pull_1.pullCommand)(context);
+                break;
+            case 'commit':
+                await (0, commit_1.commitCommand)(context);
+                break;
+            case 'add':
+                await (0, add_1.addCommand)(context);
+                break;
+            case 'generate':
+                await (0, generate_1.generateCommand)(context);
+                break;
+            case 'push':
+                await (0, push_1.pushCommand)(context);
+                break;
+            case 'history':
+            case 'log':
+                await (0, log_1.logCommand)(context);
+                break;
+            case 'fetch':
+                await (0, fetch_1.fetchCommand)(context);
+                break;
+            case 'rollback':
+            case 'revert':
+                await (0, rollback_1.rollbackCommand)(context);
+                break;
+            case 'introspect':
+                await (0, introspect_1.introspectCommand)(context);
+                break;
+            case 'sync':
+                await (0, sync_1.syncCommand)(context);
+                break;
+            case 'import':
+                await (0, import_1.importCommand)(args[0], {
+                    output: flags.output,
+                    includeFunctions: Boolean(flags['include-functions']),
+                    includeTriggers: Boolean(flags['include-triggers']),
+                    force: Boolean(flags.force),
+                    dryRun: Boolean(flags['dry-run']),
+                    theirs: Boolean(flags.theirs),
+                    ours: Boolean(flags.ours),
+                    abort: Boolean(flags.abort),
+                });
+                break;
+            case 'export':
+                await (0, export_1.exportCommand)(context);
+                break;
+            case 'migrate':
+                console.log('Note: "migrate" is deprecated, use "push" instead.\n');
+                await (0, push_1.pushCommand)(context);
+                break;
+            default:
+                console.error(`Error: Unknown command "${command}"\n`);
+                printHelp();
+                process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}
+main().catch(console.error);