relq 1.0.0

package/dist/cjs/cli/commands/push.cjs

@@ -0,0 +1,165 @@
+"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 });
+exports.pushCommand = pushCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const config_loader_1 = require("../utils/config-loader.cjs");
+const env_loader_1 = require("../utils/env-loader.cjs");
+const spinner_1 = require("../utils/spinner.cjs");
+const repo_manager_1 = require("../utils/repo-manager.cjs");
+async function pushCommand(context) {
+    const { config, flags } = context;
+    if (!config) {
+        console.error('Error: No configuration found.');
+        process.exit(1);
+    }
+    (0, config_loader_1.requireValidConfig)(config);
+    const connection = config.connection;
+    const projectRoot = process.cwd();
+    const force = flags['force'] === true;
+    const dryRun = flags['dry-run'] === true;
+    const applySQL = flags['apply'] === true;
+    console.log('');
+    if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
+        console.log(`${spinner_1.colors.red('fatal:')} not a relq repository`);
+        console.log('');
+        console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq init')} ${spinner_1.colors.muted('to initialize.')}`);
+        return;
+    }
+    const localHead = (0, repo_manager_1.getHead)(projectRoot);
+    if (!localHead) {
+        console.log(`${spinner_1.colors.red('error:')} no commits to push`);
+        console.log('');
+        console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq commit -m "message"')} ${spinner_1.colors.muted('to create a commit.')}`);
+        return;
+    }
+    const spinner = (0, spinner_1.createSpinner)();
+    try {
+        spinner.start('Connecting to remote...');
+        await (0, repo_manager_1.ensureRemoteTable)(connection);
+        spinner.succeed(`Connected to ${spinner_1.colors.cyan((0, env_loader_1.getConnectionDescription)(connection))}`);
+        spinner.start('Checking remote...');
+        const remoteCommits = await (0, repo_manager_1.fetchRemoteCommits)(connection, 100);
+        const remoteHead = remoteCommits.length > 0 ? remoteCommits[0].hash : null;
+        spinner.stop();
+        const localCommits = (0, repo_manager_1.getAllCommits)(projectRoot);
+        const remoteHashes = new Set(remoteCommits.map(c => c.hash));
+        const localHashes = new Set(localCommits.map(c => c.hash));
+        const toPush = localCommits.filter(c => !remoteHashes.has(c.hash));
+        if (toPush.length === 0) {
+            console.log(`${spinner_1.colors.green('✓')} Everything up-to-date`);
+            console.log('');
+            return;
+        }
+        const remoteMissing = remoteCommits.filter(c => !localHashes.has(c.hash));
+        if (remoteMissing.length > 0 && !force) {
+            console.log(`${spinner_1.colors.red('error:')} failed to push`);
+            console.log('');
+            console.log(`${spinner_1.colors.yellow('hint:')} Updates were rejected because the remote contains work that you do not have locally.`);
+            console.log(`${spinner_1.colors.yellow('hint:')} Run ${spinner_1.colors.cyan('relq pull')} to integrate the remote changes before pushing.`);
+            console.log('');
+            return;
+        }
+        console.log(`Pushing to ${spinner_1.colors.cyan((0, env_loader_1.getConnectionDescription)(connection))}`);
+        console.log('');
+        if (dryRun) {
+            console.log(`${spinner_1.colors.yellow('Would push')} ${toPush.length} commit(s):`);
+            for (const commit of toPush.slice(0, 5)) {
+                console.log(`   ${spinner_1.colors.yellow((0, repo_manager_1.shortHash)(commit.hash))} ${commit.message}`);
+            }
+            if (toPush.length > 5) {
+                console.log(`   ${spinner_1.colors.muted(`... and ${toPush.length - 5} more`)}`);
+            }
+            console.log('');
+            return;
+        }
+        const commitsToProcess = [...toPush].reverse();
+        spinner.start(`Pushing ${toPush.length} commit(s)...`);
+        for (const commit of commitsToProcess) {
+            await (0, repo_manager_1.pushCommit)(connection, commit);
+        }
+        spinner.succeed(`Pushed ${toPush.length} commit(s)`);
+        if (applySQL) {
+            spinner.start('Applying SQL changes...');
+            const pg = await Promise.resolve().then(() => __importStar(require("../../../addons/pg.js")));
+            const client = new pg.Client({
+                host: connection.host,
+                port: connection.port,
+                database: connection.database,
+                user: connection.user,
+                password: connection.password,
+            });
+            try {
+                await client.connect();
+                let sqlExecuted = 0;
+                for (const commit of commitsToProcess) {
+                    const commitPath = path.join(projectRoot, '.relq', 'commits', `${commit.hash}.json`);
+                    if (fs.existsSync(commitPath)) {
+                        const enhancedCommit = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+                        if (enhancedCommit.sql) {
+                            await client.query(enhancedCommit.sql);
+                            sqlExecuted++;
+                        }
+                    }
+                }
+                spinner.succeed(`Applied SQL from ${sqlExecuted} commit(s)`);
+            }
+            finally {
+                await client.end();
+            }
+        }
+        const oldHash = remoteHead ? (0, repo_manager_1.shortHash)(remoteHead) : '(none)';
+        const newHash = (0, repo_manager_1.shortHash)(localHead);
+        console.log(`   ${oldHash}..${newHash}  ${spinner_1.colors.muted('main -> main')}`);
+        if (!applySQL && toPush.some(c => {
+            const commitPath = path.join(projectRoot, '.relq', 'commits', `${c.hash}.json`);
+            if (fs.existsSync(commitPath)) {
+                const ec = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+                return ec.sql && ec.sql.trim().length > 0;
+            }
+            return false;
+        })) {
+            console.log('');
+            console.log(`${spinner_1.colors.muted('Use')} ${spinner_1.colors.cyan('relq push --apply')} ${spinner_1.colors.muted('to also execute SQL against database.')}`);
+        }
+    }
+    catch (error) {
+        spinner.fail('Push failed');
+        console.error(spinner_1.colors.red(`Error: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
+    }
+    console.log('');
+}

package/dist/cjs/cli/commands/rollback.cjs

@@ -0,0 +1,169 @@
+"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 });
+exports.rollbackCommand = rollbackCommand;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const config_loader_1 = require("../utils/config-loader.cjs");
+const env_loader_1 = require("../utils/env-loader.cjs");
+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');
+        });
+    });
+}
+async function rollbackCommand(context) {
+    const { config, args, flags } = context;
+    if (!config) {
+        console.error('Error: No configuration found.');
+        process.exit(1);
+    }
+    (0, config_loader_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: ${(0, env_loader_1.getConnectionDescription)(connection)}`);
+    console.log('');
+    try {
+        const { Pool } = await Promise.resolve().then(() => __importStar(require("../../../addons/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/cjs/cli/commands/status.cjs

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.statusCommand = statusCommand;
+const env_loader_1 = require("../utils/env-loader.cjs");
+const spinner_1 = require("../utils/spinner.cjs");
+const repo_manager_1 = require("../utils/repo-manager.cjs");
+async function statusCommand(context) {
+    const { config, flags } = context;
+    const projectRoot = process.cwd();
+    const connection = config?.connection;
+    console.log('');
+    if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
+        console.log(`${spinner_1.colors.red('fatal:')} not a relq repository`);
+        console.log('');
+        console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq init')} ${spinner_1.colors.muted('to initialize.')}`);
+        console.log('');
+        return;
+    }
+    const head = (0, repo_manager_1.getHead)(projectRoot);
+    const staged = (0, repo_manager_1.getStagedChanges)(projectRoot);
+    const unstaged = (0, repo_manager_1.getUnstagedChanges)(projectRoot);
+    if (head) {
+        const headCommit = (0, repo_manager_1.loadCommit)(head, projectRoot);
+        console.log(`On commit ${spinner_1.colors.yellow((0, repo_manager_1.shortHash)(head))}`);
+        if (headCommit) {
+            console.log(`${spinner_1.colors.muted(`"${headCommit.message}"`)}`);
+        }
+    }
+    else {
+        console.log(`${spinner_1.colors.muted('No commits yet')}`);
+    }
+    if (connection) {
+        console.log(`Database: ${spinner_1.colors.cyan((0, env_loader_1.getConnectionDescription)(connection))}`);
+    }
+    console.log('');
+    if (staged.length > 0) {
+        console.log(`${spinner_1.colors.green('Changes to be committed:')}`);
+        console.log(`  ${spinner_1.colors.muted('(use "relq restore --staged <name>..." to unstage)')}`);
+        console.log('');
+        displayChanges(staged, '	');
+        console.log('');
+    }
+    if (unstaged.length > 0) {
+        console.log(`${spinner_1.colors.red('Changes not staged for commit:')}`);
+        console.log(`  ${spinner_1.colors.muted('(use "relq add <name>..." to stage)')}`);
+        console.log(`  ${spinner_1.colors.muted('(use "relq restore <name>..." to discard)')}`);
+        console.log('');
+        displayChanges(unstaged, '	');
+        console.log('');
+    }
+    if (staged.length === 0 && unstaged.length === 0) {
+        console.log(`${spinner_1.colors.green('nothing to commit, working tree clean')}`);
+        console.log('');
+        console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq pull')} ${spinner_1.colors.muted('to sync with database.')}`);
+        console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq import <file>')} ${spinner_1.colors.muted('to import SQL schema.')}`);
+    }
+    else {
+        if (staged.length > 0 && unstaged.length === 0) {
+            console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq commit -m "message"')} ${spinner_1.colors.muted('to commit.')}`);
+        }
+        else if (unstaged.length > 0) {
+            console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq add .')} ${spinner_1.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' ? spinner_1.colors.green :
+                change.type === 'DROP' ? spinner_1.colors.red :
+                    spinner_1.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()}:`;
+    }
+}
+exports.default = statusCommand;

package/dist/cjs/cli/commands/sync.cjs

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncCommand = syncCommand;
+const config_loader_1 = require("../utils/config-loader.cjs");
+const env_loader_1 = require("../utils/env-loader.cjs");
+const spinner_1 = require("../utils/spinner.cjs");
+const repo_manager_1 = require("../utils/repo-manager.cjs");
+const pull_1 = require("./pull.cjs");
+async function syncCommand(context) {
+    const { config, flags } = context;
+    if (!config) {
+        console.error('Error: No configuration found.');
+        process.exit(1);
+    }
+    (0, config_loader_1.requireValidConfig)(config);
+    const connection = config.connection;
+    const projectRoot = process.cwd();
+    console.log('');
+    if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
+        console.log(`${spinner_1.colors.red('fatal:')} not a relq repository`);
+        console.log('');
+        console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq init')} ${spinner_1.colors.muted('to initialize.')}`);
+        return;
+    }
+    const spinner = (0, spinner_1.createSpinner)();
+    try {
+        spinner.start('Checking sync status...');
+        const status = await (0, repo_manager_1.getRepoStatus)(connection, projectRoot);
+        spinner.stop();
+        console.log(`On database: ${spinner_1.colors.cyan((0, env_loader_1.getConnectionDescription)(connection))}`);
+        console.log('');
+        if (status.behindBy > 0) {
+            console.log(`${spinner_1.colors.yellow('↓')} ${status.behindBy} commit(s) to pull`);
+        }
+        if (status.aheadBy > 0) {
+            console.log(`${spinner_1.colors.green('↑')} ${status.aheadBy} commit(s) to push`);
+        }
+        if (status.behindBy === 0 && status.aheadBy === 0) {
+            console.log(`${spinner_1.colors.green('✓')} Already in sync`);
+            console.log('');
+            return;
+        }
+        console.log('');
+        if (status.behindBy > 0) {
+            console.log(`${spinner_1.colors.cyan('●')} Pulling changes...`);
+            console.log('');
+            const pullContext = {
+                ...context,
+                flags: { ...flags, force: true },
+            };
+            await (0, pull_1.pullCommand)(pullContext);
+        }
+        if (status.aheadBy > 0) {
+            console.log(`${spinner_1.colors.cyan('●')} Pushing commits...`);
+            console.log('');
+            await (0, repo_manager_1.ensureRemoteTable)(connection);
+            const localCommits = (0, repo_manager_1.getAllCommits)(projectRoot);
+            const remoteCommits = await (0, repo_manager_1.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 (0, repo_manager_1.pushCommit)(connection, commit);
+            }
+            spinner.succeed(`Pushed ${toPush.length} commit(s)`);
+        }
+        console.log('');
+        const pulledText = status.behindBy > 0 ? `${spinner_1.colors.yellow(`↓ ${status.behindBy}`)} pulled` : '';
+        const pushedText = status.aheadBy > 0 ? `${spinner_1.colors.green(`↑ ${status.aheadBy}`)} pushed` : '';
+        const separator = pulledText && pushedText ? ' | ' : '';
+        console.log(`${spinner_1.colors.green('✓')} Sync complete: ${pulledText}${separator}${pushedText}`);
+    }
+    catch (error) {
+        spinner.fail('Sync failed');
+        console.error(spinner_1.colors.red(`Error: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
+    }
+    console.log('');
+}