relq 1.0.1 → 1.0.3

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

@@ -1,14 +1,15 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { introspectDatabase } from "../utils/schema-introspect.js";
-import { createSpinner, colors } from "../utils/spinner.js";
+import { createSpinner, colors, warning } from "../utils/spinner.js";
 import { isInitialized, getStagedChanges, getUnstagedChanges, loadSnapshot, } from "../utils/repo-manager.js";
 import { generateCombinedSQL, sortChangesByDependency, getChangeDisplayName, } from "../utils/change-tracker.js";
 import { generateFullSchemaSQL } from "../utils/sql-generator.js";
+import { loadRelqignore, isTableIgnored, isColumnIgnored, isIndexIgnored, isConstraintIgnored, isEnumIgnored, isDomainIgnored, isSequenceIgnored, isCompositeTypeIgnored, isFunctionIgnored, } from "../utils/relqignore.js";
+import { loadConfig } from "../../config/config.js";
 export async function exportCommand(context) {
     const spinner = createSpinner();
-    const { args, flags } = context;
-    const projectRoot = process.cwd();
+    const { args, flags, projectRoot } = context;
     const changesOnly = Boolean(flags['changes']);
     const stagedOnly = Boolean(flags['staged']);
     const fromDb = Boolean(flags['db']);
@@ -46,7 +47,18 @@ async function exportFromSnapshot(projectRoot, absoluteOutputPath, options) {
         return;
     }
     spinner.succeed('Loaded snapshot');
-    const schema = normalizedToDbSchema(snapshot);
+    const config = await loadConfig();
+    const ignorePatterns = loadRelqignore(projectRoot);
+    const filteredSnapshot = filterNormalizedSchema(snapshot, ignorePatterns, {
+        includeFunctions: config.includeFunctions ?? options.includeFunctions ?? false,
+        includeTriggers: config.includeTriggers ?? options.includeTriggers ?? false,
+        includeViews: config.includeViews ?? false,
+        includeFDW: config.includeFDW ?? false,
+    });
+    const schema = normalizedToDbSchema(filteredSnapshot);
+    const ignoredCount = (snapshot.tables.length - filteredSnapshot.tables.length) +
+        (snapshot.enums.length - filteredSnapshot.enums.length) +
+        ((snapshot.functions?.length || 0) - (filteredSnapshot.functions?.length || 0));
     console.log('');
     console.log(colors.cyan('Schema Summary:'));
     console.log(`  ${colors.green('•')} Tables: ${schema.tables.length}`);
@@ -55,11 +67,14 @@ async function exportFromSnapshot(projectRoot, absoluteOutputPath, options) {
     console.log(`  ${colors.green('•')} Composite Types: ${schema.compositeTypes.length}`);
     console.log(`  ${colors.green('•')} Sequences: ${schema.sequences?.length || 0}`);
     console.log(`  ${colors.green('•')} Extensions: ${schema.extensions.length}`);
-    if (snapshot.functions?.length) {
-        console.log(`  ${colors.green('•')} Functions: ${snapshot.functions.length}`);
+    if (filteredSnapshot.functions?.length) {
+        console.log(`  ${colors.green('•')} Functions: ${filteredSnapshot.functions.length}`);
+    }
+    if (filteredSnapshot.triggers?.length) {
+        console.log(`  ${colors.green('•')} Triggers: ${filteredSnapshot.triggers.length}`);
     }
-    if (snapshot.triggers?.length) {
-        console.log(`  ${colors.green('•')} Triggers: ${snapshot.triggers.length}`);
+    if (ignoredCount > 0) {
+        console.log(`  ${colors.muted(`${ignoredCount} object(s) filtered by .relqignore`)}`);
     }
     spinner.start('Generating SQL statements');
     const sqlContent = generateFullSQL(schema, options);
@@ -71,7 +86,7 @@ async function exportFromSnapshot(projectRoot, absoluteOutputPath, options) {
     fs.writeFileSync(absoluteOutputPath, sqlContent, 'utf-8');
     spinner.succeed(`Written ${options.output} (${(sqlContent.length / 1024).toFixed(1)} KB)`);
     console.log('');
-    console.log(colors.green('✓ Export completed!'));
+    console.log('Export completed');
     console.log(`  Source: ${colors.muted('snapshot (local)')}`);
     console.log(`  Output: ${colors.muted(options.output || '')}`);
 }
@@ -111,7 +126,7 @@ async function exportFromDatabase(context, absoluteOutputPath, options) {
         fs.writeFileSync(absoluteOutputPath, sqlContent, 'utf-8');
         spinner.succeed(`Written ${options.output} (${(sqlContent.length / 1024).toFixed(1)} KB)`);
         console.log('');
-        console.log(colors.green('✓ Export completed!'));
+        console.log('Export completed');
         console.log(`  Source: ${colors.muted('database (live)')}`);
         console.log(`  Output: ${colors.muted(options.output || '')}`);
     }
@@ -197,6 +212,7 @@ function normalizedToDbSchema(normalized) {
             cycle: s.cycle,
             ownedBy: s.ownedBy || undefined,
         })),
+        collations: [],
         extensions: normalized.extensions.map(e => e.name),
         functions: (normalized.functions || []).map(f => ({
             name: f.name,
@@ -244,7 +260,7 @@ async function exportChanges(projectRoot, flags, args, stagedOnly) {
         modeLabel = 'uncommitted';
     }
     if (changes.length === 0) {
-        console.log(`${colors.yellow('⚠')} No ${modeLabel} changes to export`);
+        warning(`No ${modeLabel} changes to export`);
         console.log('');
         if (stagedOnly) {
             console.log(`${colors.muted('Run')} ${colors.cyan('relq add .')} ${colors.muted('to stage changes.')}`);
@@ -273,7 +289,7 @@ async function exportChanges(projectRoot, flags, args, stagedOnly) {
         fs.mkdirSync(outputDir, { recursive: true });
     }
     fs.writeFileSync(absoluteOutputPath, sqlContent, 'utf-8');
-    console.log(`${colors.green('✓')} Exported ${changes.length} ${modeLabel} change(s) to ${outputPath}`);
+    console.log(`Exported ${changes.length} ${modeLabel} change(s) to ${outputPath}`);
     console.log(`${colors.muted(`${(sqlContent.length / 1024).toFixed(1)} KB`)}`);
     console.log('');
 }
@@ -294,4 +310,47 @@ function generateFullSQL(schema, options) {
         headerComment: header,
     });
 }
+function filterNormalizedSchema(schema, patterns, options) {
+    const filteredTables = schema.tables
+        .filter(table => !isTableIgnored(table.name, patterns).ignored)
+        .map(table => ({
+        ...table,
+        columns: table.columns.filter(col => !isColumnIgnored(table.name, col.name, patterns).ignored),
+        indexes: table.indexes.filter(idx => !isIndexIgnored(table.name, idx.name, patterns).ignored),
+        constraints: table.constraints?.filter(con => !isConstraintIgnored(table.name, con.name, patterns).ignored) || [],
+    }));
+    const filteredEnums = schema.enums.filter(e => !isEnumIgnored(e.name, patterns).ignored);
+    const filteredDomains = schema.domains.filter(d => !isDomainIgnored(d.name, patterns).ignored);
+    const filteredCompositeTypes = schema.compositeTypes.filter(c => !isCompositeTypeIgnored(c.name, patterns).ignored);
+    const filteredSequences = schema.sequences.filter(s => !isSequenceIgnored(s.name, patterns).ignored);
+    const filteredFunctions = options.includeFunctions
+        ? (schema.functions || []).filter(f => !isFunctionIgnored(f.name, patterns).ignored)
+        : [];
+    const filteredTriggers = options.includeTriggers
+        ? schema.triggers || []
+        : [];
+    const filteredViews = options.includeViews
+        ? schema.views || []
+        : [];
+    const filteredMaterializedViews = options.includeViews
+        ? schema.materializedViews || []
+        : [];
+    const filteredForeignTables = options.includeFDW
+        ? schema.foreignTables || []
+        : [];
+    return {
+        extensions: schema.extensions,
+        enums: filteredEnums,
+        domains: filteredDomains,
+        compositeTypes: filteredCompositeTypes,
+        sequences: filteredSequences,
+        collations: schema.collations,
+        tables: filteredTables,
+        functions: filteredFunctions,
+        triggers: filteredTriggers,
+        views: filteredViews,
+        materializedViews: filteredMaterializedViews,
+        foreignTables: filteredForeignTables,
+    };
+}
 export default exportCommand;

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

@@ -1,22 +1,18 @@
 import { requireValidConfig } from "../utils/config-loader.js";
 import { getConnectionDescription } from "../utils/env-loader.js";
-import { colors, createSpinner } from "../utils/spinner.js";
-import { isInitialized, getHead, loadCommit, saveCommit, setFetchHead, shortHash, fetchRemoteCommits, ensureRemoteTable, } from "../utils/repo-manager.js";
+import { colors, createSpinner, fatal, hint } from "../utils/cli-utils.js";
+import { isInitialized, getHead, loadCommit, saveCommit, setFetchHead, fetchRemoteCommits, ensureRemoteTable, } from "../utils/repo-manager.js";
 export async function fetchCommand(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`);
     }
-    requireValidConfig(config);
+    await requireValidConfig(config, { calledFrom: 'fetch' });
     const connection = config.connection;
-    const projectRoot = process.cwd();
+    const { projectRoot } = context;
     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;
+        fatal('not a relq repository (or any parent directories): .relq', "run 'relq init' to initialize");
     }
     const spinner = createSpinner();
     spinner.start(`Fetching from ${getConnectionDescription(connection)}...`);
@@ -25,8 +21,7 @@ export async function fetchCommand(context) {
         const remoteCommits = await fetchRemoteCommits(connection, 100);
         if (remoteCommits.length === 0) {
             spinner.succeed('No remote commits found');
-            console.log('');
-            console.log(`${colors.muted('Run')} ${colors.cyan('relq push')} ${colors.muted('to push your commits.')}`);
+            hint("run 'relq push' to push your commits");
             return;
         }
         let newCommits = 0;
@@ -41,16 +36,45 @@ export async function fetchCommand(context) {
         setFetchHead(latestRemote.hash, projectRoot);
         spinner.succeed(`Fetched ${remoteCommits.length} commits (${newCommits} new)`);
         const localHead = getHead(projectRoot);
-        if (localHead && latestRemote.hash !== localHead) {
-            console.log('');
-            console.log(`${colors.muted('From')} ${getConnectionDescription(connection)}`);
-            console.log(`   ${shortHash(localHead)}..${shortHash(latestRemote.hash)}  ${colors.muted('main -> origin/main')}`);
+        const localCommits = localHead ? getAllLocalCommitHashes(projectRoot) : new Set();
+        const remoteHashes = new Set(remoteCommits.map(c => c.hash));
+        const behind = remoteCommits.filter(c => !localCommits.has(c.hash)).length;
+        const ahead = [...localCommits].filter(h => !remoteHashes.has(h)).length;
+        console.log('');
+        if (behind > 0 && ahead > 0) {
+            console.log(`Your branch and 'origin/main' have diverged,`);
+            console.log(`and have ${ahead} and ${behind} different commits each, respectively.`);
+        }
+        else if (behind > 0) {
+            console.log(`Your branch is behind 'origin/main' by ${behind} commit(s).`);
+            hint("run 'relq pull' to update your local branch");
+        }
+        else if (ahead > 0) {
+            console.log(`Your branch is ahead of 'origin/main' by ${ahead} commit(s).`);
+            hint("run 'relq push' to publish your local commits");
+        }
+        else {
+            console.log("Your branch is up to date with 'origin/main'.");
         }
     }
     catch (error) {
         spinner.fail('Fetch failed');
-        console.error(colors.red(`Error: ${error instanceof Error ? error.message : error}`));
-        process.exit(1);
+        fatal('Fetch failed', error instanceof Error ? error.message : String(error));
     }
     console.log('');
 }
+function getAllLocalCommitHashes(projectRoot) {
+    const fs = require('fs');
+    const path = require('path');
+    const commitsDir = path.join(projectRoot, '.relq', 'commits');
+    const hashes = new Set();
+    if (fs.existsSync(commitsDir)) {
+        const files = fs.readdirSync(commitsDir);
+        for (const file of files) {
+            if (file.endsWith('.json')) {
+                hashes.add(file.replace('.json', ''));
+            }
+        }
+    }
+    return hashes;
+}

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

@@ -8,32 +8,7 @@ import { diffSchemas, filterDiff, hasDestructiveChanges, getDestructiveTables }
 import { normalizeSchema } from "../utils/schema-hash.js";
 import { generateMigrationFile, getNextMigrationNumber, generateTimestampedName } from "../utils/migration-generator.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 askConfirm(question, defaultYes = false) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    const suffix = defaultYes ? '[Y/n]' : '[y/N]';
-    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');
-        });
-    });
-}
+import { colors, confirm, fatal, warning } from "../utils/cli-utils.js";
 function askInput(question) {
     const rl = readline.createInterface({
         input: process.stdin,
@@ -49,10 +24,10 @@ function askInput(question) {
 export async function generateCommand(context) {
     const { config, args, 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: 'generate' });
     const connection = config.connection;
     const migrationsDir = config.migrations?.directory || './migrations';
     const snapshotPath = config.sync?.snapshot || '.relq/snapshot.json';
@@ -75,10 +50,10 @@ export async function generateCommand(context) {
         migrationName = message.replace(/\s+/g, '_').toLowerCase();
     }
     if (!migrationName && !isEmpty) {
-        migrationName = await askInput(`${colors.cyan}Migration name:${colors.reset} `);
+        migrationName = await askInput('Migration name: ');
         if (!migrationName) {
-            console.error('Error: Migration name is required.');
-            process.exit(1);
+            fatal('Migration name is required');
+            return;
         }
     }
     if (isEmpty) {
@@ -86,48 +61,48 @@ export async function generateCommand(context) {
         await createEmptyMigration(migrationsDir, migrationName, format, dryRun);
         return;
     }
-    console.log(`${colors.bold}Generating migration...${colors.reset}`);
+    console.log('Generating migration...');
     console.log(`   Connection: ${getConnectionDescription(connection)}`);
     console.log('');
     try {
         const dbSchema = await introspectDatabase(connection);
         const snapshot = loadSnapshot(snapshotPath);
         if (!snapshot) {
-            console.log(`${colors.yellow}No snapshot found.${colors.reset}`);
-            console.log(`Run "${colors.cyan}relq pull${colors.reset}" first to create initial snapshot.`);
+            warning('No snapshot found.');
+            console.log('Run "relq pull" first to create initial snapshot.');
             return;
         }
         const localSchema = snapshotToDatabaseSchema(snapshot);
         const diff = diffSchemas(normalizeSchema(localSchema), normalizeSchema(dbSchema));
         const filteredDiff = filterDiff(diff, ignorePatterns);
         if (!filteredDiff.hasChanges) {
-            console.log(`${colors.green}No changes to generate.${colors.reset}`);
+            console.log('No changes to generate.');
             return;
         }
         const s = filteredDiff.summary;
-        console.log(`${colors.bold}Changes to include:${colors.reset}`);
+        console.log('Changes to include:');
         if (s.tablesAdded > 0)
-            console.log(`  ${colors.green}+ ${s.tablesAdded} table(s)${colors.reset}`);
+            console.log(`  + ${s.tablesAdded} table(s)`);
         if (s.tablesRemoved > 0)
-            console.log(`  ${colors.red}- ${s.tablesRemoved} table(s)${colors.reset}`);
+            console.log(`  - ${s.tablesRemoved} table(s)`);
         if (s.tablesModified > 0)
-            console.log(`  ${colors.yellow}~ ${s.tablesModified} table(s) modified${colors.reset}`);
+            console.log(`  ~ ${s.tablesModified} table(s) modified`);
         if (s.columnsAdded > 0)
-            console.log(`  ${colors.green}+ ${s.columnsAdded} column(s)${colors.reset}`);
+            console.log(`  + ${s.columnsAdded} column(s)`);
         if (s.columnsRemoved > 0)
-            console.log(`  ${colors.red}- ${s.columnsRemoved} column(s)${colors.reset}`);
+            console.log(`  - ${s.columnsRemoved} column(s)`);
         if (s.columnsModified > 0)
-            console.log(`  ${colors.yellow}~ ${s.columnsModified} column(s)${colors.reset}`);
+            console.log(`  ~ ${s.columnsModified} column(s)`);
         console.log('');
         if (hasDestructiveChanges(filteredDiff)) {
             const tables = getDestructiveTables(filteredDiff);
-            console.log(`${colors.red}${colors.bold}⚠️  Destructive changes:${colors.reset}`);
+            warning('Destructive changes:');
             for (const t of tables) {
-                console.log(`   ${colors.red}• ${t}${colors.reset}`);
+                console.log(`   - ${t}`);
             }
             console.log('');
             if (!autoStage) {
-                const proceed = await askConfirm('Include destructive changes?', false);
+                const proceed = await confirm('Include destructive changes?', false);
                 if (!proceed) {
                     console.log('Cancelled.');
                     return;
@@ -149,7 +124,7 @@ export async function generateCommand(context) {
         }
         const filePath = path.join(migrationsDir, fileName);
         if (dryRun) {
-            console.log(`${colors.cyan}[dry-run] Would create: ${filePath}${colors.reset}`);
+            console.log(`[dry-run] Would create: ${filePath}`);
             console.log('');
             console.log('--- Generated SQL ---');
             console.log(migrationFile.content);
@@ -160,16 +135,15 @@ export async function generateCommand(context) {
                 fs.mkdirSync(migrationsDir, { recursive: true });
             }
             fs.writeFileSync(filePath, migrationFile.content, 'utf-8');
-            console.log(`${colors.green}✓ Created:${colors.reset} ${filePath}`);
+            console.log(`Created: ${filePath}`);
             saveSnapshot(dbSchema, snapshotPath, connection.database);
-            console.log(`${colors.dim}Updated snapshot.${colors.reset}`);
+            console.log('Updated snapshot.');
         }
         console.log('');
-        console.log(`${colors.dim}Run "relq push" to apply this migration.${colors.reset}`);
+        console.log('Run "relq push" to apply this migration.');
     }
     catch (error) {
-        console.error('Error:', error instanceof Error ? error.message : error);
-        process.exit(1);
+        fatal('Generation failed', error instanceof Error ? error.message : String(error));
     }
 }
 async function createEmptyMigration(migrationsDir, name, format, dryRun) {
@@ -194,13 +168,13 @@ async function createEmptyMigration(migrationsDir, name, format, dryRun) {
 
 `;
     if (dryRun) {
-        console.log(`${colors.cyan}[dry-run] Would create: ${filePath}${colors.reset}`);
+        console.log(`[dry-run] Would create: ${filePath}`);
     }
     else {
         if (!fs.existsSync(migrationsDir)) {
             fs.mkdirSync(migrationsDir, { recursive: true });
         }
         fs.writeFileSync(filePath, content, 'utf-8');
-        console.log(`${colors.green}✓ Created empty migration:${colors.reset} ${filePath}`);
+        console.log(`Created empty migration: ${filePath}`);
     }
 }

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

@@ -1,27 +1,19 @@
 import * as fs from 'fs';
 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',
-};
+import { colors, fatal } from "../utils/cli-utils.js";
+import { withPool } from "../utils/pool-manager.js";
 export async function historyCommand(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`);
     }
-    requireValidConfig(config);
+    await requireValidConfig(config, { calledFrom: 'history' });
     const connection = config.connection;
     const migrationsDir = config.migrations?.directory || './migrations';
     const tableName = config.migrations?.tableName || '_relq_migrations';
     const limit = parseInt(flags['n']) || 20;
-    console.log(`${colors.bold}Migration History${colors.reset}`);
+    console.log('Migration History');
     console.log(`Database: ${getConnectionDescription(connection)}`);
     console.log('');
     try {
@@ -40,8 +32,8 @@ export async function historyCommand(context) {
         const toShow = history.slice(0, limit);
         const pendingCount = history.filter(h => h.pending).length;
         const appliedCount = history.filter(h => !h.pending).length;
-        console.log(`${colors.dim}Showing ${toShow.length} of ${history.length} migrations${colors.reset}`);
-        console.log(`${colors.green}${appliedCount} applied${colors.reset}, ${colors.yellow}${pendingCount} pending${colors.reset}`);
+        console.log(`Showing ${toShow.length} of ${history.length} migrations`);
+        console.log(`${appliedCount} applied, ${pendingCount} pending`);
         console.log('');
         for (const record of toShow) {
             if (record.pending) {
@@ -74,8 +66,7 @@ export async function historyCommand(context) {
             }
             return;
         }
-        console.error('Error:', error instanceof Error ? error.message : error);
-        process.exit(1);
+        fatal('Failed to load history', error instanceof Error ? error.message : String(error));
     }
 }
 function getMigrationFiles(migrationsDir) {
@@ -87,29 +78,17 @@ function getMigrationFiles(migrationsDir) {
         .sort();
 }
 async function getAppliedMigrations(connection, tableName) {
-    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 {
+    return withPool(connection, async (pool) => {
         const result = await pool.query(`
             SELECT name, applied_at 
             FROM "${tableName}" 
             ORDER BY id DESC;
         `);
-        return result.rows.map(r => ({
+        return result.rows.map((r) => ({
             name: r.name,
             appliedAt: new Date(r.applied_at),
         }));
-    }
-    finally {
-        await pool.end();
-    }
+    });
 }
 function formatDate(date) {
     const now = new Date();