relq 1.0.1 → 1.0.2

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

@@ -245,8 +245,24 @@ async function pullCommand(context) {
             includeTriggers,
         });
         spinner.succeed(`Found ${dbSchema.tables.length} tables`);
-        const ignorePatterns = (0, relqignore_1.getIgnorePatterns)(projectRoot);
-        const filteredTables = (0, relqignore_1.filterIgnored)(dbSchema.tables, ignorePatterns);
+        const ignorePatterns = (0, relqignore_1.loadRelqignore)(projectRoot);
+        const filteredTables = dbSchema.tables
+            .filter(t => !(0, relqignore_1.isTableIgnored)(t.name, ignorePatterns).ignored)
+            .map(t => ({
+            ...t,
+            columns: t.columns.filter(c => !(0, relqignore_1.isColumnIgnored)(t.name, c.name, ignorePatterns).ignored),
+            indexes: t.indexes.filter(i => !(0, relqignore_1.isIndexIgnored)(t.name, i.name, ignorePatterns).ignored),
+            constraints: t.constraints.filter(c => !(0, relqignore_1.isConstraintIgnored)(t.name, c.name, ignorePatterns).ignored),
+        }));
+        const filteredEnums = dbSchema.enums.filter(e => !(0, relqignore_1.isEnumIgnored)(e.name, ignorePatterns).ignored);
+        const filteredDomains = dbSchema.domains.filter(d => !(0, relqignore_1.isDomainIgnored)(d.name, ignorePatterns).ignored);
+        const filteredCompositeTypes = dbSchema.compositeTypes.filter(c => !(0, relqignore_1.isCompositeTypeIgnored)(c.name, ignorePatterns).ignored);
+        const filteredFunctions = includeFunctions
+            ? dbSchema.functions.filter(f => !(0, relqignore_1.isFunctionIgnored)(f.name, ignorePatterns).ignored)
+            : [];
+        const filteredTriggers = includeTriggers
+            ? dbSchema.triggers
+            : [];
         const localHead = (0, repo_manager_1.getHead)(projectRoot);
         const localSnapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
         const schemaExists = fs.existsSync(schemaPath);
@@ -275,12 +291,12 @@ async function pullCommand(context) {
                     definition: c.definition,
                 })),
             })),
-            enums: dbSchema.enums.map(e => ({
+            enums: filteredEnums.map(e => ({
                 name: e.name,
                 schema: 'public',
                 values: e.values,
             })),
-            domains: dbSchema.domains.map(d => ({
+            domains: filteredDomains.map(d => ({
                 name: d.name,
                 schema: 'public',
                 baseType: d.baseType,
@@ -288,20 +304,20 @@ async function pullCommand(context) {
                 default: d.defaultValue || null,
                 check: d.checkExpression || null,
             })),
-            compositeTypes: dbSchema.compositeTypes.map(c => ({
+            compositeTypes: filteredCompositeTypes.map(c => ({
                 name: c.name,
                 schema: 'public',
                 attributes: c.attributes,
             })),
             sequences: [],
             collations: [],
-            functions: dbSchema.functions.map(f => ({
+            functions: filteredFunctions.map(f => ({
                 name: f.name,
                 returnType: f.returnType,
                 argTypes: f.argTypes,
                 language: f.language,
             })),
-            triggers: dbSchema.triggers.map(t => ({
+            triggers: filteredTriggers.map(t => ({
                 name: t.name,
                 table: t.tableName,
                 events: [t.event],
@@ -312,11 +328,49 @@ async function pullCommand(context) {
             extensions: dbSchema.extensions.map(ext => ({ name: ext })),
         };
         console.log('');
+        const mergeStatePath = path.join(projectRoot, '.relq', 'MERGE_STATE');
+        if (fs.existsSync(mergeStatePath) && !force) {
+            console.log(`${spinner_1.colors.red('error:')} You have unresolved merge conflicts`);
+            console.log('');
+            console.log(`${spinner_1.colors.muted('Use')} ${spinner_1.colors.cyan('relq resolve')} ${spinner_1.colors.muted('to see and resolve conflicts')}`);
+            console.log(`${spinner_1.colors.muted('Or use')} ${spinner_1.colors.cyan('relq pull --force')} ${spinner_1.colors.muted('to overwrite local')}`);
+            console.log('');
+            return;
+        }
         if (schemaExists && localSnapshot && !force) {
             const localTables = new Set(localSnapshot.tables.map(t => t.name));
             const remoteTables = new Set(currentSchema.tables.map(t => t.name));
             const added = [...remoteTables].filter(t => !localTables.has(t));
             const removed = [...localTables].filter(t => !remoteTables.has(t));
+            const conflicts = detectObjectConflicts(localSnapshot, currentSchema);
+            if (conflicts.length > 0 && !force) {
+                const mergeState = {
+                    conflicts,
+                    remoteSnapshot: currentSchema,
+                    createdAt: new Date().toISOString(),
+                };
+                fs.writeFileSync(mergeStatePath, JSON.stringify(mergeState, null, 2));
+                console.log(`${spinner_1.colors.red('error:')} Merge conflict detected`);
+                console.log('');
+                console.log(`Both local and remote have modified the same objects:`);
+                console.log('');
+                for (const c of conflicts.slice(0, 10)) {
+                    const name = c.parentName ? `${c.parentName}.${c.objectName}` : c.objectName;
+                    console.log(`   ${spinner_1.colors.red('conflict:')} ${c.objectType.toLowerCase()} ${spinner_1.colors.bold(name)}`);
+                    console.log(`     ${spinner_1.colors.muted(c.description)}`);
+                }
+                if (conflicts.length > 10) {
+                    console.log(`   ${spinner_1.colors.muted(`... and ${conflicts.length - 10} more`)}`);
+                }
+                console.log('');
+                console.log('To resolve:');
+                console.log(`  ${spinner_1.colors.cyan('relq resolve --theirs <name>')}  Take remote version`);
+                console.log(`  ${spinner_1.colors.cyan('relq resolve --ours <name>')}    Keep local version`);
+                console.log(`  ${spinner_1.colors.cyan('relq resolve --all-theirs')}     Take all remote`);
+                console.log(`  ${spinner_1.colors.cyan('relq pull --force')}             Force overwrite local`);
+                console.log('');
+                return;
+            }
             if (added.length === 0 && removed.length === 0) {
                 console.log(`${spinner_1.colors.green('✓')} Already up to date with remote`);
                 console.log('');
@@ -408,3 +462,65 @@ async function pullCommand(context) {
         process.exit(1);
     }
 }
+function detectObjectConflicts(local, remote) {
+    const conflicts = [];
+    for (const localTable of local.tables) {
+        const remoteTable = remote.tables.find(t => t.name === localTable.name);
+        if (!remoteTable)
+            continue;
+        for (const localCol of localTable.columns) {
+            const remoteCol = remoteTable.columns.find(c => c.name === localCol.name);
+            if (!remoteCol)
+                continue;
+            if (localCol.type !== remoteCol.type) {
+                conflicts.push({
+                    objectType: 'COLUMN',
+                    objectName: localCol.name,
+                    parentName: localTable.name,
+                    localValue: localCol.type,
+                    remoteValue: remoteCol.type,
+                    description: `Type changed: ${localCol.type} → ${remoteCol.type}`,
+                });
+            }
+            else if (localCol.nullable !== remoteCol.nullable) {
+                conflicts.push({
+                    objectType: 'COLUMN',
+                    objectName: localCol.name,
+                    parentName: localTable.name,
+                    localValue: localCol.nullable,
+                    remoteValue: remoteCol.nullable,
+                    description: `Nullable changed: ${localCol.nullable} → ${remoteCol.nullable}`,
+                });
+            }
+            else if (String(localCol.default || '') !== String(remoteCol.default || '')) {
+                if (localCol.default && remoteCol.default && localCol.default !== remoteCol.default) {
+                    conflicts.push({
+                        objectType: 'COLUMN',
+                        objectName: localCol.name,
+                        parentName: localTable.name,
+                        localValue: localCol.default,
+                        remoteValue: remoteCol.default,
+                        description: `Default changed`,
+                    });
+                }
+            }
+        }
+    }
+    for (const localEnum of local.enums) {
+        const remoteEnum = remote.enums.find(e => e.name === localEnum.name);
+        if (!remoteEnum)
+            continue;
+        const localVals = JSON.stringify(localEnum.values.sort());
+        const remoteVals = JSON.stringify(remoteEnum.values.sort());
+        if (localVals !== remoteVals) {
+            conflicts.push({
+                objectType: 'ENUM',
+                objectName: localEnum.name,
+                localValue: localEnum.values,
+                remoteValue: remoteEnum.values,
+                description: `Values differ`,
+            });
+        }
+    }
+    return conflicts;
+}

package/dist/cjs/cli/commands/push.cjs

@@ -36,9 +36,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.pushCommand = pushCommand;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
 const config_loader_1 = require("../utils/config-loader.cjs");
 const env_loader_1 = require("../utils/env-loader.cjs");
 const spinner_1 = require("../utils/spinner.cjs");
+const fast_introspect_1 = require("../utils/fast-introspect.cjs");
+const relqignore_1 = require("../utils/relqignore.cjs");
 const repo_manager_1 = require("../utils/repo-manager.cjs");
 async function pushCommand(context) {
     const { config, flags } = context;
@@ -52,6 +55,11 @@ async function pushCommand(context) {
     const force = flags['force'] === true;
     const dryRun = flags['dry-run'] === true;
     const applySQL = flags['apply'] === true;
+    const noVerify = flags['no-verify'] === true;
+    const skipPrompt = flags['yes'] === true || flags['y'] === true;
+    const includeFunctions = config.includeFunctions ?? false;
+    const includeTriggers = config.includeTriggers ?? false;
+    const includeViews = config.includeViews ?? false;
     console.log('');
     if (!(0, repo_manager_1.isInitialized)(projectRoot)) {
         console.log(`${spinner_1.colors.red('fatal:')} not a relq repository`);
@@ -71,32 +79,101 @@ async function pushCommand(context) {
         spinner.start('Connecting to remote...');
         await (0, repo_manager_1.ensureRemoteTable)(connection);
         spinner.succeed(`Connected to ${spinner_1.colors.cyan((0, env_loader_1.getConnectionDescription)(connection))}`);
-        spinner.start('Checking remote...');
+        spinner.start('Checking remote commits...');
         const remoteCommits = await (0, repo_manager_1.fetchRemoteCommits)(connection, 100);
         const remoteHead = remoteCommits.length > 0 ? remoteCommits[0].hash : null;
-        spinner.stop();
         const localCommits = (0, repo_manager_1.getAllCommits)(projectRoot);
         const remoteHashes = new Set(remoteCommits.map(c => c.hash));
         const localHashes = new Set(localCommits.map(c => c.hash));
         const toPush = localCommits.filter(c => !remoteHashes.has(c.hash));
-        if (toPush.length === 0) {
-            console.log(`${spinner_1.colors.green('✓')} Everything up-to-date`);
+        const remoteMissing = remoteCommits.filter(c => !localHashes.has(c.hash));
+        spinner.succeed('Checked remote commits');
+        spinner.start('Introspecting remote database...');
+        const remoteDb = await (0, fast_introspect_1.fastIntrospectDatabase)(connection, undefined, {
+            includeFunctions,
+            includeTriggers,
+        });
+        spinner.succeed(`Found ${remoteDb.tables.length} tables in remote`);
+        const localSnapshot = (0, repo_manager_1.loadSnapshot)(projectRoot);
+        if (!localSnapshot) {
+            console.log(`${spinner_1.colors.red('error:')} No local snapshot found`);
+            console.log(`${spinner_1.colors.muted('Run')} ${spinner_1.colors.cyan('relq pull')} ${spinner_1.colors.muted('or')} ${spinner_1.colors.cyan('relq import')} ${spinner_1.colors.muted('first.')}`);
+            return;
+        }
+        const ignorePatterns = (0, relqignore_1.loadRelqignore)(projectRoot);
+        const analysis = analyzeSync(localSnapshot, remoteDb, ignorePatterns, { includeFunctions, includeTriggers, includeViews });
+        const hasRemoteAhead = remoteMissing.length > 0;
+        const hasObjectsToDrop = analysis.objectsToDrop.length > 0;
+        const hasSchemaDrift = analysis.schemaDrift.length > 0;
+        if (hasRemoteAhead && !force) {
+            console.log('');
+            console.log(`${spinner_1.colors.red('error:')} Remote has ${remoteMissing.length} commit(s) you don't have locally`);
+            console.log('');
+            for (const commit of remoteMissing.slice(0, 3)) {
+                console.log(`   ${spinner_1.colors.yellow((0, repo_manager_1.shortHash)(commit.hash))} ${commit.message}`);
+            }
+            if (remoteMissing.length > 3) {
+                console.log(`   ${spinner_1.colors.muted(`... and ${remoteMissing.length - 3} more`)}`);
+            }
+            console.log('');
+            console.log(`${spinner_1.colors.yellow('hint:')} Run ${spinner_1.colors.cyan('relq pull')} to integrate remote changes.`);
+            console.log(`${spinner_1.colors.yellow('hint:')} Use ${spinner_1.colors.cyan('relq push --force')} to override (may cause data loss).`);
             console.log('');
             return;
         }
-        const remoteMissing = remoteCommits.filter(c => !localHashes.has(c.hash));
-        if (remoteMissing.length > 0 && !force) {
-            console.log(`${spinner_1.colors.red('error:')} failed to push`);
+        if (hasObjectsToDrop) {
+            console.log('');
+            console.log(`${spinner_1.colors.yellow('⚠')} Remote has ${analysis.objectsToDrop.length} object(s) not in your local schema:`);
+            console.log('');
+            for (const obj of analysis.objectsToDrop.slice(0, 10)) {
+                console.log(`   ${spinner_1.colors.red('DROP')} ${obj.type.toLowerCase()}: ${obj.name}`);
+            }
+            if (analysis.objectsToDrop.length > 10) {
+                console.log(`   ${spinner_1.colors.muted(`... and ${analysis.objectsToDrop.length - 10} more`)}`);
+            }
             console.log('');
-            console.log(`${spinner_1.colors.yellow('hint:')} Updates were rejected because the remote contains work that you do not have locally.`);
-            console.log(`${spinner_1.colors.yellow('hint:')} Run ${spinner_1.colors.cyan('relq pull')} to integrate the remote changes before pushing.`);
+            if (!force) {
+                console.log(`${spinner_1.colors.red('error:')} Cannot push - remote has objects not in your history`);
+                console.log('');
+                console.log(`${spinner_1.colors.yellow('hint:')} Run ${spinner_1.colors.cyan('relq pull')} first to sync your local schema.`);
+                console.log(`${spinner_1.colors.yellow('hint:')} Use ${spinner_1.colors.cyan('relq push --force')} to DROP these objects from remote.`);
+                console.log('');
+                return;
+            }
+            const dependencyErrors = checkDropDependencies(analysis.objectsToDrop, remoteDb, ignorePatterns);
+            if (dependencyErrors.length > 0) {
+                console.log(`${spinner_1.colors.red('error:')} Cannot drop objects due to dependencies:`);
+                console.log('');
+                for (const err of dependencyErrors) {
+                    console.log(`   ${spinner_1.colors.red('✗')} ${err}`);
+                }
+                console.log('');
+                console.log(`${spinner_1.colors.muted('These objects are used by non-ignored objects in your schema.')}`);
+                console.log(`${spinner_1.colors.muted('Either add them to .relqignore or import them with')} ${spinner_1.colors.cyan('relq pull')}`);
+                console.log('');
+                return;
+            }
+            if (!skipPrompt && !dryRun) {
+                console.log(`${spinner_1.colors.red('⚠  WARNING: This will DROP data from your database!')}`);
+                console.log('');
+                const confirmed = await askConfirmation(`Drop ${analysis.objectsToDrop.length} object(s) from remote? [y/N] `);
+                if (!confirmed) {
+                    console.log(`${spinner_1.colors.muted('Cancelled.')}`);
+                    console.log('');
+                    return;
+                }
+            }
+        }
+        if (toPush.length === 0 && !hasObjectsToDrop) {
+            console.log(`${spinner_1.colors.green('✓')} Everything up-to-date`);
             console.log('');
             return;
         }
+        console.log('');
         console.log(`Pushing to ${spinner_1.colors.cyan((0, env_loader_1.getConnectionDescription)(connection))}`);
         console.log('');
-        if (dryRun) {
-            console.log(`${spinner_1.colors.yellow('Would push')} ${toPush.length} commit(s):`);
+        if (toPush.length > 0) {
+            console.log(`${spinner_1.colors.cyan('Commits:')} ${toPush.length}`);
             for (const commit of toPush.slice(0, 5)) {
                 console.log(`   ${spinner_1.colors.yellow((0, repo_manager_1.shortHash)(commit.hash))} ${commit.message}`);
             }
@@ -104,17 +181,25 @@ async function pushCommand(context) {
                 console.log(`   ${spinner_1.colors.muted(`... and ${toPush.length - 5} more`)}`);
             }
             console.log('');
+        }
+        if (dryRun) {
+            console.log(`${spinner_1.colors.yellow('Dry run')} - no changes applied`);
+            console.log('');
+            console.log(`${spinner_1.colors.muted('Use')} ${spinner_1.colors.cyan('relq push --apply')} ${spinner_1.colors.muted('to execute.')}`);
+            console.log('');
             return;
         }
-        const commitsToProcess = [...toPush].reverse();
-        spinner.start(`Pushing ${toPush.length} commit(s)...`);
-        for (const commit of commitsToProcess) {
-            await (0, repo_manager_1.pushCommit)(connection, commit);
+        if (toPush.length > 0) {
+            const commitsToProcess = [...toPush].reverse();
+            spinner.start(`Pushing ${toPush.length} commit(s)...`);
+            for (const commit of commitsToProcess) {
+                await (0, repo_manager_1.pushCommit)(connection, commit);
+            }
+            spinner.succeed(`Pushed ${toPush.length} commit(s)`);
         }
-        spinner.succeed(`Pushed ${toPush.length} commit(s)`);
         if (applySQL) {
             spinner.start('Applying SQL changes...');
-            const pg = await Promise.resolve().then(() => __importStar(require("../../../addons/pg.js")));
+            const pg = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
             const client = new pg.Client({
                 host: connection.host,
                 port: connection.port,
@@ -124,18 +209,42 @@ async function pushCommand(context) {
             });
             try {
                 await client.connect();
+                await client.query('BEGIN');
                 let sqlExecuted = 0;
+                let statementsRun = 0;
+                if (hasObjectsToDrop && force) {
+                    for (const obj of analysis.objectsToDrop) {
+                        const dropSQL = generateDropSQL(obj);
+                        if (dropSQL) {
+                            await client.query(dropSQL);
+                            statementsRun++;
+                        }
+                    }
+                }
+                const commitsToProcess = [...toPush].reverse();
                 for (const commit of commitsToProcess) {
                     const commitPath = path.join(projectRoot, '.relq', 'commits', `${commit.hash}.json`);
                     if (fs.existsSync(commitPath)) {
                         const enhancedCommit = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
-                        if (enhancedCommit.sql) {
+                        if (enhancedCommit.sql && enhancedCommit.sql.trim()) {
                             await client.query(enhancedCommit.sql);
                             sqlExecuted++;
+                            statementsRun += enhancedCommit.sql.split(';').filter(s => s.trim()).length;
                         }
                     }
                 }
-                spinner.succeed(`Applied SQL from ${sqlExecuted} commit(s)`);
+                await client.query('COMMIT');
+                spinner.succeed(`Applied ${statementsRun} statement(s) from ${sqlExecuted} commit(s)`);
+            }
+            catch (error) {
+                try {
+                    await client.query('ROLLBACK');
+                    spinner.fail('SQL execution failed - rolled back');
+                }
+                catch {
+                    spinner.fail('SQL execution failed');
+                }
+                throw error;
             }
             finally {
                 await client.end();
@@ -144,22 +253,129 @@ async function pushCommand(context) {
         const oldHash = remoteHead ? (0, repo_manager_1.shortHash)(remoteHead) : '(none)';
         const newHash = (0, repo_manager_1.shortHash)(localHead);
         console.log(`   ${oldHash}..${newHash}  ${spinner_1.colors.muted('main -> main')}`);
-        if (!applySQL && toPush.some(c => {
-            const commitPath = path.join(projectRoot, '.relq', 'commits', `${c.hash}.json`);
-            if (fs.existsSync(commitPath)) {
-                const ec = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
-                return ec.sql && ec.sql.trim().length > 0;
-            }
-            return false;
-        })) {
+        if (hasObjectsToDrop && force && applySQL) {
+            console.log('');
+            console.log(`${spinner_1.colors.yellow('⚠')} Dropped ${analysis.objectsToDrop.length} object(s) from remote`);
+        }
+        if (!applySQL) {
             console.log('');
-            console.log(`${spinner_1.colors.muted('Use')} ${spinner_1.colors.cyan('relq push --apply')} ${spinner_1.colors.muted('to also execute SQL against database.')}`);
+            console.log(`${spinner_1.colors.muted('Use')} ${spinner_1.colors.cyan('relq push --apply')} ${spinner_1.colors.muted('to execute SQL.')}`);
         }
+        console.log('');
     }
     catch (error) {
         spinner.fail('Push failed');
         console.error(spinner_1.colors.red(`Error: ${error instanceof Error ? error.message : error}`));
         process.exit(1);
     }
-    console.log('');
 }
+function analyzeSync(local, remote, patterns, options) {
+    const objectsToDrop = [];
+    const schemaDrift = [];
+    const localTables = new Set(local.tables.map(t => t.name));
+    const localEnums = new Set(local.enums.map(e => e.name));
+    const localDomains = new Set(local.domains.map(d => d.name));
+    const localSequences = new Set(local.sequences.map(s => s.name));
+    const localFunctions = new Set((local.functions || []).map(f => f.name));
+    const localViews = new Set((local.views || []).map(v => v.name));
+    const localMViews = new Set((local.materializedViews || []).map(v => v.name));
+    for (const table of remote.tables) {
+        if ((0, relqignore_1.isTableIgnored)(table.name, patterns).ignored)
+            continue;
+        if (!localTables.has(table.name)) {
+            objectsToDrop.push({ type: 'TABLE', name: table.name });
+        }
+    }
+    for (const enumType of remote.enums) {
+        if ((0, relqignore_1.isEnumIgnored)(enumType.name, patterns).ignored)
+            continue;
+        if (!localEnums.has(enumType.name)) {
+            objectsToDrop.push({ type: 'ENUM', name: enumType.name });
+        }
+    }
+    for (const domain of remote.domains) {
+        if ((0, relqignore_1.isDomainIgnored)(domain.name, patterns).ignored)
+            continue;
+        if (!localDomains.has(domain.name)) {
+            objectsToDrop.push({ type: 'DOMAIN', name: domain.name });
+        }
+    }
+    if (options.includeFunctions) {
+        for (const func of remote.functions || []) {
+            if ((0, relqignore_1.isFunctionIgnored)(func.name, patterns).ignored)
+                continue;
+            if (!localFunctions.has(func.name)) {
+                objectsToDrop.push({ type: 'FUNCTION', name: func.name });
+            }
+        }
+    }
+    return {
+        toPush: [],
+        objectsToDrop,
+        schemaDrift,
+        remoteAhead: false,
+    };
+}
+function checkDropDependencies(objectsToDrop, remoteDb, patterns) {
+    const errors = [];
+    const droppingTables = new Set(objectsToDrop.filter(o => o.type === 'TABLE').map(o => o.name));
+    const droppingEnums = new Set(objectsToDrop.filter(o => o.type === 'ENUM').map(o => o.name));
+    const droppingDomains = new Set(objectsToDrop.filter(o => o.type === 'DOMAIN').map(o => o.name));
+    const droppingSequences = new Set(objectsToDrop.filter(o => o.type === 'SEQUENCE').map(o => o.name));
+    for (const table of remoteDb.tables) {
+        if (droppingTables.has(table.name))
+            continue;
+        if ((0, relqignore_1.isTableIgnored)(table.name, patterns).ignored)
+            continue;
+        for (const col of table.columns) {
+            if ((0, relqignore_1.isColumnIgnored)(table.name, col.name, patterns).ignored)
+                continue;
+            const colType = (col.dataType || '').toLowerCase();
+            for (const enumName of droppingEnums) {
+                if (colType.includes(enumName.toLowerCase())) {
+                    errors.push(`Cannot drop ENUM "${enumName}" - used by column "${table.name}.${col.name}"`);
+                }
+            }
+            for (const domainName of droppingDomains) {
+                if (colType.includes(domainName.toLowerCase())) {
+                    errors.push(`Cannot drop DOMAIN "${domainName}" - used by column "${table.name}.${col.name}"`);
+                }
+            }
+        }
+    }
+    return errors;
+}
+function generateDropSQL(obj) {
+    switch (obj.type) {
+        case 'TABLE':
+            return `DROP TABLE IF EXISTS "${obj.name}" CASCADE;`;
+        case 'ENUM':
+            return `DROP TYPE IF EXISTS "${obj.name}" CASCADE;`;
+        case 'DOMAIN':
+            return `DROP DOMAIN IF EXISTS "${obj.name}" CASCADE;`;
+        case 'FUNCTION':
+            return `DROP FUNCTION IF EXISTS "${obj.name}" CASCADE;`;
+        case 'VIEW':
+            return `DROP VIEW IF EXISTS "${obj.name}" CASCADE;`;
+        case 'MATERIALIZED_VIEW':
+            return `DROP MATERIALIZED VIEW IF EXISTS "${obj.name}" CASCADE;`;
+        case 'SEQUENCE':
+            return `DROP SEQUENCE IF EXISTS "${obj.name}" CASCADE;`;
+        default:
+            return '';
+    }
+}
+function askConfirmation(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(question, (answer) => {
+            rl.close();
+            const a = answer.trim().toLowerCase();
+            resolve(a === 'y' || a === 'yes');
+        });
+    });
+}
+exports.default = pushCommand;

package/dist/cjs/cli/commands/remote.cjs

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.remoteCommand = remoteCommand;
+async function remoteCommand(context) {
+    console.log('');
+    console.log('⚠️  Remote tracking is coming soon.');
+    console.log('');
+    console.log('This will allow you to:');
+    console.log('  • Track multiple remote databases');
+    console.log('  • Push/pull to different environments');
+    console.log('  • Switch between staging/production');
+    console.log('');
+    console.log('For now, configure your remote in relq.config.ts');
+    console.log('');
+}
+exports.default = remoteCommand;