relq 1.0.1 → 1.0.2

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

@@ -0,0 +1,188 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { colors, createSpinner } from "../utils/spinner.js";
+import { isInitialized, getHead, loadCommit, loadSnapshot, saveSnapshot, createCommit, shortHash, } 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 = require('../utils/repo-manager').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 mergeCommand(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 branchName = args[0];
+    const abort = flags['abort'] === true;
+    const mergeStatePath = path.join(projectRoot, '.relq', 'MERGE_STATE');
+    if (abort) {
+        if (fs.existsSync(mergeStatePath)) {
+            fs.unlinkSync(mergeStatePath);
+            console.log(`${colors.green('✓')} Merge aborted`);
+        }
+        else {
+            console.log(`${colors.muted('No merge in progress.')}`);
+        }
+        console.log('');
+        return;
+    }
+    if (fs.existsSync(mergeStatePath)) {
+        const mergeState = JSON.parse(fs.readFileSync(mergeStatePath, 'utf-8'));
+        console.log(`${colors.red('error:')} Merge in progress from '${mergeState.fromBranch}'`);
+        console.log('');
+        console.log(`${colors.muted('Use')} ${colors.cyan('relq resolve')} ${colors.muted('to resolve conflicts')}`);
+        console.log(`${colors.muted('Or')} ${colors.cyan('relq merge --abort')} ${colors.muted('to cancel')}`);
+        console.log('');
+        return;
+    }
+    if (!branchName) {
+        console.log(`${colors.red('error:')} Please specify a branch to merge`);
+        console.log('');
+        console.log(`Usage: ${colors.cyan('relq merge <branch>')}`);
+        console.log('');
+        return;
+    }
+    const state = loadBranchState(projectRoot);
+    if (!state.branches[branchName]) {
+        console.log(`${colors.red('error:')} Branch not found: ${branchName}`);
+        return;
+    }
+    if (branchName === state.current) {
+        console.log(`${colors.red('error:')} Cannot merge branch into itself`);
+        return;
+    }
+    const spinner = createSpinner();
+    spinner.start(`Merging '${branchName}' into '${state.current}'...`);
+    try {
+        const currentHash = getHead(projectRoot);
+        const incomingHash = state.branches[branchName];
+        if (!currentHash || !incomingHash) {
+            spinner.fail('No commits to merge');
+            return;
+        }
+        if (currentHash === incomingHash) {
+            spinner.succeed('Already up to date');
+            console.log('');
+            return;
+        }
+        const currentCommit = loadCommit(currentHash, projectRoot);
+        const incomingCommit = loadCommit(incomingHash, projectRoot);
+        if (!currentCommit || !incomingCommit) {
+            spinner.fail('Cannot load commit data');
+            return;
+        }
+        const currentSnapshot = loadSnapshot(projectRoot) || currentCommit.schema;
+        const incomingSnapshot = incomingCommit.schema;
+        if (!currentSnapshot || !incomingSnapshot) {
+            spinner.fail('No snapshot data');
+            return;
+        }
+        const conflicts = detectMergeConflicts(currentSnapshot, incomingSnapshot);
+        if (conflicts.length > 0) {
+            const mergeState = {
+                fromBranch: branchName,
+                toBranch: state.current,
+                conflicts,
+                incomingSnapshot,
+                createdAt: new Date().toISOString(),
+            };
+            fs.writeFileSync(mergeStatePath, JSON.stringify(mergeState, 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}`);
+            }
+            if (conflicts.length > 5) {
+                console.log(`   ${colors.muted(`... and ${conflicts.length - 5} more`)}`);
+            }
+            console.log('');
+            console.log(`${colors.muted('Use')} ${colors.cyan('relq resolve --all-theirs')} ${colors.muted('to accept incoming')}`);
+            console.log(`${colors.muted('Or')} ${colors.cyan('relq merge --abort')} ${colors.muted('to cancel')}`);
+            console.log('');
+            return;
+        }
+        const mergedSnapshot = mergeSnapshots(currentSnapshot, incomingSnapshot);
+        saveSnapshot(mergedSnapshot, projectRoot);
+        const author = config?.author || 'Relq CLI';
+        const message = `Merge branch '${branchName}' into ${state.current}`;
+        const commit = createCommit(mergedSnapshot, author, message, projectRoot);
+        spinner.succeed(`Merged '${branchName}' into '${state.current}'`);
+        console.log(`   ${colors.yellow(shortHash(commit.hash))} ${message}`);
+        console.log('');
+    }
+    catch (error) {
+        spinner.fail('Merge failed');
+        console.error(colors.red(`Error: ${error instanceof Error ? error.message : error}`));
+    }
+}
+function detectMergeConflicts(current, incoming) {
+    const conflicts = [];
+    for (const currentTable of current.tables) {
+        const incomingTable = incoming.tables.find(t => t.name === currentTable.name);
+        if (!incomingTable)
+            continue;
+        for (const currentCol of currentTable.columns) {
+            const incomingCol = incomingTable.columns.find(c => c.name === currentCol.name);
+            if (!incomingCol)
+                continue;
+            if (currentCol.type !== incomingCol.type) {
+                conflicts.push({
+                    objectType: 'COLUMN',
+                    objectName: currentCol.name,
+                    parentName: currentTable.name,
+                    currentValue: currentCol.type,
+                    incomingValue: incomingCol.type,
+                    description: `Type differs: ${currentCol.type} vs ${incomingCol.type}`,
+                });
+            }
+        }
+    }
+    for (const currentEnum of current.enums) {
+        const incomingEnum = incoming.enums.find(e => e.name === currentEnum.name);
+        if (!incomingEnum)
+            continue;
+        const currentVals = JSON.stringify(currentEnum.values.sort());
+        const incomingVals = JSON.stringify(incomingEnum.values.sort());
+        if (currentVals !== incomingVals) {
+            conflicts.push({
+                objectType: 'ENUM',
+                objectName: currentEnum.name,
+                currentValue: currentEnum.values,
+                incomingValue: incomingEnum.values,
+                description: 'Values differ',
+            });
+        }
+    }
+    return conflicts;
+}
+function mergeSnapshots(current, incoming) {
+    const result = JSON.parse(JSON.stringify(current));
+    for (const table of incoming.tables) {
+        if (!result.tables.find(t => t.name === table.name)) {
+            result.tables.push(table);
+        }
+    }
+    for (const e of incoming.enums) {
+        if (!result.enums.find(x => x.name === e.name)) {
+            result.enums.push(e);
+        }
+    }
+    for (const d of incoming.domains) {
+        if (!result.domains.find(x => x.name === d.name)) {
+            result.domains.push(d);
+        }
+    }
+    return result;
+}
+export default mergeCommand;

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

@@ -39,7 +39,7 @@ export async function migrateCommand(context) {
     console.log(`   Connection: ${getConnectionDescription(connection)}`);
     console.log(`   Migrations: ${migrationsDir}\n`);
     try {
-        const { Pool } = await import("../../addon/pg.js");
+        const { Pool } = await import("../../addon/pg/index.js");
         const pool = new Pool({
             host: connection.host,
             port: connection.port || 5432,

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

@@ -6,7 +6,7 @@ import { fastIntrospectDatabase } from "../utils/fast-introspect.js";
 import { generateTypeScript } from "../utils/type-generator.js";
 import { getConnectionDescription } from "../utils/env-loader.js";
 import { createSpinner, colors, formatBytes } from "../utils/spinner.js";
-import { getIgnorePatterns, filterIgnored } from "../utils/relqignore.js";
+import { loadRelqignore, isTableIgnored, isColumnIgnored, isIndexIgnored, isConstraintIgnored, isEnumIgnored, isDomainIgnored, isCompositeTypeIgnored, isFunctionIgnored, } from "../utils/relqignore.js";
 import { isInitialized, initRepository, getHead, saveSnapshot, loadSnapshot, createCommit, shortHash, fetchRemoteCommits, ensureRemoteTable, setFetchHead, getStagedChanges, getUnstagedChanges, } from "../utils/repo-manager.js";
 function toCamelCase(str) {
     return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
@@ -209,8 +209,24 @@ export async function pullCommand(context) {
             includeTriggers,
         });
         spinner.succeed(`Found ${dbSchema.tables.length} tables`);
-        const ignorePatterns = getIgnorePatterns(projectRoot);
-        const filteredTables = filterIgnored(dbSchema.tables, ignorePatterns);
+        const ignorePatterns = loadRelqignore(projectRoot);
+        const filteredTables = dbSchema.tables
+            .filter(t => !isTableIgnored(t.name, ignorePatterns).ignored)
+            .map(t => ({
+            ...t,
+            columns: t.columns.filter(c => !isColumnIgnored(t.name, c.name, ignorePatterns).ignored),
+            indexes: t.indexes.filter(i => !isIndexIgnored(t.name, i.name, ignorePatterns).ignored),
+            constraints: t.constraints.filter(c => !isConstraintIgnored(t.name, c.name, ignorePatterns).ignored),
+        }));
+        const filteredEnums = dbSchema.enums.filter(e => !isEnumIgnored(e.name, ignorePatterns).ignored);
+        const filteredDomains = dbSchema.domains.filter(d => !isDomainIgnored(d.name, ignorePatterns).ignored);
+        const filteredCompositeTypes = dbSchema.compositeTypes.filter(c => !isCompositeTypeIgnored(c.name, ignorePatterns).ignored);
+        const filteredFunctions = includeFunctions
+            ? dbSchema.functions.filter(f => !isFunctionIgnored(f.name, ignorePatterns).ignored)
+            : [];
+        const filteredTriggers = includeTriggers
+            ? dbSchema.triggers
+            : [];
         const localHead = getHead(projectRoot);
         const localSnapshot = loadSnapshot(projectRoot);
         const schemaExists = fs.existsSync(schemaPath);
@@ -239,12 +255,12 @@ export 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,
@@ -252,20 +268,20 @@ export 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],
@@ -276,11 +292,49 @@ export 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(`${colors.red('error:')} You have unresolved merge conflicts`);
+            console.log('');
+            console.log(`${colors.muted('Use')} ${colors.cyan('relq resolve')} ${colors.muted('to see and resolve conflicts')}`);
+            console.log(`${colors.muted('Or use')} ${colors.cyan('relq pull --force')} ${colors.muted('to overwrite local')}`);
+            console.log('');
+            return;
+        }
         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(`${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(`   ${colors.red('conflict:')} ${c.objectType.toLowerCase()} ${colors.bold(name)}`);
+                    console.log(`     ${colors.muted(c.description)}`);
+                }
+                if (conflicts.length > 10) {
+                    console.log(`   ${colors.muted(`... and ${conflicts.length - 10} more`)}`);
+                }
+                console.log('');
+                console.log('To resolve:');
+                console.log(`  ${colors.cyan('relq resolve --theirs <name>')}  Take remote version`);
+                console.log(`  ${colors.cyan('relq resolve --ours <name>')}    Keep local version`);
+                console.log(`  ${colors.cyan('relq resolve --all-theirs')}     Take all remote`);
+                console.log(`  ${colors.cyan('relq pull --force')}             Force overwrite local`);
+                console.log('');
+                return;
+            }
             if (added.length === 0 && removed.length === 0) {
                 console.log(`${colors.green('✓')} Already up to date with remote`);
                 console.log('');
@@ -372,3 +426,65 @@ export 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;
+}