relq 1.0.1 → 1.0.3

package/dist/cjs/cli/commands/history.cjs

@@ -37,27 +37,19 @@ exports.historyCommand = historyCommand;
 const fs = __importStar(require("fs"));
 const config_loader_1 = require("../utils/config-loader.cjs");
 const env_loader_1 = require("../utils/env-loader.cjs");
-const colors = {
-    reset: '\x1b[0m',
-    bold: '\x1b[1m',
-    dim: '\x1b[2m',
-    red: '\x1b[31m',
-    green: '\x1b[32m',
-    yellow: '\x1b[33m',
-    cyan: '\x1b[36m',
-};
+const cli_utils_1 = require("../utils/cli-utils.cjs");
+const pool_manager_1 = require("../utils/pool-manager.cjs");
 async function historyCommand(context) {
     const { config, flags } = context;
     if (!config) {
-        console.error('Error: No configuration found.');
-        process.exit(1);
+        (0, cli_utils_1.fatal)('No configuration found', `run ${cli_utils_1.colors.cyan('relq init')} to create a configuration file`);
     }
-    (0, config_loader_1.requireValidConfig)(config);
+    await (0, config_loader_1.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: ${(0, env_loader_1.getConnectionDescription)(connection)}`);
     console.log('');
     try {
@@ -76,42 +68,41 @@ 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) {
-                console.log(`${colors.yellow}○ ${record.name}${colors.reset} ${colors.dim}(pending)${colors.reset}`);
+                console.log(`${cli_utils_1.colors.yellow}○ ${record.name}${cli_utils_1.colors.reset} ${cli_utils_1.colors.dim}(pending)${cli_utils_1.colors.reset}`);
             }
             else {
                 const date = record.appliedAt ? formatDate(record.appliedAt) : '';
-                console.log(`${colors.green}● ${record.name}${colors.reset} ${colors.dim}${date}${colors.reset}`);
+                console.log(`${cli_utils_1.colors.green}● ${record.name}${cli_utils_1.colors.reset} ${cli_utils_1.colors.dim}${date}${cli_utils_1.colors.reset}`);
             }
         }
         if (history.length > limit) {
             console.log('');
-            console.log(`${colors.dim}Use "relq history -n ${history.length}" to see all.${colors.reset}`);
+            console.log(`${cli_utils_1.colors.dim}Use "relq history -n ${history.length}" to see all.${cli_utils_1.colors.reset}`);
         }
     }
     catch (error) {
         if (error?.code === '42P01') {
-            console.log(`${colors.yellow}No migration table found.${colors.reset}`);
-            console.log(`Run "${colors.cyan}relq push${colors.reset}" to initialize.`);
+            console.log(`${cli_utils_1.colors.yellow}No migration table found.${cli_utils_1.colors.reset}`);
+            console.log(`Run "${cli_utils_1.colors.cyan}relq push${cli_utils_1.colors.reset}" to initialize.`);
             console.log('');
             const files = getMigrationFiles(migrationsDir);
             if (files.length > 0) {
-                console.log(`${colors.bold}Pending migrations:${colors.reset}`);
+                console.log(`${cli_utils_1.colors.bold}Pending migrations:${cli_utils_1.colors.reset}`);
                 for (const file of files.slice(0, limit)) {
-                    console.log(`  ${colors.yellow}○ ${file}${colors.reset}`);
+                    console.log(`  ${cli_utils_1.colors.yellow}○ ${file}${cli_utils_1.colors.reset}`);
                 }
             }
             else {
-                console.log(`${colors.dim}No migration files found.${colors.reset}`);
+                console.log(`${cli_utils_1.colors.dim}No migration files found.${cli_utils_1.colors.reset}`);
             }
             return;
         }
-        console.error('Error:', error instanceof Error ? error.message : error);
-        process.exit(1);
+        (0, cli_utils_1.fatal)('Failed to load history', error instanceof Error ? error.message : String(error));
     }
 }
 function getMigrationFiles(migrationsDir) {
@@ -123,29 +114,17 @@ function getMigrationFiles(migrationsDir) {
         .sort();
 }
 async function getAppliedMigrations(connection, tableName) {
-    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 {
+    return (0, pool_manager_1.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();

package/dist/cjs/cli/commands/import.cjs

@@ -41,27 +41,24 @@ const type_generator_1 = require("../utils/type-generator.cjs");
 const repo_manager_1 = require("../utils/repo-manager.cjs");
 const schema_comparator_1 = require("../utils/schema-comparator.cjs");
 const change_tracker_1 = require("../utils/change-tracker.cjs");
+const relqignore_1 = require("../utils/relqignore.cjs");
 const git_utils_1 = require("../utils/git-utils.cjs");
-async function importCommand(sqlFilePath, options = {}) {
+async function importCommand(sqlFilePath, options = {}, projectRoot = process.cwd()) {
     const { includeFunctions = false, includeTriggers = false, force = false, dryRun = false } = options;
-    const projectRoot = process.cwd();
     const spinner = (0, git_utils_1.createSpinner)();
     console.log('');
     if (!sqlFilePath) {
-        (0, git_utils_1.error)('No SQL file specified.');
-        console.log('');
-        console.log('usage: relq import <sql-file> [options]');
-        console.log('');
-        console.log('Options:');
-        console.log('    --output <path>       Output schema file path');
-        console.log('    --force               Force import, overwrite local changes');
-        console.log('    --dry-run             Preview changes without applying');
-        console.log('    --theirs              Accept all incoming changes');
-        console.log('    --ours                Keep all local changes (reject incoming)');
-        console.log('    --abort               Abort the import operation');
-        console.log('    --include-functions   Include functions in import');
-        console.log('    --include-triggers    Include triggers in import');
-        process.exit(1);
+        (0, git_utils_1.fatal)('No SQL file specified', 'usage: relq import <sql-file> [options]\n\n' +
+            'Options:\n' +
+            '    --output <path>       Output schema file path\n' +
+            '    --force               Force import, overwrite local changes\n' +
+            '    --dry-run             Preview changes without applying\n' +
+            '    --theirs              Accept all incoming changes\n' +
+            '    --ours                Keep all local changes (reject incoming)\n' +
+            '    --abort               Abort the import operation\n' +
+            '    --include-functions   Include functions in import\n' +
+            '    --include-triggers    Include triggers in import');
+        return;
     }
     if (options.abort) {
         console.log('Aborting import...');
@@ -84,11 +81,8 @@ async function importCommand(sqlFilePath, options = {}) {
         (0, git_utils_1.warning)(warn);
     }
     if (!validation.valid) {
-        (0, git_utils_1.error)('Invalid PostgreSQL SQL file:');
-        for (const err of validation.errors) {
-            console.log(`  - ${err}`);
-        }
-        process.exit(1);
+        (0, git_utils_1.fatal)('Invalid PostgreSQL SQL file', validation.errors.join('\n  - '));
+        return;
     }
     console.log(`Importing ${git_utils_1.colors.cyan(path.basename(sqlFilePath))} ${git_utils_1.colors.gray(`(${(0, git_utils_1.formatBytes)(sqlContent.length)})`)}`);
     console.log('');
@@ -103,7 +97,8 @@ async function importCommand(sqlFilePath, options = {}) {
             (0, git_utils_1.printDirtyWorkingTreeError)(status, 'import');
             console.log('');
             (0, git_utils_1.printMergeStrategyHelp)();
-            process.exit(1);
+            (0, git_utils_1.fatal)('Working tree is not clean', 'Commit or stash your changes before importing.');
+            return;
         }
     }
     spinner.start('Parsing SQL schema');
@@ -144,26 +139,138 @@ async function importCommand(sqlFilePath, options = {}) {
         }
     }
     console.log('');
+    const ignorePatterns = (0, relqignore_1.loadRelqignore)(projectRoot);
+    let ignoredCount = 0;
+    const filteredTables = parsedSchema.tables.filter(table => {
+        if ((0, relqignore_1.isTableIgnored)(table.name, ignorePatterns).ignored) {
+            ignoredCount++;
+            return false;
+        }
+        return true;
+    }).map(table => {
+        const filteredColumns = table.columns.filter(col => {
+            if ((0, relqignore_1.isColumnIgnored)(table.name, col.name, ignorePatterns).ignored) {
+                ignoredCount++;
+                return false;
+            }
+            return true;
+        });
+        const filteredIndexes = table.indexes.filter(idx => {
+            if ((0, relqignore_1.isIndexIgnored)(table.name, idx.name, ignorePatterns).ignored) {
+                ignoredCount++;
+                return false;
+            }
+            return true;
+        });
+        const filteredConstraints = table.constraints.filter(con => {
+            if ((0, relqignore_1.isConstraintIgnored)(table.name, con.name, ignorePatterns).ignored) {
+                ignoredCount++;
+                return false;
+            }
+            return true;
+        });
+        return {
+            ...table,
+            columns: filteredColumns,
+            indexes: filteredIndexes,
+            constraints: filteredConstraints,
+        };
+    });
+    const filteredEnums = parsedSchema.enums.filter(e => {
+        if ((0, relqignore_1.isEnumIgnored)(e.name, ignorePatterns).ignored) {
+            ignoredCount++;
+            return false;
+        }
+        return true;
+    });
+    const filteredDomains = parsedSchema.domains.filter(d => {
+        if ((0, relqignore_1.isDomainIgnored)(d.name, ignorePatterns).ignored) {
+            ignoredCount++;
+            return false;
+        }
+        return true;
+    });
+    const filteredCompositeTypes = parsedSchema.compositeTypes.filter(c => {
+        if ((0, relqignore_1.isCompositeTypeIgnored)(c.name, ignorePatterns).ignored) {
+            ignoredCount++;
+            return false;
+        }
+        return true;
+    });
+    const filteredSequences = parsedSchema.sequences.filter(s => {
+        if ((0, relqignore_1.isSequenceIgnored)(s.name, ignorePatterns).ignored) {
+            ignoredCount++;
+            return false;
+        }
+        return true;
+    });
+    const filteredFunctions = functions.filter(f => {
+        if ((0, relqignore_1.isFunctionIgnored)(f.name, ignorePatterns).ignored) {
+            ignoredCount++;
+            return false;
+        }
+        return true;
+    });
+    const filteredSchema = {
+        tables: filteredTables,
+        enums: filteredEnums,
+        domains: filteredDomains,
+        compositeTypes: filteredCompositeTypes,
+        sequences: filteredSequences,
+        collations: parsedSchema.collations,
+        foreignTables: parsedSchema.foreignTables,
+        views: parsedSchema.views,
+        materializedViews: parsedSchema.materializedViews,
+        foreignServers: parsedSchema.foreignServers,
+        extensions: parsedSchema.extensions,
+        partitions: parsedSchema.partitions,
+    };
+    if (ignoredCount > 0) {
+        console.log(`${ignoredCount} object(s) ignored by .relqignore`);
+    }
+    const dependencyErrors = (0, relqignore_1.validateIgnoreDependencies)({
+        tables: filteredTables.map(t => ({
+            name: t.name,
+            columns: t.columns.map(c => ({
+                name: c.name,
+                type: c.dataType,
+                default: c.defaultValue,
+            })),
+        })),
+        enums: parsedSchema.enums,
+        domains: parsedSchema.domains,
+        sequences: parsedSchema.sequences,
+        compositeTypes: parsedSchema.compositeTypes,
+    }, ignorePatterns);
+    if (dependencyErrors.length > 0) {
+        spinner.stop();
+        const errorMessages = dependencyErrors.map(e => e.message).join('\n  ');
+        (0, git_utils_1.fatal)('Dependency validation failed', `${errorMessages}\n\nEither un-ignore the type or add the column to .relqignore`);
+        return;
+    }
     spinner.start('Generating TypeScript schema');
-    const dbSchema = convertToDbSchema(parsedSchema, functions, triggers, comments);
+    const dbSchema = convertToDbSchema(filteredSchema, filteredFunctions, triggers, comments);
     const typescriptContent = (0, type_generator_1.generateTypeScript)(dbSchema, {
         camelCase: true,
         includeFunctions,
         includeTriggers,
     });
     spinner.succeed('Generated TypeScript schema');
-    const normalizedSchema = convertToNormalizedSchema(parsedSchema, functions, triggers);
+    const incomingSchema = convertToNormalizedSchema(filteredSchema, filteredFunctions, triggers);
     const existingSnapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
+    const replaceAll = options.theirs === true;
+    let mergedSchema;
     let changes = [];
     if (existingSnapshot) {
         spinner.start('Detecting changes');
+        mergedSchema = mergeSchemas(existingSnapshot, incomingSchema, replaceAll);
         const beforeSchema = snapshotToDbSchema(existingSnapshot);
-        const afterSchema = snapshotToDbSchema(normalizedSchema);
+        const afterSchema = snapshotToDbSchema(mergedSchema);
         changes = (0, schema_comparator_1.compareSchemas)(beforeSchema, afterSchema);
         spinner.stop();
         if (changes.length > 0) {
             console.log('');
-            console.log(`${git_utils_1.colors.bold('Changes detected:')}`);
+            console.log(`${git_utils_1.colors.bold('Changes detected:')}${replaceAll ? git_utils_1.colors.yellow(' (--theirs: full replacement)') : ''}`);
             console.log('');
             const creates = changes.filter(c => c.type === 'CREATE');
             const alters = changes.filter(c => c.type === 'ALTER');
@@ -185,11 +292,17 @@ async function importCommand(sqlFilePath, options = {}) {
                 }
             }
             if (drops.length > 0) {
-                for (const change of drops.slice(0, 10)) {
-                    console.log(`\t${git_utils_1.colors.red((0, change_tracker_1.getChangeDisplayName)(change))}`);
+                if (replaceAll) {
+                    for (const change of drops.slice(0, 10)) {
+                        console.log(`\t${git_utils_1.colors.red((0, change_tracker_1.getChangeDisplayName)(change))}`);
+                    }
+                    if (drops.length > 10) {
+                        console.log(`\t${git_utils_1.colors.gray(`... and ${drops.length - 10} more deletions`)}`);
+                    }
                 }
-                if (drops.length > 10) {
-                    console.log(`\t${git_utils_1.colors.gray(`... and ${drops.length - 10} more deletions`)}`);
+                else {
+                    console.log('');
+                    console.log(`${drops.length} object(s) only in existing schema (preserved)`);
                 }
             }
             console.log('');
@@ -201,16 +314,25 @@ async function importCommand(sqlFilePath, options = {}) {
         }
     }
     else {
+        mergedSchema = incomingSchema;
         changes = [];
         console.log(`${git_utils_1.colors.cyan('First import')} - creating initial snapshot`);
     }
+    const mergedDbSchema = snapshotToDbSchemaForGeneration(mergedSchema);
+    const finalTypescriptContent = (0, type_generator_1.generateTypeScript)(mergedDbSchema, {
+        camelCase: true,
+        includeFunctions,
+        includeTriggers,
+    });
     if (dryRun) {
         console.log('');
         console.log(`${git_utils_1.colors.yellow('Dry run mode')} - no files written`);
         console.log('');
         console.log('Would write:');
-        console.log(`  ${git_utils_1.colors.cyan(options.output || './db/schema.ts')} ${git_utils_1.colors.gray(`(${(0, git_utils_1.formatBytes)(typescriptContent.length)})`)}`);
-        console.log(`  ${git_utils_1.colors.cyan('.relq/snapshot.json')}`);
+        const dryRunOutputPath = options.output || './db/schema.ts';
+        const dryRunAbsPath = path.resolve(projectRoot, dryRunOutputPath);
+        console.log(`  ${git_utils_1.colors.cyan(dryRunAbsPath)} ${git_utils_1.colors.gray(`(${(0, git_utils_1.formatBytes)(finalTypescriptContent.length)})`)}`);
+        console.log(`  ${git_utils_1.colors.cyan(path.join(projectRoot, '.relq/snapshot.json'))}`);
         if (changes.length > 0) {
             console.log(`  Stage ${changes.length} change(s)`);
         }
@@ -218,29 +340,29 @@ async function importCommand(sqlFilePath, options = {}) {
         return;
     }
     const outputPath = options.output || './db/schema.ts';
-    const absoluteOutputPath = path.resolve(outputPath);
+    const absoluteOutputPath = path.resolve(projectRoot, outputPath);
     const outputDir = path.dirname(absoluteOutputPath);
     if (!fs.existsSync(outputDir)) {
         fs.mkdirSync(outputDir, { recursive: true });
     }
-    fs.writeFileSync(absoluteOutputPath, typescriptContent, 'utf-8');
-    console.log(`Written ${git_utils_1.colors.cyan(outputPath)} ${git_utils_1.colors.gray(`(${(0, git_utils_1.formatBytes)(typescriptContent.length)})`)}`);
-    (0, repo_manager_1.saveSnapshot)(normalizedSchema, projectRoot);
+    fs.writeFileSync(absoluteOutputPath, finalTypescriptContent, 'utf-8');
+    console.log(`Written ${git_utils_1.colors.cyan(absoluteOutputPath)} ${git_utils_1.colors.gray(`(${(0, git_utils_1.formatBytes)(finalTypescriptContent.length)})`)}`);
+    (0, repo_manager_1.saveSnapshot)(mergedSchema, projectRoot);
     if (changes.length > 0) {
         (0, repo_manager_1.addUnstagedChanges)(changes, projectRoot);
         (0, repo_manager_1.stageChanges)(['.'], projectRoot);
         console.log('');
-        console.log(`${git_utils_1.colors.green('✓')} ${changes.length} change(s) staged for commit`);
+        console.log(`${changes.length} change(s) staged for commit`);
     }
     console.log('');
-    console.log(`${git_utils_1.colors.green('Import successful.')}`);
+    console.log('Import successful.');
     console.log('');
     if (changes.length > 0) {
-        (0, git_utils_1.hint)('Run "relq status" to see staged changes');
-        (0, git_utils_1.hint)('Run "relq commit -m <message>" to commit');
+        (0, git_utils_1.hint)("run 'relq status' to see staged changes");
+        (0, git_utils_1.hint)("run 'relq commit -m <message>' to commit");
     }
     else {
-        (0, git_utils_1.hint)('Run "relq status" to see current state');
+        (0, git_utils_1.hint)("run 'relq status' to see current state");
     }
     console.log('');
 }
@@ -337,6 +459,7 @@ function convertToDbSchema(parsed, functions = [], triggers = [], comments = [])
             cycle: s.cycle,
             ownedBy: s.ownedBy,
         })) || [],
+        collations: [],
         extensions: parsed.extensions,
         partitions: parsed.partitions,
         functions: functions.map(f => ({
@@ -442,6 +565,17 @@ function convertToNormalizedSchema(parsed, functions = [], triggers = []) {
             forEach: 'STATEMENT',
             functionName: t.functionName || '',
         })),
+        views: parsed.views.map(v => ({
+            name: v.name,
+            schema: v.schema || 'public',
+            definition: v.definition,
+        })),
+        materializedViews: parsed.materializedViews.map(mv => ({
+            name: mv.name,
+            schema: mv.schema || 'public',
+            definition: mv.definition,
+            withData: mv.withData ?? true,
+        })),
     };
 }
 function snapshotToDbSchema(snapshot) {
@@ -521,4 +655,134 @@ function snapshotToDbSchema(snapshot) {
         sequences: [],
     });
 }
+function snapshotToDbSchemaForGeneration(snapshot) {
+    return {
+        tables: snapshot.tables.map(t => ({
+            name: t.name,
+            schema: t.schema || 'public',
+            comment: null,
+            columns: t.columns.map(c => ({
+                name: c.name,
+                dataType: c.type,
+                udtName: c.type,
+                isNullable: c.nullable,
+                defaultValue: c.default ?? null,
+                isPrimaryKey: c.primaryKey || false,
+                isUnique: c.unique || false,
+                maxLength: null,
+                precision: null,
+                scale: null,
+                references: null,
+                comment: null,
+                isGenerated: c.isGenerated || false,
+                generationExpression: c.generationExpression || null,
+                identityGeneration: c.identity?.type || null,
+            })),
+            indexes: t.indexes.map(i => ({
+                name: i.name,
+                columns: Array.isArray(i.columns) ? i.columns : [i.columns],
+                isUnique: i.unique || false,
+                isPrimary: false,
+                type: i.type || 'btree',
+                definition: i.definition,
+                whereClause: i.whereClause,
+                comment: null,
+            })),
+            constraints: t.constraints?.map(c => ({
+                name: c.name,
+                type: c.type,
+                columns: [],
+                definition: c.definition,
+            })) || [],
+            rowCount: 0,
+            isPartitioned: t.isPartitioned || false,
+            partitionType: t.partitionType,
+            partitionKey: t.partitionKey ? [t.partitionKey].flat() : undefined,
+        })),
+        enums: snapshot.enums?.map(e => ({
+            name: e.name,
+            values: e.values,
+        })) || [],
+        domains: snapshot.domains?.map(d => ({
+            name: d.name,
+            baseType: d.baseType,
+            isNotNull: d.notNull || false,
+            defaultValue: d.default || null,
+            checkExpression: d.check || null,
+            check: d.check,
+            default: d.default,
+            notNull: d.notNull,
+        })) || [],
+        compositeTypes: snapshot.compositeTypes?.map(c => ({
+            name: c.name,
+            attributes: c.attributes || [],
+        })) || [],
+        sequences: snapshot.sequences?.map(s => ({
+            name: s.name,
+            dataType: s.dataType,
+            start: s.startValue,
+            increment: s.increment,
+            minValue: s.minValue,
+            maxValue: s.maxValue,
+            cache: s.cache,
+            cycle: s.cycle,
+            ownedBy: s.ownedBy ?? undefined,
+        })) || [],
+        collations: [],
+        extensions: (snapshot.extensions || []).map(e => typeof e === 'string' ? e : e.name),
+        partitions: [],
+        functions: snapshot.functions?.map(f => ({
+            name: f.name,
+            schema: 'public',
+            returnType: f.returnType,
+            argTypes: f.argTypes || [],
+            language: f.language,
+            definition: '',
+            isAggregate: false,
+            volatility: 'VOLATILE',
+        })) || [],
+        triggers: snapshot.triggers?.map(t => ({
+            name: t.name,
+            tableName: t.table,
+            timing: t.timing,
+            event: t.events?.[0] || '',
+            functionName: t.functionName || '',
+            definition: '',
+            isEnabled: t.isEnabled ?? true,
+        })) || [],
+        policies: [],
+        foreignServers: [],
+        foreignTables: [],
+    };
+}
+function mergeSchemas(existing, incoming, replaceAll = false) {
+    if (replaceAll) {
+        return incoming;
+    }
+    function mergeByName(existingArr, incomingArr) {
+        const incomingMap = new Map(incomingArr.map(item => [item.name, item]));
+        const resultMap = new Map();
+        for (const item of existingArr) {
+            resultMap.set(item.name, item);
+        }
+        for (const item of incomingArr) {
+            resultMap.set(item.name, item);
+        }
+        return Array.from(resultMap.values());
+    }
+    return {
+        extensions: mergeByName(existing.extensions || [], incoming.extensions || []),
+        enums: mergeByName(existing.enums || [], incoming.enums || []),
+        domains: mergeByName(existing.domains || [], incoming.domains || []),
+        compositeTypes: mergeByName(existing.compositeTypes || [], incoming.compositeTypes || []),
+        sequences: mergeByName(existing.sequences || [], incoming.sequences || []),
+        collations: mergeByName(existing.collations || [], incoming.collations || []),
+        tables: mergeByName(existing.tables || [], incoming.tables || []),
+        functions: mergeByName(existing.functions || [], incoming.functions || []),
+        triggers: mergeByName(existing.triggers || [], incoming.triggers || []),
+        views: mergeByName(existing.views || [], incoming.views || []),
+        materializedViews: mergeByName(existing.materializedViews || [], incoming.materializedViews || []),
+        foreignTables: mergeByName(existing.foreignTables || [], incoming.foreignTables || []),
+    };
+}
 exports.default = importCommand;