relq 1.0.0

package/dist/esm/cli/commands/rollback.js

@@ -0,0 +1,133 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as readline from 'readline';
+import { requireValidConfig } from "../utils/config-loader.js";
+import { getConnectionDescription } from "../utils/env-loader.js";
+const colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    cyan: '\x1b[36m',
+};
+function parseMigration(content) {
+    const upMatch = content.match(/--\s*UP\s*\n([\s\S]*?)(?=--\s*DOWN|$)/i);
+    const downMatch = content.match(/--\s*DOWN\s*\n([\s\S]*?)$/i);
+    return {
+        up: upMatch?.[1]?.trim() || '',
+        down: downMatch?.[1]?.trim() || '',
+    };
+}
+function askConfirm(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(`${question} [y/N]: `, (answer) => {
+            rl.close();
+            resolve(answer.trim().toLowerCase() === 'y');
+        });
+    });
+}
+export async function rollbackCommand(context) {
+    const { config, args, flags } = context;
+    if (!config) {
+        console.error('Error: No configuration found.');
+        process.exit(1);
+    }
+    requireValidConfig(config);
+    const connection = config.connection;
+    const migrationsDir = config.migrations?.directory || './migrations';
+    const tableName = config.migrations?.tableName || '_relq_migrations';
+    const count = parseInt(args[0]) || 1;
+    const dryRun = flags['dry-run'] === true;
+    const force = flags['force'] === true;
+    console.log(`${colors.bold}Rolling back ${count} migration(s)...${colors.reset}`);
+    console.log(`   Connection: ${getConnectionDescription(connection)}`);
+    console.log('');
+    try {
+        const { Pool } = await import("../../addon/pg.js");
+        const pool = new Pool({
+            host: connection.host,
+            port: connection.port || 5432,
+            database: connection.database,
+            user: connection.user,
+            password: connection.password,
+            connectionString: connection.url,
+        });
+        try {
+            const result = await pool.query(`
+                SELECT name FROM "${tableName}" 
+                ORDER BY id DESC 
+                LIMIT $1;
+            `, [count]);
+            if (result.rows.length === 0) {
+                console.log(`${colors.yellow}No migrations to rollback.${colors.reset}`);
+                return;
+            }
+            const toRollback = result.rows.map(r => r.name);
+            console.log(`${colors.bold}Migrations to rollback:${colors.reset}`);
+            for (const name of toRollback) {
+                console.log(`  ${colors.red}• ${name}${colors.reset}`);
+            }
+            console.log('');
+            if (!force && !dryRun) {
+                const proceed = await askConfirm(`${colors.red}This will undo ${toRollback.length} migration(s). Continue?${colors.reset}`);
+                if (!proceed) {
+                    console.log('Cancelled.');
+                    return;
+                }
+            }
+            for (const name of toRollback) {
+                const filePath = path.join(migrationsDir, name);
+                if (!fs.existsSync(filePath)) {
+                    console.log(`${colors.yellow}⚠️  Migration file not found: ${name}${colors.reset}`);
+                    continue;
+                }
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const { down } = parseMigration(content);
+                if (!down) {
+                    console.log(`${colors.yellow}⚠️  No DOWN section in: ${name}${colors.reset}`);
+                    continue;
+                }
+                if (dryRun) {
+                    console.log(`${colors.cyan}[dry-run] Would rollback: ${name}${colors.reset}`);
+                    console.log(`${colors.dim}${down}${colors.reset}`);
+                    console.log('');
+                }
+                else {
+                    console.log(`Rolling back: ${name}...`);
+                    const client = await pool.connect();
+                    try {
+                        await client.query('BEGIN');
+                        await client.query(down);
+                        await client.query(`DELETE FROM "${tableName}" WHERE name = $1`, [name]);
+                        await client.query('COMMIT');
+                        console.log(`   ${colors.green}✓ Rolled back${colors.reset}`);
+                    }
+                    catch (error) {
+                        await client.query('ROLLBACK');
+                        throw error;
+                    }
+                    finally {
+                        client.release();
+                    }
+                }
+            }
+            if (!dryRun) {
+                console.log('');
+                console.log(`${colors.green}✓ Rolled back ${toRollback.length} migration(s).${colors.reset}`);
+            }
+        }
+        finally {
+            await pool.end();
+        }
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}

package/dist/esm/cli/commands/status.js

@@ -0,0 +1,107 @@
+import { getConnectionDescription } from "../utils/env-loader.js";
+import { colors } from "../utils/spinner.js";
+import { isInitialized, getHead, loadCommit, shortHash, getStagedChanges, getUnstagedChanges, } from "../utils/repo-manager.js";
+export async function statusCommand(context) {
+    const { config, flags } = context;
+    const projectRoot = process.cwd();
+    const connection = config?.connection;
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        console.log(`${colors.red('fatal:')} not a relq repository`);
+        console.log('');
+        console.log(`${colors.muted('Run')} ${colors.cyan('relq init')} ${colors.muted('to initialize.')}`);
+        console.log('');
+        return;
+    }
+    const head = getHead(projectRoot);
+    const staged = getStagedChanges(projectRoot);
+    const unstaged = getUnstagedChanges(projectRoot);
+    if (head) {
+        const headCommit = loadCommit(head, projectRoot);
+        console.log(`On commit ${colors.yellow(shortHash(head))}`);
+        if (headCommit) {
+            console.log(`${colors.muted(`"${headCommit.message}"`)}`);
+        }
+    }
+    else {
+        console.log(`${colors.muted('No commits yet')}`);
+    }
+    if (connection) {
+        console.log(`Database: ${colors.cyan(getConnectionDescription(connection))}`);
+    }
+    console.log('');
+    if (staged.length > 0) {
+        console.log(`${colors.green('Changes to be committed:')}`);
+        console.log(`  ${colors.muted('(use "relq restore --staged <name>..." to unstage)')}`);
+        console.log('');
+        displayChanges(staged, '	');
+        console.log('');
+    }
+    if (unstaged.length > 0) {
+        console.log(`${colors.red('Changes not staged for commit:')}`);
+        console.log(`  ${colors.muted('(use "relq add <name>..." to stage)')}`);
+        console.log(`  ${colors.muted('(use "relq restore <name>..." to discard)')}`);
+        console.log('');
+        displayChanges(unstaged, '	');
+        console.log('');
+    }
+    if (staged.length === 0 && unstaged.length === 0) {
+        console.log(`${colors.green('nothing to commit, working tree clean')}`);
+        console.log('');
+        console.log(`${colors.muted('Run')} ${colors.cyan('relq pull')} ${colors.muted('to sync with database.')}`);
+        console.log(`${colors.muted('Run')} ${colors.cyan('relq import <file>')} ${colors.muted('to import SQL schema.')}`);
+    }
+    else {
+        if (staged.length > 0 && unstaged.length === 0) {
+            console.log(`${colors.muted('Run')} ${colors.cyan('relq commit -m "message"')} ${colors.muted('to commit.')}`);
+        }
+        else if (unstaged.length > 0) {
+            console.log(`${colors.muted('Run')} ${colors.cyan('relq add .')} ${colors.muted('to stage all changes.')}`);
+        }
+    }
+    console.log('');
+}
+function displayChanges(changes, indent = '') {
+    const byType = new Map();
+    for (const change of changes) {
+        const key = change.objectType;
+        if (!byType.has(key)) {
+            byType.set(key, []);
+        }
+        byType.get(key).push(change);
+    }
+    const order = ['TABLE', 'COLUMN', 'INDEX', 'CONSTRAINT', 'PRIMARY_KEY', 'FOREIGN_KEY', 'CHECK', 'EXCLUSION', 'EXTENSION', 'ENUM', 'DOMAIN', 'FUNCTION', 'TRIGGER', 'VIEW'];
+    const sorted = [...byType.entries()].sort((a, b) => {
+        const aIdx = order.indexOf(a[0]);
+        const bIdx = order.indexOf(b[0]);
+        return (aIdx === -1 ? 999 : aIdx) - (bIdx === -1 ? 999 : bIdx);
+    });
+    for (const [type, typeChanges] of sorted) {
+        for (const change of typeChanges) {
+            const color = change.type === 'CREATE' ? colors.green :
+                change.type === 'DROP' ? colors.red :
+                    colors.yellow;
+            const typeLabel = getTypeLabel(change.type, change.objectType);
+            const objectName = change.parentName
+                ? `${change.parentName}.${change.objectName}`
+                : change.objectName;
+            console.log(`${indent}${color(typeLabel.padEnd(16))} ${objectName}`);
+        }
+    }
+}
+function getTypeLabel(changeType, objectType) {
+    const objectName = objectType.toLowerCase().replace(/_/g, ' ');
+    switch (changeType) {
+        case 'CREATE':
+            return `new ${objectName}:`;
+        case 'DROP':
+            return `deleted:`;
+        case 'ALTER':
+            return `modified:`;
+        case 'RENAME':
+            return `renamed:`;
+        default:
+            return `${changeType.toLowerCase()}:`;
+    }
+}
+export default statusCommand;

package/dist/esm/cli/commands/sync.js

@@ -0,0 +1,76 @@
+import { requireValidConfig } from "../utils/config-loader.js";
+import { getConnectionDescription } from "../utils/env-loader.js";
+import { colors, createSpinner } from "../utils/spinner.js";
+import { isInitialized, fetchRemoteCommits, pushCommit, ensureRemoteTable, getAllCommits, getRepoStatus, } from "../utils/repo-manager.js";
+import { pullCommand } from "./pull.js";
+export async function syncCommand(context) {
+    const { config, flags } = context;
+    if (!config) {
+        console.error('Error: No configuration found.');
+        process.exit(1);
+    }
+    requireValidConfig(config);
+    const connection = config.connection;
+    const projectRoot = process.cwd();
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        console.log(`${colors.red('fatal:')} not a relq repository`);
+        console.log('');
+        console.log(`${colors.muted('Run')} ${colors.cyan('relq init')} ${colors.muted('to initialize.')}`);
+        return;
+    }
+    const spinner = createSpinner();
+    try {
+        spinner.start('Checking sync status...');
+        const status = await getRepoStatus(connection, projectRoot);
+        spinner.stop();
+        console.log(`On database: ${colors.cyan(getConnectionDescription(connection))}`);
+        console.log('');
+        if (status.behindBy > 0) {
+            console.log(`${colors.yellow('↓')} ${status.behindBy} commit(s) to pull`);
+        }
+        if (status.aheadBy > 0) {
+            console.log(`${colors.green('↑')} ${status.aheadBy} commit(s) to push`);
+        }
+        if (status.behindBy === 0 && status.aheadBy === 0) {
+            console.log(`${colors.green('✓')} Already in sync`);
+            console.log('');
+            return;
+        }
+        console.log('');
+        if (status.behindBy > 0) {
+            console.log(`${colors.cyan('●')} Pulling changes...`);
+            console.log('');
+            const pullContext = {
+                ...context,
+                flags: { ...flags, force: true },
+            };
+            await pullCommand(pullContext);
+        }
+        if (status.aheadBy > 0) {
+            console.log(`${colors.cyan('●')} Pushing commits...`);
+            console.log('');
+            await ensureRemoteTable(connection);
+            const localCommits = getAllCommits(projectRoot);
+            const remoteCommits = await fetchRemoteCommits(connection, 100);
+            const remoteHashes = new Set(remoteCommits.map(c => c.hash));
+            const toPush = localCommits.filter(c => !remoteHashes.has(c.hash));
+            spinner.start(`Pushing ${toPush.length} commit(s)...`);
+            for (const commit of toPush.reverse()) {
+                await pushCommit(connection, commit);
+            }
+            spinner.succeed(`Pushed ${toPush.length} commit(s)`);
+        }
+        console.log('');
+        const pulledText = status.behindBy > 0 ? `${colors.yellow(`↓ ${status.behindBy}`)} pulled` : '';
+        const pushedText = status.aheadBy > 0 ? `${colors.green(`↑ ${status.aheadBy}`)} pushed` : '';
+        const separator = pulledText && pushedText ? ' | ' : '';
+        console.log(`${colors.green('✓')} Sync complete: ${pulledText}${separator}${pushedText}`);
+    }
+    catch (error) {
+        spinner.fail('Sync failed');
+        console.error(colors.red(`Error: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
+    }
+    console.log('');
+}

package/dist/esm/cli/index.js

@@ -0,0 +1,240 @@
+#!/usr/bin/env node
+import { initCommand } from "./commands/init.js";
+import { pullCommand } from "./commands/pull.js";
+import { pushCommand } from "./commands/push.js";
+import { generateCommand } from "./commands/generate.js";
+import { introspectCommand } from "./commands/introspect.js";
+import { syncCommand } from "./commands/sync.js";
+import { statusCommand } from "./commands/status.js";
+import { diffCommand } from "./commands/diff.js";
+import { logCommand } from "./commands/log.js";
+import { rollbackCommand } from "./commands/rollback.js";
+import { commitCommand } from "./commands/commit.js";
+import { fetchCommand } from "./commands/fetch.js";
+import { addCommand } from "./commands/add.js";
+import { importCommand } from "./commands/import.js";
+import { exportCommand } from "./commands/export.js";
+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 import("./utils/config-loader.js");
+            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 initCommand(context);
+                break;
+            case 'status':
+                await statusCommand(context);
+                break;
+            case 'diff':
+                await diffCommand(context);
+                break;
+            case 'pull':
+                await pullCommand(context);
+                break;
+            case 'commit':
+                await commitCommand(context);
+                break;
+            case 'add':
+                await addCommand(context);
+                break;
+            case 'generate':
+                await generateCommand(context);
+                break;
+            case 'push':
+                await pushCommand(context);
+                break;
+            case 'history':
+            case 'log':
+                await logCommand(context);
+                break;
+            case 'fetch':
+                await fetchCommand(context);
+                break;
+            case 'rollback':
+            case 'revert':
+                await rollbackCommand(context);
+                break;
+            case 'introspect':
+                await introspectCommand(context);
+                break;
+            case 'sync':
+                await syncCommand(context);
+                break;
+            case 'import':
+                await 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 exportCommand(context);
+                break;
+            case 'migrate':
+                console.log('Note: "migrate" is deprecated, use "push" instead.\n');
+                await 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);