relq 1.0.0 → 1.0.2

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

@@ -0,0 +1,98 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { colors } from "../utils/spinner.js";
+import { isInitialized, getHead, setHead, loadCommit, saveSnapshot, getStagedChanges, getUnstagedChanges, } from "../utils/repo-manager.js";
+function loadBranchState(projectRoot) {
+    const branchPath = path.join(projectRoot, '.relq', 'branches.json');
+    if (fs.existsSync(branchPath)) {
+        return JSON.parse(fs.readFileSync(branchPath, 'utf-8'));
+    }
+    const head = getHead(projectRoot);
+    return { current: 'main', branches: { main: head || '' } };
+}
+function saveBranchState(state, projectRoot) {
+    const branchPath = path.join(projectRoot, '.relq', 'branches.json');
+    fs.writeFileSync(branchPath, JSON.stringify(state, null, 2));
+}
+export async function checkoutCommand(context) {
+    const { args, flags } = context;
+    const projectRoot = process.cwd();
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        console.log(`${colors.red('fatal:')} not a relq repository`);
+        return;
+    }
+    const createBranch = flags['b'] === true;
+    const branchName = args[0];
+    if (!branchName) {
+        console.log(`${colors.red('error:')} Please specify a branch`);
+        console.log('');
+        console.log(`Usage: ${colors.cyan('relq checkout <branch>')}`);
+        console.log(`       ${colors.cyan('relq checkout -b <new-branch>')}`);
+        console.log('');
+        return;
+    }
+    const staged = getStagedChanges(projectRoot);
+    const unstaged = getUnstagedChanges(projectRoot);
+    if (staged.length > 0 || unstaged.length > 0) {
+        console.log(`${colors.red('error:')} You have uncommitted changes`);
+        console.log('');
+        console.log('Commit or stash them before switching branches:');
+        console.log(`  ${colors.cyan('relq commit -m "message"')}`);
+        console.log(`  ${colors.cyan('relq stash')}`);
+        console.log('');
+        return;
+    }
+    const state = loadBranchState(projectRoot);
+    if (createBranch) {
+        if (state.branches[branchName]) {
+            console.log(`${colors.red('error:')} Branch already exists: ${branchName}`);
+            return;
+        }
+        const head = getHead(projectRoot);
+        if (!head) {
+            console.log(`${colors.red('error:')} No commits yet`);
+            return;
+        }
+        state.branches[branchName] = head;
+        state.current = branchName;
+        saveBranchState(state, projectRoot);
+        console.log(`${colors.green('✓')} Switched to new branch '${branchName}'`);
+        console.log('');
+        return;
+    }
+    if (!state.branches[branchName]) {
+        console.log(`${colors.red('error:')} Branch not found: ${branchName}`);
+        console.log('');
+        console.log('Available branches:');
+        for (const name of Object.keys(state.branches)) {
+            console.log(`   ${name}`);
+        }
+        console.log('');
+        return;
+    }
+    if (state.current === branchName) {
+        console.log(`Already on '${branchName}'`);
+        console.log('');
+        return;
+    }
+    const currentHead = getHead(projectRoot);
+    if (currentHead) {
+        state.branches[state.current] = currentHead;
+    }
+    const targetHash = state.branches[branchName];
+    const targetCommit = loadCommit(targetHash, projectRoot);
+    if (!targetCommit) {
+        console.log(`${colors.red('error:')} Cannot find commit for branch`);
+        return;
+    }
+    if (targetCommit.schema) {
+        saveSnapshot(targetCommit.schema, projectRoot);
+    }
+    setHead(targetHash, projectRoot);
+    state.current = branchName;
+    saveBranchState(state, projectRoot);
+    console.log(`${colors.green('✓')} Switched to branch '${branchName}'`);
+    console.log('');
+}
+export default checkoutCommand;

package/dist/esm/cli/commands/cherry-pick.js

@@ -0,0 +1,247 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { colors, createSpinner } from "../utils/spinner.js";
+import { isInitialized, loadCommit, loadParentCommit, loadSnapshot, saveSnapshot, createCommit, shortHash, resolveRef, } from "../utils/repo-manager.js";
+export async function cherryPickCommand(context) {
+    const { config, args, flags } = context;
+    const projectRoot = process.cwd();
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        console.log(`${colors.red('fatal:')} not a relq repository`);
+        return;
+    }
+    const abort = flags['abort'] === true;
+    const cherryPickStatePath = path.join(projectRoot, '.relq', 'CHERRY_PICK_STATE');
+    if (abort) {
+        if (fs.existsSync(cherryPickStatePath)) {
+            fs.unlinkSync(cherryPickStatePath);
+            console.log(`${colors.green('✓')} Cherry-pick aborted`);
+        }
+        else {
+            console.log(`${colors.muted('No cherry-pick in progress.')}`);
+        }
+        console.log('');
+        return;
+    }
+    if (fs.existsSync(cherryPickStatePath)) {
+        const state = JSON.parse(fs.readFileSync(cherryPickStatePath, 'utf-8'));
+        console.log(`${colors.red('error:')} Cherry-pick in progress from ${shortHash(state.fromCommit)}`);
+        console.log('');
+        console.log(`${colors.muted('Use')} ${colors.cyan('relq resolve')} ${colors.muted('to resolve conflicts')}`);
+        console.log(`${colors.muted('Or')} ${colors.cyan('relq cherry-pick --abort')} ${colors.muted('to cancel')}`);
+        console.log('');
+        return;
+    }
+    const ref = args[0];
+    if (!ref) {
+        console.log(`${colors.red('error:')} Please specify a commit`);
+        console.log('');
+        console.log(`Usage: ${colors.cyan('relq cherry-pick <commit>')}`);
+        console.log('');
+        return;
+    }
+    const spinner = createSpinner();
+    spinner.start(`Cherry-picking ${shortHash(ref)}...`);
+    try {
+        const hash = resolveRef(ref, projectRoot);
+        if (!hash) {
+            spinner.fail(`Commit not found: ${ref}`);
+            return;
+        }
+        const targetCommit = loadCommit(hash, projectRoot);
+        const parentCommit = loadParentCommit(hash, projectRoot);
+        if (!targetCommit) {
+            spinner.fail('Cannot load commit');
+            return;
+        }
+        if (!parentCommit) {
+            spinner.fail('Cannot cherry-pick first commit (no parent)');
+            return;
+        }
+        const diff = calculateCommitDiff(parentCommit.schema, targetCommit.schema);
+        const currentSnapshot = loadSnapshot(projectRoot);
+        if (!currentSnapshot) {
+            spinner.fail('No snapshot found');
+            return;
+        }
+        const conflicts = detectCherryPickConflicts(currentSnapshot, diff);
+        if (conflicts.length > 0) {
+            const state = {
+                fromCommit: hash,
+                originalMessage: targetCommit.message,
+                conflicts,
+                diff,
+                createdAt: new Date().toISOString(),
+            };
+            fs.writeFileSync(cherryPickStatePath, JSON.stringify(state, null, 2));
+            spinner.fail(`${conflicts.length} conflict(s) detected`);
+            console.log('');
+            for (const c of conflicts.slice(0, 5)) {
+                const name = c.parentName ? `${c.parentName}.${c.objectName}` : c.objectName;
+                console.log(`   ${colors.red('conflict:')} ${c.objectType.toLowerCase()} ${name}`);
+                console.log(`      ${colors.muted(c.description)}`);
+            }
+            if (conflicts.length > 5) {
+                console.log(`   ${colors.muted(`... and ${conflicts.length - 5} more`)}`);
+            }
+            console.log('');
+            console.log(`${colors.muted('Use')} ${colors.cyan('relq resolve --theirs')} ${colors.muted('to resolve')}`);
+            console.log(`${colors.muted('Or')} ${colors.cyan('relq cherry-pick --abort')} ${colors.muted('to cancel')}`);
+            console.log('');
+            return;
+        }
+        const newSnapshot = applyCommitDiff(currentSnapshot, diff);
+        saveSnapshot(newSnapshot, projectRoot);
+        const author = config?.author || 'Relq CLI';
+        const message = `Cherry-picked ${shortHash(hash)}: ${targetCommit.message}`;
+        const commit = createCommit(newSnapshot, author, message, projectRoot);
+        spinner.succeed(`Cherry-picked ${colors.yellow(shortHash(hash))}`);
+        console.log(`   ${colors.cyan(commit.message)}`);
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Cherry-pick failed');
+        console.error(colors.red(`Error: ${error instanceof Error ? error.message : error}`));
+    }
+}
+function calculateCommitDiff(parent, target) {
+    const diff = {
+        tablesAdded: [],
+        tablesRemoved: [],
+        tablesModified: [],
+        enumsAdded: [],
+        enumsRemoved: [],
+        columnsAdded: [],
+        columnsRemoved: [],
+    };
+    const parentTables = new Map(parent.tables.map(t => [t.name, t]));
+    const targetTables = new Map(target.tables.map(t => [t.name, t]));
+    for (const [name, table] of targetTables) {
+        if (!parentTables.has(name)) {
+            diff.tablesAdded.push(table);
+        }
+    }
+    for (const [name] of parentTables) {
+        if (!targetTables.has(name)) {
+            diff.tablesRemoved.push(name);
+        }
+    }
+    for (const [name, targetTable] of targetTables) {
+        const parentTable = parentTables.get(name);
+        if (!parentTable)
+            continue;
+        const parentCols = new Map(parentTable.columns.map(c => [c.name, c]));
+        const targetCols = new Map(targetTable.columns.map(c => [c.name, c]));
+        const changes = { columnsAdded: [], columnsRemoved: [] };
+        for (const [colName, col] of targetCols) {
+            if (!parentCols.has(colName)) {
+                changes.columnsAdded.push(col);
+            }
+        }
+        for (const [colName] of parentCols) {
+            if (!targetCols.has(colName)) {
+                changes.columnsRemoved.push(colName);
+            }
+        }
+        if (changes.columnsAdded.length > 0 || changes.columnsRemoved.length > 0) {
+            diff.tablesModified.push({ name, changes });
+        }
+    }
+    const parentEnums = new Set(parent.enums.map(e => e.name));
+    const targetEnums = new Map(target.enums.map(e => [e.name, e]));
+    for (const [name, e] of targetEnums) {
+        if (!parentEnums.has(name)) {
+            diff.enumsAdded.push(e);
+        }
+    }
+    for (const name of parentEnums) {
+        if (!targetEnums.has(name)) {
+            diff.enumsRemoved.push(name);
+        }
+    }
+    return diff;
+}
+function detectCherryPickConflicts(current, diff) {
+    const conflicts = [];
+    for (const table of diff.tablesAdded) {
+        if (current.tables.find(t => t.name === table.name)) {
+            conflicts.push({
+                objectType: 'TABLE',
+                objectName: table.name,
+                currentValue: 'exists',
+                incomingValue: 'add',
+                description: 'Table already exists in current snapshot',
+            });
+        }
+    }
+    for (const tableName of diff.tablesRemoved) {
+        if (!current.tables.find(t => t.name === tableName)) {
+            conflicts.push({
+                objectType: 'TABLE',
+                objectName: tableName,
+                currentValue: 'missing',
+                incomingValue: 'remove',
+                description: 'Table does not exist in current snapshot',
+            });
+        }
+    }
+    for (const mod of diff.tablesModified) {
+        const currentTable = current.tables.find(t => t.name === mod.name);
+        if (!currentTable) {
+            conflicts.push({
+                objectType: 'TABLE',
+                objectName: mod.name,
+                currentValue: 'missing',
+                incomingValue: 'modify',
+                description: 'Table does not exist in current snapshot',
+            });
+            continue;
+        }
+        for (const col of mod.changes.columnsAdded) {
+            if (currentTable.columns.find(c => c.name === col.name)) {
+                conflicts.push({
+                    objectType: 'COLUMN',
+                    objectName: col.name,
+                    parentName: mod.name,
+                    currentValue: 'exists',
+                    incomingValue: 'add',
+                    description: 'Column already exists',
+                });
+            }
+        }
+    }
+    for (const e of diff.enumsAdded) {
+        if (current.enums.find(en => en.name === e.name)) {
+            conflicts.push({
+                objectType: 'ENUM',
+                objectName: e.name,
+                currentValue: 'exists',
+                incomingValue: 'add',
+                description: 'Enum already exists',
+            });
+        }
+    }
+    return conflicts;
+}
+function applyCommitDiff(snapshot, diff) {
+    const result = JSON.parse(JSON.stringify(snapshot));
+    for (const table of diff.tablesAdded) {
+        result.tables.push(table);
+    }
+    result.tables = result.tables.filter(t => !diff.tablesRemoved.includes(t.name));
+    for (const mod of diff.tablesModified) {
+        const table = result.tables.find(t => t.name === mod.name);
+        if (!table)
+            continue;
+        for (const col of mod.changes.columnsAdded) {
+            table.columns.push(col);
+        }
+        table.columns = table.columns.filter(c => !mod.changes.columnsRemoved.includes(c.name));
+    }
+    for (const e of diff.enumsAdded) {
+        result.enums.push(e);
+    }
+    result.enums = result.enums.filter(e => !diff.enumsRemoved.includes(e.name));
+    return result;
+}
+export default cherryPickCommand;

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

@@ -1,81 +1,160 @@
 import { requireValidConfig } from "../utils/config-loader.js";
-import { introspectDatabase } from "../utils/schema-introspect.js";
-import { loadSnapshot, snapshotToDatabaseSchema } from "../utils/snapshot-manager.js";
-import { formatDiff } from "../utils/schema-diff.js";
-import { normalizeSchema } from "../utils/schema-hash.js";
-import { diffSchemas } from "../utils/schema-diff.js";
-import { generateMigration } from "../utils/migration-generator.js";
+import { fastIntrospectDatabase } from "../utils/fast-introspect.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',
-    blue: '\x1b[34m',
-    cyan: '\x1b[36m',
-    magenta: '\x1b[35m',
-};
-function filterDiff(diff, ignorePatterns) {
-    const patterns = ignorePatterns.map(p => {
-        const regexStr = p.replace(/\*/g, '.*').replace(/\?/g, '.');
-        return new RegExp(`^${regexStr}$`, 'i');
-    });
-    const matchesPattern = (name) => patterns.some(p => p.test(name));
-    const tables = diff.tables.filter(t => !matchesPattern(t.name));
-    const hasChanges = tables.length > 0 || diff.extensions.length > 0;
-    return {
-        ...diff,
-        tables,
-        hasChanges,
-    };
-}
+import { colors, createSpinner } from "../utils/spinner.js";
+import { isInitialized, loadSnapshot, getStagedChanges, getUnstagedChanges, } from "../utils/repo-manager.js";
+import { getChangeDisplayName, generateChangeSQL, sortChangesByDependency } from "../utils/change-tracker.js";
 export async function diffCommand(context) {
-    const { config, flags } = context;
-    if (!config) {
-        console.error('Error: No configuration found.');
-        process.exit(1);
+    const { config, args, flags } = context;
+    const projectRoot = process.cwd();
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        console.log(`${colors.red('fatal:')} not a relq repository`);
+        console.log(`${colors.muted('Run')} ${colors.cyan('relq init')} ${colors.muted('to initialize.')}`);
+        return;
     }
-    requireValidConfig(config);
-    const connection = config.connection;
-    const snapshotPath = config.sync?.snapshot || '.relq/snapshot.json';
-    const ignorePatterns = config.sync?.ignore || ['_relq_*'];
     const showSQL = flags['sql'] === true;
-    console.log(`${colors.bold}Comparing:${colors.reset} local snapshot ↔ ${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}" to create initial snapshot.`);
-            return;
+    const staged = flags['staged'] === true;
+    const target = args[0];
+    if (staged) {
+        await showStagedDiff(projectRoot, showSQL);
+        return;
+    }
+    if (target === 'remote/live' || target === 'remote' || target === 'live' || target === 'origin') {
+        if (!config) {
+            console.error('Error: No configuration found.');
+            process.exit(1);
         }
-        const localSchema = snapshotToDatabaseSchema(snapshot);
-        const normalizedLocal = normalizeSchema(localSchema);
-        const normalizedDb = normalizeSchema(dbSchema);
-        const diff = diffSchemas(normalizedLocal, normalizedDb);
-        const filteredDiff = filterDiff(diff, ignorePatterns);
-        if (!filteredDiff.hasChanges) {
-            console.log(`${colors.green}No differences.${colors.reset}`);
-            return;
+        requireValidConfig(config);
+        await showOriginDiff(config, projectRoot, showSQL);
+        return;
+    }
+    await showUnstagedDiff(projectRoot, showSQL);
+}
+function getSymbol(change) {
+    if (change.type === 'CREATE')
+        return colors.green('+');
+    if (change.type === 'DROP')
+        return colors.red('-');
+    return colors.yellow('~');
+}
+async function showUnstagedDiff(projectRoot, showSQL) {
+    const unstaged = getUnstagedChanges(projectRoot);
+    if (unstaged.length === 0) {
+        console.log(`${colors.green('No unstaged changes.')}`);
+        console.log(`${colors.muted('Use')} ${colors.cyan('relq diff remote/live')} ${colors.muted('to compare with remote.')}`);
+        console.log('');
+        return;
+    }
+    console.log(`${colors.bold('Unstaged changes:')}`);
+    console.log('');
+    const sorted = sortChangesByDependency(unstaged);
+    for (const change of sorted) {
+        console.log(`   ${getSymbol(change)} ${change.objectType.toLowerCase()}: ${getChangeDisplayName(change)}`);
+    }
+    if (showSQL) {
+        console.log('');
+        console.log(`${colors.bold('SQL:')}`);
+        for (const change of sorted) {
+            const sql = generateChangeSQL(change);
+            if (sql)
+                console.log(`${colors.cyan(sql)}`);
         }
-        console.log(formatDiff(filteredDiff));
-        if (showSQL) {
-            console.log('');
-            console.log(`${colors.bold}Generated SQL:${colors.reset}`);
-            console.log('');
-            const { up } = generateMigration(filteredDiff, { includeDown: false });
-            for (const sql of up) {
-                console.log(`${colors.cyan}${sql}${colors.reset}`);
-            }
+    }
+    console.log('');
+    console.log(`${colors.muted('Use')} ${colors.cyan('relq add .')} ${colors.muted('to stage all.')}`);
+    console.log('');
+}
+async function showStagedDiff(projectRoot, showSQL) {
+    const staged = getStagedChanges(projectRoot);
+    if (staged.length === 0) {
+        console.log(`${colors.green('No staged changes.')}`);
+        console.log(`${colors.muted('Use')} ${colors.cyan('relq add .')} ${colors.muted('to stage changes.')}`);
+        console.log('');
+        return;
+    }
+    console.log(`${colors.bold('Staged changes:')}`);
+    console.log('');
+    const sorted = sortChangesByDependency(staged);
+    for (const change of sorted) {
+        console.log(`   ${getSymbol(change)} ${change.objectType.toLowerCase()}: ${getChangeDisplayName(change)}`);
+    }
+    if (showSQL) {
+        console.log('');
+        console.log(`${colors.bold('SQL:')}`);
+        for (const change of sorted) {
+            const sql = generateChangeSQL(change);
+            if (sql)
+                console.log(`${colors.cyan(sql)}`);
         }
+    }
+    console.log('');
+    console.log(`${colors.muted('Use')} ${colors.cyan('relq commit -m "message"')} ${colors.muted('to commit.')}`);
+    console.log('');
+}
+async function showOriginDiff(config, projectRoot, showSQL) {
+    const connection = config.connection;
+    const spinner = createSpinner();
+    const snapshot = loadSnapshot(projectRoot);
+    if (!snapshot) {
+        console.log(`${colors.yellow('No local snapshot.')}`);
+        console.log(`${colors.muted('Run')} ${colors.cyan('relq pull')} ${colors.muted('first.')}`);
+        console.log('');
+        return;
+    }
+    spinner.start(`Connecting to ${getConnectionDescription(connection)}...`);
+    const remoteDb = await fastIntrospectDatabase(connection, undefined, {
+        includeFunctions: config.includeFunctions ?? false,
+        includeTriggers: config.includeTriggers ?? false,
+    });
+    spinner.succeed(`Connected`);
+    const diffs = compareSchemas(snapshot, remoteDb);
+    if (diffs.length === 0) {
+        console.log('');
+        console.log(`${colors.green('✓ Local and remote are in sync.')}`);
         console.log('');
-        console.log(`${colors.dim}Use "relq diff --sql" to see generated SQL statements.${colors.reset}`);
+        return;
+    }
+    console.log('');
+    console.log(`${colors.bold('Differences:')}`);
+    console.log('');
+    for (const d of diffs.slice(0, 20)) {
+        const sym = d.type === 'added' ? colors.green('+') : d.type === 'removed' ? colors.red('-') : colors.yellow('~');
+        console.log(`   ${sym} ${d.description}`);
     }
-    catch (error) {
-        console.error('Error:', error instanceof Error ? error.message : error);
-        process.exit(1);
+    if (diffs.length > 20) {
+        console.log(`   ${colors.muted(`... and ${diffs.length - 20} more`)}`);
+    }
+    console.log('');
+    console.log(`${colors.muted('Use')} ${colors.cyan('relq pull')} ${colors.muted('to sync local with remote.')}`);
+    console.log('');
+}
+function compareSchemas(local, remote) {
+    const diffs = [];
+    const localTableNames = local.tables.map(t => t.name);
+    const remoteTableNames = (remote.tables || []).map((t) => t.name);
+    for (const name of remoteTableNames) {
+        if (!localTableNames.includes(name)) {
+            diffs.push({ type: 'added', description: `table: ${name}` });
+        }
+    }
+    for (const name of localTableNames) {
+        if (!remoteTableNames.includes(name)) {
+            diffs.push({ type: 'removed', description: `table: ${name}` });
+        }
+    }
+    const localEnumNames = local.enums.map(e => e.name);
+    const remoteEnumNames = (remote.enums || []).map((e) => e.name);
+    for (const name of remoteEnumNames) {
+        if (!localEnumNames.includes(name)) {
+            diffs.push({ type: 'added', description: `enum: ${name}` });
+        }
+    }
+    for (const name of localEnumNames) {
+        if (!remoteEnumNames.includes(name)) {
+            diffs.push({ type: 'removed', description: `enum: ${name}` });
+        }
     }
+    return diffs;
 }
+export default diffCommand;

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

@@ -5,6 +5,8 @@ import { createSpinner, colors } 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;
@@ -46,7 +48,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 +68,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);
@@ -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;