relq 1.0.0

package/dist/cjs/cli/commands/migrate.cjs

@@ -0,0 +1,167 @@
+"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.migrateCommand = migrateCommand;
+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");
+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 migrateCommand(context) {
+    const { config, flags } = context;
+    if (!config) {
+        console.error('Error: No configuration found.');
+        process.exit(1);
+    }
+    (0, config_loader_1.requireValidConfig)(config);
+    const dryRun = flags['dry-run'] === true;
+    const force = flags['force'] === true;
+    const connection = config.connection;
+    const migrationsDir = config.migrations?.directory || './migrations';
+    const tableName = config.migrations?.tableName || '_relq_migrations';
+    console.log('🔄 Running migrations...');
+    console.log(`   Connection: ${(0, env_loader_1.getConnectionDescription)(connection)}`);
+    console.log(`   Migrations: ${migrationsDir}\n`);
+    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 {
+            await pool.query(`
+                CREATE TABLE IF NOT EXISTS "${tableName}" (
+                    id SERIAL PRIMARY KEY,
+                    name VARCHAR(255) NOT NULL UNIQUE,
+                    applied_at TIMESTAMPTZ DEFAULT NOW()
+                );
+            `);
+            const appliedResult = await pool.query(`
+                SELECT name FROM "${tableName}" ORDER BY id;
+            `);
+            const appliedMigrations = new Set(appliedResult.rows.map(r => r.name));
+            if (!fs.existsSync(migrationsDir)) {
+                console.log('No migrations directory found.');
+                return;
+            }
+            const migrationFiles = fs.readdirSync(migrationsDir)
+                .filter(f => f.endsWith('.sql'))
+                .sort();
+            const pending = migrationFiles.filter(f => !appliedMigrations.has(f));
+            if (pending.length === 0) {
+                console.log('✅ No pending migrations.');
+                return;
+            }
+            console.log(`📋 Pending migrations (${pending.length}):`);
+            for (const file of pending) {
+                console.log(`   • ${file}`);
+            }
+            console.log('');
+            if (!force && !dryRun) {
+                if (!await askConfirm('Apply these migrations?')) {
+                    console.log('Cancelled.');
+                    return;
+                }
+            }
+            for (const file of pending) {
+                const filePath = path.join(migrationsDir, file);
+                const content = fs.readFileSync(filePath, 'utf-8');
+                const { up } = parseMigration(content);
+                if (!up) {
+                    console.log(`⚠️  Skipping ${file} (no UP section)`);
+                    continue;
+                }
+                if (dryRun) {
+                    console.log(`Would apply: ${file}`);
+                    console.log('---');
+                    console.log(up);
+                    console.log('---\n');
+                }
+                else {
+                    console.log(`Applying: ${file}...`);
+                    const client = await pool.connect();
+                    try {
+                        await client.query('BEGIN');
+                        await client.query(up);
+                        await client.query(`INSERT INTO "${tableName}" (name) VALUES ($1)`, [file]);
+                        await client.query('COMMIT');
+                        console.log(`   ✅ Applied`);
+                    }
+                    catch (error) {
+                        await client.query('ROLLBACK');
+                        throw error;
+                    }
+                    finally {
+                        client.release();
+                    }
+                }
+            }
+            if (!dryRun) {
+                console.log(`\n✅ Applied ${pending.length} migration(s).`);
+            }
+        }
+        finally {
+            await pool.end();
+        }
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}

package/dist/cjs/cli/commands/pull.cjs

@@ -0,0 +1,410 @@
+"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.pullCommand = pullCommand;
+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 fast_introspect_1 = require("../utils/fast-introspect.cjs");
+const type_generator_1 = require("../utils/type-generator.cjs");
+const env_loader_1 = require("../utils/env-loader.cjs");
+const spinner_1 = require("../utils/spinner.cjs");
+const relqignore_1 = require("../utils/relqignore.cjs");
+const repo_manager_1 = require("../utils/repo-manager.cjs");
+function toCamelCase(str) {
+    return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+function parseSchemaFileForSnapshot(schemaPath) {
+    if (!fs.existsSync(schemaPath)) {
+        return null;
+    }
+    const content = fs.readFileSync(schemaPath, 'utf-8');
+    const tables = [];
+    const tableRegex = /defineTable\s*\(\s*['"]([^'"]+)['"],\s*\{([\s\S]*?)\}(?:\s*,\s*\{([\s\S]*?)\})?\s*\)/g;
+    let tableMatch;
+    while ((tableMatch = tableRegex.exec(content)) !== null) {
+        const tableName = tableMatch[1];
+        const columnsBlock = tableMatch[2];
+        const optionsBlock = tableMatch[3] || '';
+        const columns = [];
+        const typePattern = 'varchar|text|uuid|integer|bigint|boolean|timestamp|date|jsonb|json|numeric|serial|bigserial|smallserial|tsvector|smallint|real|doublePrecision|char|inet|cidr|macaddr|macaddr8|interval|time|point|line|lseg|box|path|polygon|circle|bytea|bit|varbit|money|xml|oid';
+        const columnRegex = new RegExp(`^\\s*(\\w+):\\s*(${typePattern})(?:\\([^)]*\\))?((?:\\.[a-zA-Z]+\\([^)]*\\))*)`, 'gm');
+        let colMatch;
+        while ((colMatch = columnRegex.exec(columnsBlock)) !== null) {
+            const tsName = colMatch[1];
+            const type = colMatch[2];
+            const modifiers = colMatch[3] || '';
+            const explicitNameMatch = columnsBlock.match(new RegExp(`${tsName}:\\s*${type}\\s*\\(['\"]([^'"]+)['\"]`));
+            const dbColName = explicitNameMatch ? explicitNameMatch[1] : tsName;
+            columns.push({
+                name: dbColName,
+                tsName: tsName,
+                type: modifiers.includes('.array()') ? `${type}[]` : type,
+                nullable: !modifiers.includes('.notNull()') && !modifiers.includes('.primaryKey()'),
+                default: null,
+                primaryKey: modifiers.includes('.primaryKey()'),
+                unique: modifiers.includes('.unique()'),
+            });
+        }
+        const indexes = [];
+        const indexRegex = /index\s*\(\s*['"]([^'"]+)['"]\s*\)\.on\(([^)]+)\)/g;
+        let idxMatch;
+        while ((idxMatch = indexRegex.exec(optionsBlock)) !== null) {
+            const indexName = idxMatch[1];
+            const indexCols = idxMatch[2].split(',').map(c => c.trim().replace(/table\.\s*/, ''));
+            const isUnique = optionsBlock.includes(`index('${indexName}')`) &&
+                optionsBlock.substring(optionsBlock.indexOf(`index('${indexName}')`)).split('\n')[0].includes('.unique()');
+            indexes.push({
+                name: indexName,
+                columns: indexCols,
+                unique: isUnique,
+                type: 'btree',
+            });
+        }
+        const hasPartition = optionsBlock.includes('partitionBy');
+        let partitionType;
+        let partitionKey = [];
+        let partitions = [];
+        if (hasPartition) {
+            const partitionByMatch = optionsBlock.match(/partitionBy:\s*\([^)]+\)\s*=>\s*\w+\.(list|range|hash)\(([^)]+)\)/i);
+            if (partitionByMatch) {
+                partitionType = partitionByMatch[1].toUpperCase();
+                const colMatch = partitionByMatch[2].match(/table\.(\w+)/);
+                if (colMatch) {
+                    partitionKey = [colMatch[1]];
+                }
+            }
+            const partitionsMatch = optionsBlock.match(/partitions:\s*\(partition\)\s*=>\s*\[([\s\S]*?)\]/);
+            if (partitionsMatch) {
+                const partitionsBlock = partitionsMatch[1];
+                const partitionRegex = /partition\s*\(\s*['"]([^'"]+)['"]\s*\)\.([^,\n]+)/g;
+                let pMatch;
+                while ((pMatch = partitionRegex.exec(partitionsBlock)) !== null) {
+                    partitions.push({
+                        name: pMatch[1],
+                        bound: pMatch[2].trim(),
+                    });
+                }
+            }
+        }
+        tables.push({
+            name: tableName,
+            schema: 'public',
+            columns,
+            indexes,
+            constraints: [],
+            ...(hasPartition && {
+                isPartitioned: true,
+                partitionType,
+                partitionKey,
+                partitions,
+            }),
+        });
+    }
+    const enums = [];
+    const enumRegex = /pgEnum\s*\(\s*['"]([^'"]+)['"]]/g;
+    let enumMatch;
+    while ((enumMatch = enumRegex.exec(content)) !== null) {
+        enums.push(enumMatch[1]);
+    }
+    return {
+        tables,
+        enums: [],
+        domains: [],
+        compositeTypes: [],
+        sequences: [],
+        collations: [],
+        functions: [],
+        triggers: [],
+        extensions: [],
+    };
+}
+function askConfirm(question, defaultYes = true) {
+    const suffix = defaultYes ? spinner_1.colors.muted('[Y/n]') : spinner_1.colors.muted('[y/N]');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(`${question} ${suffix}: `, (answer) => {
+            rl.close();
+            const a = answer.trim().toLowerCase();
+            if (!a)
+                resolve(defaultYes);
+            else
+                resolve(a === 'y' || a === 'yes');
+        });
+    });
+}
+async function pullCommand(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 author = config.author || 'Relq CLI';
+    const schemaPath = typeof config.schema === 'string' ? config.schema : './db/schema.ts';
+    const includeFunctions = config.generate?.includeFunctions ?? false;
+    const includeTriggers = config.generate?.includeTriggers ?? false;
+    const spinner = (0, spinner_1.createSpinner)();
+    const startTime = Date.now();
+    console.log('');
+    if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
+        (0, repo_manager_1.initRepository)(projectRoot);
+        console.log(`${spinner_1.colors.cyan('ℹ')}  Initialized .relq folder`);
+    }
+    if (!force) {
+        const stagedChanges = (0, repo_manager_1.getStagedChanges)(projectRoot);
+        const unstagedChanges = (0, repo_manager_1.getUnstagedChanges)(projectRoot);
+        if (stagedChanges.length > 0 || unstagedChanges.length > 0) {
+            const hasUnstaged = unstagedChanges.length > 0;
+            const hasStaged = stagedChanges.length > 0;
+            if (hasUnstaged && hasStaged) {
+                console.error(spinner_1.colors.red('Error: You have uncommitted and unstaged changes.'));
+            }
+            else if (hasStaged) {
+                console.error(spinner_1.colors.red('Error: You have uncommitted changes.'));
+            }
+            else {
+                console.error(spinner_1.colors.red('Error: You have unstaged changes.'));
+            }
+            console.log('');
+            if (hasStaged) {
+                console.log(`  ${spinner_1.colors.green('Staged (uncommitted):')} ${stagedChanges.length} change(s)`);
+            }
+            if (hasUnstaged) {
+                console.log(`  ${spinner_1.colors.red('Unstaged:')} ${unstagedChanges.length} change(s)`);
+            }
+            console.log('');
+            if (hasUnstaged && !hasStaged) {
+                console.log('Please stage and commit, or reset your changes:');
+                console.log(`  ${spinner_1.colors.cyan('relq add .')}              - stage all changes`);
+                console.log(`  ${spinner_1.colors.cyan('relq commit -m "message"')}  - then commit`);
+            }
+            else {
+                console.log('Please commit or reset your changes:');
+                console.log(`  ${spinner_1.colors.cyan('relq commit -m "message"')}  - commit staged changes`);
+            }
+            console.log(`  ${spinner_1.colors.cyan('relq reset')}               - discard all changes`);
+            console.log(`  ${spinner_1.colors.cyan('relq pull --force')}        - force pull (overwrites local changes)`);
+            return;
+        }
+    }
+    try {
+        spinner.start('Connecting to database...');
+        await (0, repo_manager_1.ensureRemoteTable)(connection);
+        spinner.succeed(`Connected to ${spinner_1.colors.cyan((0, env_loader_1.getConnectionDescription)(connection))}`);
+        spinner.start('Fetching remote commits...');
+        const remoteCommits = await (0, repo_manager_1.fetchRemoteCommits)(connection, 100);
+        const remoteHead = remoteCommits.length > 0 ? remoteCommits[0].hash : null;
+        if (remoteHead) {
+            (0, repo_manager_1.setFetchHead)(remoteHead, projectRoot);
+        }
+        spinner.succeed(`Fetched ${remoteCommits.length} remote commits`);
+        spinner.start('Introspecting database...');
+        const dbSchema = await (0, fast_introspect_1.fastIntrospectDatabase)(connection, undefined, {
+            includeFunctions,
+            includeTriggers,
+        });
+        spinner.succeed(`Found ${dbSchema.tables.length} tables`);
+        const ignorePatterns = (0, relqignore_1.getIgnorePatterns)(projectRoot);
+        const filteredTables = (0, relqignore_1.filterIgnored)(dbSchema.tables, ignorePatterns);
+        const localHead = (0, repo_manager_1.getHead)(projectRoot);
+        const localSnapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
+        const schemaExists = fs.existsSync(schemaPath);
+        const currentSchema = {
+            tables: filteredTables.map(t => ({
+                name: t.name,
+                schema: t.schema,
+                columns: t.columns.map(c => ({
+                    name: c.name,
+                    tsName: toCamelCase(c.name),
+                    type: c.dataType,
+                    nullable: c.isNullable,
+                    default: c.defaultValue,
+                    primaryKey: c.isPrimaryKey,
+                    unique: c.isUnique,
+                })),
+                indexes: t.indexes.map(i => ({
+                    name: i.name,
+                    columns: i.columns,
+                    unique: i.isUnique,
+                    type: i.type,
+                })),
+                constraints: t.constraints.map(c => ({
+                    name: c.name,
+                    type: c.type,
+                    definition: c.definition,
+                })),
+            })),
+            enums: dbSchema.enums.map(e => ({
+                name: e.name,
+                schema: 'public',
+                values: e.values,
+            })),
+            domains: dbSchema.domains.map(d => ({
+                name: d.name,
+                schema: 'public',
+                baseType: d.baseType,
+                notNull: d.isNotNull || false,
+                default: d.defaultValue || null,
+                check: d.checkExpression || null,
+            })),
+            compositeTypes: dbSchema.compositeTypes.map(c => ({
+                name: c.name,
+                schema: 'public',
+                attributes: c.attributes,
+            })),
+            sequences: [],
+            collations: [],
+            functions: dbSchema.functions.map(f => ({
+                name: f.name,
+                returnType: f.returnType,
+                argTypes: f.argTypes,
+                language: f.language,
+            })),
+            triggers: dbSchema.triggers.map(t => ({
+                name: t.name,
+                table: t.tableName,
+                events: [t.event],
+                timing: t.timing,
+                forEach: 'STATEMENT',
+                functionName: t.functionName || '',
+            })),
+            extensions: dbSchema.extensions.map(ext => ({ name: ext })),
+        };
+        console.log('');
+        if (schemaExists && localSnapshot && !force) {
+            const localTables = new Set(localSnapshot.tables.map(t => t.name));
+            const remoteTables = new Set(currentSchema.tables.map(t => t.name));
+            const added = [...remoteTables].filter(t => !localTables.has(t));
+            const removed = [...localTables].filter(t => !remoteTables.has(t));
+            if (added.length === 0 && removed.length === 0) {
+                console.log(`${spinner_1.colors.green('✓')} Already up to date with remote`);
+                console.log('');
+                return;
+            }
+            console.log(`${spinner_1.colors.yellow('Remote has changes:')}`);
+            if (added.length > 0) {
+                console.log(`   ${spinner_1.colors.green(`+${added.length}`)} tables added`);
+            }
+            if (removed.length > 0) {
+                console.log(`   ${spinner_1.colors.red(`-${removed.length}`)} tables removed`);
+            }
+            console.log('');
+            if (!dryRun) {
+                const proceed = await askConfirm(`${spinner_1.colors.bold('Pull these changes?')}`, true);
+                if (!proceed) {
+                    console.log('');
+                    console.log(`${spinner_1.colors.muted('Cancelled.')}`);
+                    return;
+                }
+                console.log('');
+            }
+        }
+        else if (schemaExists && !force) {
+            console.log(`${spinner_1.colors.yellow('⚠')}  ${spinner_1.colors.bold('Local schema exists but not tracked')}`);
+            console.log('');
+            console.log(`   ${spinner_1.colors.cyan(schemaPath)}`);
+            console.log('');
+            if (!dryRun) {
+                const proceed = await askConfirm(`${spinner_1.colors.bold('Overwrite local schema?')}`, false);
+                if (!proceed) {
+                    console.log('');
+                    console.log(`${spinner_1.colors.muted('Cancelled. Run')} ${spinner_1.colors.cyan('relq status')} ${spinner_1.colors.muted('to see current state.')}`);
+                    return;
+                }
+                console.log('');
+            }
+        }
+        else if (!schemaExists) {
+            console.log(`${spinner_1.colors.cyan('ℹ')}  ${spinner_1.colors.bold('First pull - creating schema')}`);
+            console.log('');
+            console.log(`📊 ${spinner_1.colors.bold('Schema Summary')}`);
+            console.log(`   ${spinner_1.colors.green(String(filteredTables.length))} tables`);
+            console.log(`   ${spinner_1.colors.green(String(dbSchema.extensions.length))} extensions`);
+            console.log('');
+        }
+        if (dryRun) {
+            console.log(`${spinner_1.colors.yellow('⚠')} Dry run - no files written`);
+            console.log('');
+            return;
+        }
+        spinner.start('Generating TypeScript schema...');
+        const typescript = (0, type_generator_1.generateTypeScript)(dbSchema, {
+            includeDefineTables: true,
+            includeSchema: true,
+            includeIndexes: true,
+            includeFunctions,
+            includeTriggers,
+            camelCase: config.generate?.camelCase ?? true,
+        });
+        spinner.succeed('Generated TypeScript schema');
+        const schemaDir = path.dirname(schemaPath);
+        if (!fs.existsSync(schemaDir)) {
+            fs.mkdirSync(schemaDir, { recursive: true });
+        }
+        spinner.start('Writing schema file...');
+        fs.writeFileSync(schemaPath, typescript, 'utf-8');
+        const fileSize = Buffer.byteLength(typescript, 'utf8');
+        spinner.succeed(`Written ${spinner_1.colors.cyan(schemaPath)} ${spinner_1.colors.muted(`(${(0, spinner_1.formatBytes)(fileSize)})`)}`);
+        const snapshotFromFile = parseSchemaFileForSnapshot(schemaPath);
+        if (snapshotFromFile) {
+            (0, repo_manager_1.saveSnapshot)(snapshotFromFile, projectRoot);
+        }
+        else {
+            (0, repo_manager_1.saveSnapshot)(currentSchema, projectRoot);
+        }
+        spinner.start('Creating commit...');
+        const message = localHead ? 'Pulled schema from database' : 'Initial schema pull';
+        const commit = (0, repo_manager_1.createCommit)(currentSchema, author, message, projectRoot);
+        spinner.succeed(`Created commit ${spinner_1.colors.yellow((0, repo_manager_1.shortHash)(commit.hash))}`);
+        const duration = Date.now() - startTime;
+        console.log('');
+        console.log(`${spinner_1.colors.green('✓')} Pull completed in ${spinner_1.colors.cyan(`${duration}ms`)}`);
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Pull failed');
+        console.error(spinner_1.colors.red(`Error: ${error instanceof Error ? error.message : error}`));
+        process.exit(1);
+    }
+}