relq 1.0.2 → 1.0.4

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

@@ -1,8 +1,8 @@
 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";
+import { confirm, fatal, colors, warning } from "../utils/cli-utils.js";
 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);
@@ -11,31 +11,19 @@ function parseMigration(content) {
         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 migrateCommand(context) {
     const { config, flags } = context;
     if (!config) {
-        console.error('Error: No configuration found.');
-        process.exit(1);
+        fatal('No configuration found', `run ${colors.cyan('relq init')} to create a configuration file`);
+        return;
     }
-    requireValidConfig(config);
+    await requireValidConfig(config, { calledFrom: 'migrate' });
     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('Running migrations...');
     console.log(`   Connection: ${getConnectionDescription(connection)}`);
     console.log(`   Migrations: ${migrationsDir}\n`);
     try {
@@ -69,16 +57,16 @@ export async function migrateCommand(context) {
                 .sort();
             const pending = migrationFiles.filter(f => !appliedMigrations.has(f));
             if (pending.length === 0) {
-                console.log('✅ No pending migrations.');
+                console.log('No pending migrations.');
                 return;
             }
-            console.log(`📋 Pending migrations (${pending.length}):`);
+            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?')) {
+                if (!await confirm('Apply these migrations?', false)) {
                     console.log('Cancelled.');
                     return;
                 }
@@ -88,7 +76,7 @@ export async function migrateCommand(context) {
                 const content = fs.readFileSync(filePath, 'utf-8');
                 const { up } = parseMigration(content);
                 if (!up) {
-                    console.log(`⚠️  Skipping ${file} (no UP section)`);
+                    warning(`Skipping ${file} (no UP section)`);
                     continue;
                 }
                 if (dryRun) {
@@ -105,7 +93,7 @@ export async function migrateCommand(context) {
                         await client.query(up);
                         await client.query(`INSERT INTO "${tableName}" (name) VALUES ($1)`, [file]);
                         await client.query('COMMIT');
-                        console.log(`   ✅ Applied`);
+                        console.log('   Applied');
                     }
                     catch (error) {
                         await client.query('ROLLBACK');
@@ -117,7 +105,7 @@ export async function migrateCommand(context) {
                 }
             }
             if (!dryRun) {
-                console.log(`\n✅ Applied ${pending.length} migration(s).`);
+                console.log(`\nApplied ${pending.length} migration(s).`);
             }
         }
         finally {
@@ -125,7 +113,6 @@ export async function migrateCommand(context) {
         }
     }
     catch (error) {
-        console.error('Error:', error instanceof Error ? error.message : error);
-        process.exit(1);
+        fatal('Migration failed', error instanceof Error ? error.message : String(error));
     }
 }

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

@@ -1,16 +1,31 @@
 import * as fs from 'fs';
 import * as path from 'path';
-import * as readline from 'readline';
 import { requireValidConfig } from "../utils/config-loader.js";
 import { fastIntrospectDatabase } from "../utils/fast-introspect.js";
 import { generateTypeScript } from "../utils/type-generator.js";
 import { getConnectionDescription } from "../utils/env-loader.js";
-import { createSpinner, colors, formatBytes } from "../utils/spinner.js";
+import { createSpinner, colors, formatBytes, formatDuration, fatal, confirm, warning } from "../utils/cli-utils.js";
 import { loadRelqignore, isTableIgnored, isColumnIgnored, isIndexIgnored, isConstraintIgnored, isEnumIgnored, isDomainIgnored, isCompositeTypeIgnored, isFunctionIgnored, } from "../utils/relqignore.js";
-import { isInitialized, initRepository, getHead, saveSnapshot, loadSnapshot, createCommit, shortHash, fetchRemoteCommits, ensureRemoteTable, setFetchHead, getStagedChanges, getUnstagedChanges, } from "../utils/repo-manager.js";
+import { isInitialized, initRepository, getHead, saveSnapshot, loadSnapshot, createCommit, shortHash, fetchRemoteCommits, ensureRemoteTable, setFetchHead, addUnstagedChanges, getStagedChanges, getUnstagedChanges, clearWorkingState, hashFileContent, saveFileHash, } from "../utils/repo-manager.js";
+import { compareSchemas } from "../utils/schema-comparator.js";
 function toCamelCase(str) {
     return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
 }
+function normalizePartitionKey(partitionKey) {
+    if (!partitionKey)
+        return undefined;
+    if (Array.isArray(partitionKey)) {
+        return partitionKey;
+    }
+    if (typeof partitionKey === 'string') {
+        return partitionKey
+            .replace(/^\{|\}$/g, '')
+            .split(',')
+            .map(k => k.trim())
+            .filter(Boolean);
+    }
+    return undefined;
+}
 function parseSchemaFileForSnapshot(schemaPath) {
     if (!fs.existsSync(schemaPath)) {
         return null;
@@ -116,36 +131,20 @@ function parseSchemaFileForSnapshot(schemaPath) {
         extensions: [],
     };
 }
-function askConfirm(question, defaultYes = true) {
-    const suffix = defaultYes ? colors.muted('[Y/n]') : 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');
-        });
-    });
-}
 export async function pullCommand(context) {
-    const { config, flags } = context;
+    const { config, flags, projectRoot } = context;
     if (!config) {
-        console.error('Error: No configuration found.');
-        process.exit(1);
+        fatal('No configuration found', `Run ${colors.cyan('relq init')} to create one.`);
     }
-    requireValidConfig(config);
+    await requireValidConfig(config, { calledFrom: 'pull' });
     const connection = config.connection;
-    const projectRoot = process.cwd();
     const force = flags['force'] === true;
+    const merge = flags['merge'] === true;
+    const noCommit = flags['no-commit'] === 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 schemaPathRaw = typeof config.schema === 'string' ? config.schema : './db/schema.ts';
+    const schemaPath = path.resolve(projectRoot, schemaPathRaw);
     const includeFunctions = config.generate?.includeFunctions ?? false;
     const includeTriggers = config.generate?.includeTriggers ?? false;
     const spinner = createSpinner();
@@ -153,23 +152,27 @@ export async function pullCommand(context) {
     console.log('');
     if (!isInitialized(projectRoot)) {
         initRepository(projectRoot);
-        console.log(`${colors.cyan('ℹ')}  Initialized .relq folder`);
+        console.log('Initialized .relq folder');
     }
-    if (!force) {
-        const stagedChanges = getStagedChanges(projectRoot);
-        const unstagedChanges = getUnstagedChanges(projectRoot);
-        if (stagedChanges.length > 0 || unstagedChanges.length > 0) {
+    const stagedChanges = getStagedChanges(projectRoot);
+    const unstagedChanges = getUnstagedChanges(projectRoot);
+    const hasLocalChanges = stagedChanges.length > 0 || unstagedChanges.length > 0;
+    let stashedSchemaContent = null;
+    const schemaFileExists = fs.existsSync(schemaPath);
+    if (hasLocalChanges) {
+        if (force) {
+            clearWorkingState(projectRoot);
+        }
+        else if (merge) {
+            if (schemaFileExists) {
+                stashedSchemaContent = fs.readFileSync(schemaPath, 'utf-8');
+            }
+            clearWorkingState(projectRoot);
+            console.log(`Stashed local file content for restore after pull`);
+        }
+        else {
             const hasUnstaged = unstagedChanges.length > 0;
             const hasStaged = stagedChanges.length > 0;
-            if (hasUnstaged && hasStaged) {
-                console.error(colors.red('Error: You have uncommitted and unstaged changes.'));
-            }
-            else if (hasStaged) {
-                console.error(colors.red('Error: You have uncommitted changes.'));
-            }
-            else {
-                console.error(colors.red('Error: You have unstaged changes.'));
-            }
             console.log('');
             if (hasStaged) {
                 console.log(`  ${colors.green('Staged (uncommitted):')} ${stagedChanges.length} change(s)`);
@@ -177,19 +180,15 @@ export async function pullCommand(context) {
             if (hasUnstaged) {
                 console.log(`  ${colors.red('Unstaged:')} ${unstagedChanges.length} change(s)`);
             }
-            console.log('');
-            if (hasUnstaged && !hasStaged) {
-                console.log('Please stage and commit, or reset your changes:');
-                console.log(`  ${colors.cyan('relq add .')}              - stage all changes`);
-                console.log(`  ${colors.cyan('relq commit -m "message"')}  - then commit`);
+            let errorMsg = 'You have uncommitted changes';
+            if (hasUnstaged && hasStaged) {
+                errorMsg = 'You have uncommitted and unstaged changes';
             }
-            else {
-                console.log('Please commit or reset your changes:');
-                console.log(`  ${colors.cyan('relq commit -m "message"')}  - commit staged changes`);
+            else if (hasUnstaged) {
+                errorMsg = 'You have unstaged changes';
             }
-            console.log(`  ${colors.cyan('relq reset')}               - discard all changes`);
-            console.log(`  ${colors.cyan('relq pull --force')}        - force pull (overwrites local changes)`);
-            return;
+            const hint = `Commit first: ${colors.cyan('relq add . && relq commit -m "message"')}\nOr merge:    ${colors.cyan('relq pull --merge')} (preserve local edits)\nOr force:    ${colors.cyan('relq pull --force')} (discard & pull)`;
+            fatal(errorMsg, hint);
         }
     }
     try {
@@ -254,6 +253,9 @@ export async function pullCommand(context) {
                     type: c.type,
                     definition: c.definition,
                 })),
+                isPartitioned: t.isPartitioned,
+                partitionType: t.partitionType,
+                partitionKey: normalizePartitionKey(t.partitionKey),
             })),
             enums: filteredEnums.map(e => ({
                 name: e.name,
@@ -294,12 +296,7 @@ export async function pullCommand(context) {
         console.log('');
         const mergeStatePath = path.join(projectRoot, '.relq', 'MERGE_STATE');
         if (fs.existsSync(mergeStatePath) && !force) {
-            console.log(`${colors.red('error:')} You have unresolved merge conflicts`);
-            console.log('');
-            console.log(`${colors.muted('Use')} ${colors.cyan('relq resolve')} ${colors.muted('to see and resolve conflicts')}`);
-            console.log(`${colors.muted('Or use')} ${colors.cyan('relq pull --force')} ${colors.muted('to overwrite local')}`);
-            console.log('');
-            return;
+            fatal('You have unresolved merge conflicts', `Use ${colors.cyan('relq resolve')} to see and resolve conflicts\nOr use ${colors.cyan('relq pull --force')} to overwrite local`);
         }
         if (schemaExists && localSnapshot && !force) {
             const localTables = new Set(localSnapshot.tables.map(t => t.name));
@@ -314,7 +311,6 @@ export async function pullCommand(context) {
                     createdAt: new Date().toISOString(),
                 };
                 fs.writeFileSync(mergeStatePath, JSON.stringify(mergeState, null, 2));
-                console.log(`${colors.red('error:')} Merge conflict detected`);
                 console.log('');
                 console.log(`Both local and remote have modified the same objects:`);
                 console.log('');
@@ -326,17 +322,10 @@ export async function pullCommand(context) {
                 if (conflicts.length > 10) {
                     console.log(`   ${colors.muted(`... and ${conflicts.length - 10} more`)}`);
                 }
-                console.log('');
-                console.log('To resolve:');
-                console.log(`  ${colors.cyan('relq resolve --theirs <name>')}  Take remote version`);
-                console.log(`  ${colors.cyan('relq resolve --ours <name>')}    Keep local version`);
-                console.log(`  ${colors.cyan('relq resolve --all-theirs')}     Take all remote`);
-                console.log(`  ${colors.cyan('relq pull --force')}             Force overwrite local`);
-                console.log('');
-                return;
+                fatal('Automatic merge failed; fix conflicts and then commit', `${colors.cyan('relq resolve --theirs <name>')}  Take remote version\n${colors.cyan('relq resolve --all-theirs')}     Take all remote\n${colors.cyan('relq pull --force')}             Force overwrite local`);
             }
             if (added.length === 0 && removed.length === 0) {
-                console.log(`${colors.green('✓')} Already up to date with remote`);
+                console.log('Already up to date with remote');
                 console.log('');
                 return;
             }
@@ -349,40 +338,49 @@ export async function pullCommand(context) {
             }
             console.log('');
             if (!dryRun) {
-                const proceed = await askConfirm(`${colors.bold('Pull these changes?')}`, true);
+                const proceed = await confirm(`${colors.bold('Pull these changes?')}`, true);
                 if (!proceed) {
-                    console.log('');
-                    console.log(`${colors.muted('Cancelled.')}`);
-                    return;
+                    fatal('Operation cancelled by user');
                 }
                 console.log('');
             }
         }
         else if (schemaExists && !force) {
-            console.log(`${colors.yellow('⚠')}  ${colors.bold('Local schema exists but not tracked')}`);
+            warning('Local schema exists but not tracked');
             console.log('');
             console.log(`   ${colors.cyan(schemaPath)}`);
             console.log('');
             if (!dryRun) {
-                const proceed = await askConfirm(`${colors.bold('Overwrite local schema?')}`, false);
+                const proceed = await confirm(`${colors.bold('Overwrite local schema?')}`, false);
                 if (!proceed) {
-                    console.log('');
-                    console.log(`${colors.muted('Cancelled. Run')} ${colors.cyan('relq status')} ${colors.muted('to see current state.')}`);
-                    return;
+                    fatal('Operation cancelled by user', `Run ${colors.cyan('relq status')} to see current state.`);
                 }
                 console.log('');
             }
         }
         else if (!schemaExists) {
-            console.log(`${colors.cyan('ℹ')}  ${colors.bold('First pull - creating schema')}`);
+            console.log('First pull - creating schema');
             console.log('');
-            console.log(`📊 ${colors.bold('Schema Summary')}`);
+            const indexCount = filteredTables.reduce((sum, t) => sum + (t.indexes?.filter(i => !i.isPrimary).length || 0), 0);
+            const partitionCount = filteredTables.filter(t => t.isPartitioned).length;
+            const tableCommentCount = filteredTables.filter(t => t.comment).length;
+            const columnCommentCount = filteredTables.reduce((sum, t) => sum + t.columns.filter(c => c.comment).length, 0);
+            console.log('Schema Summary:');
             console.log(`   ${colors.green(String(filteredTables.length))} tables`);
-            console.log(`   ${colors.green(String(dbSchema.extensions.length))} extensions`);
+            if (indexCount > 0)
+                console.log(`   ${colors.green(String(indexCount))} indexes`);
+            if (partitionCount > 0)
+                console.log(`   ${colors.green(String(partitionCount))} partitioned tables`);
+            if (tableCommentCount > 0)
+                console.log(`   ${colors.green(String(tableCommentCount))} table comments`);
+            if (columnCommentCount > 0)
+                console.log(`   ${colors.green(String(columnCommentCount))} column comments`);
+            if (dbSchema.extensions.length > 0)
+                console.log(`   ${colors.green(String(dbSchema.extensions.length))} extensions`);
             console.log('');
         }
         if (dryRun) {
-            console.log(`${colors.yellow('⚠')} Dry run - no files written`);
+            console.log('Dry run - no files written');
             console.log('');
             return;
         }
@@ -404,26 +402,138 @@ export async function pullCommand(context) {
         fs.writeFileSync(schemaPath, typescript, 'utf-8');
         const fileSize = Buffer.byteLength(typescript, 'utf8');
         spinner.succeed(`Written ${colors.cyan(schemaPath)} ${colors.muted(`(${formatBytes(fileSize)})`)}`);
-        const snapshotFromFile = parseSchemaFileForSnapshot(schemaPath);
-        if (snapshotFromFile) {
-            saveSnapshot(snapshotFromFile, projectRoot);
+        const fileHash = hashFileContent(typescript);
+        saveFileHash(fileHash, projectRoot);
+        const oldSnapshot = loadSnapshot(projectRoot);
+        const beforeSchema = oldSnapshot ? {
+            extensions: oldSnapshot.extensions?.map(e => e.name) || [],
+            enums: oldSnapshot.enums || [],
+            domains: oldSnapshot.domains?.map(d => ({
+                name: d.name,
+                baseType: d.baseType,
+                isNotNull: d.notNull,
+                defaultValue: d.default,
+                checkExpression: d.check,
+            })) || [],
+            compositeTypes: oldSnapshot.compositeTypes || [],
+            sequences: oldSnapshot.sequences || [],
+            tables: oldSnapshot.tables.map(t => ({
+                name: t.name,
+                schema: t.schema,
+                columns: t.columns.map(c => ({
+                    name: c.name,
+                    dataType: c.type,
+                    isNullable: c.nullable,
+                    defaultValue: c.default,
+                    isPrimaryKey: c.primaryKey,
+                    isUnique: c.unique,
+                    comment: c.comment,
+                })),
+                indexes: t.indexes.map(i => ({
+                    name: i.name,
+                    columns: i.columns,
+                    isUnique: i.unique,
+                    type: i.type,
+                })),
+                constraints: t.constraints || [],
+                isPartitioned: t.isPartitioned,
+                partitionType: t.partitionType,
+                partitionKey: t.partitionKey,
+                comment: t.comment,
+            })),
+            functions: oldSnapshot.functions || [],
+            triggers: oldSnapshot.triggers || [],
+        } : {
+            extensions: [],
+            enums: [],
+            domains: [],
+            compositeTypes: [],
+            sequences: [],
+            tables: [],
+            functions: [],
+            triggers: [],
+        };
+        const afterSchema = {
+            extensions: dbSchema.extensions || [],
+            enums: filteredEnums || [],
+            domains: filteredDomains?.map(d => ({
+                name: d.name,
+                baseType: d.baseType,
+                isNotNull: d.isNotNull,
+                defaultValue: d.defaultValue,
+                checkExpression: d.checkExpression,
+            })) || [],
+            compositeTypes: filteredCompositeTypes || [],
+            sequences: [],
+            tables: filteredTables.map(t => ({
+                name: t.name,
+                schema: t.schema,
+                columns: t.columns.map(c => ({
+                    name: c.name,
+                    dataType: c.dataType,
+                    isNullable: c.isNullable,
+                    defaultValue: c.defaultValue,
+                    isPrimaryKey: c.isPrimaryKey,
+                    isUnique: c.isUnique,
+                    comment: c.comment,
+                })),
+                indexes: t.indexes.map(i => ({
+                    name: i.name,
+                    columns: i.columns,
+                    isUnique: i.isUnique,
+                    type: i.type,
+                })),
+                constraints: t.constraints || [],
+                isPartitioned: t.isPartitioned,
+                partitionType: t.partitionType,
+                partitionKey: t.partitionKey,
+                childPartitions: t.childPartitions,
+                comment: t.comment,
+            })),
+            functions: filteredFunctions || [],
+            triggers: filteredTriggers || [],
+        };
+        const schemaChanges = compareSchemas(beforeSchema, afterSchema);
+        saveSnapshot(currentSchema, projectRoot);
+        const duration = Date.now() - startTime;
+        if (noCommit) {
+            if (schemaChanges.length > 0) {
+                addUnstagedChanges(schemaChanges, projectRoot);
+                spinner.succeed(`Detected ${schemaChanges.length} schema change(s)`);
+            }
+            console.log('');
+            console.log(`Pull completed in ${formatDuration(duration)}`);
+            if (schemaChanges.length > 0) {
+                console.log('');
+                console.log(`${colors.green(String(schemaChanges.length))} change(s) ready to stage`);
+                console.log(`hint: run ${colors.cyan("'relq add .'")} to stage all changes`);
+            }
+            else {
+                console.log('Already up to date');
+            }
         }
         else {
-            saveSnapshot(currentSchema, projectRoot);
+            const connectionDesc = getConnectionDescription(connection);
+            const commitMessage = `pull: sync from ${connectionDesc}`;
+            const commit = createCommit(currentSchema, author, commitMessage, projectRoot);
+            clearWorkingState(projectRoot);
+            console.log('');
+            console.log(`Pull completed in ${formatDuration(duration)}`);
+            console.log('');
+            console.log(`${colors.yellow('→')} ${shortHash(commit.hash)} ${commitMessage}`);
+            console.log(`  ${colors.green(String(commit.stats.tables))} tables, ${colors.green(String(commit.stats.columns))} columns`);
+            if (stashedSchemaContent) {
+                fs.writeFileSync(schemaPath, stashedSchemaContent, 'utf-8');
+                console.log('');
+                console.log(`${colors.yellow('Restored')} local schema file content`);
+                console.log(`hint: run ${colors.cyan("'relq add .'")} to detect changes against the new snapshot`);
+            }
         }
-        spinner.start('Creating commit...');
-        const message = localHead ? 'Pulled schema from database' : 'Initial schema pull';
-        const commit = createCommit(currentSchema, author, message, projectRoot);
-        spinner.succeed(`Created commit ${colors.yellow(shortHash(commit.hash))}`);
-        const duration = Date.now() - startTime;
-        console.log('');
-        console.log(`${colors.green('✓')} Pull completed in ${colors.cyan(`${duration}ms`)}`);
         console.log('');
     }
-    catch (error) {
+    catch (err) {
         spinner.fail('Pull failed');
-        console.error(colors.red(`Error: ${error instanceof Error ? error.message : error}`));
-        process.exit(1);
+        fatal(err instanceof Error ? err.message : String(err));
     }
 }
 function detectObjectConflicts(local, remote) {