relq 1.0.0 → 1.0.2

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

@@ -1,7 +1,7 @@
 import { requireValidConfig } from "../utils/config-loader.js";
 import { getConnectionDescription } from "../utils/env-loader.js";
 import { colors, createSpinner } from "../utils/spinner.js";
-import { isInitialized, getHead, loadCommit, saveCommit, setFetchHead, shortHash, fetchRemoteCommits, ensureRemoteTable, } from "../utils/repo-manager.js";
+import { isInitialized, getHead, loadCommit, saveCommit, setFetchHead, fetchRemoteCommits, ensureRemoteTable, } from "../utils/repo-manager.js";
 export async function fetchCommand(context) {
     const { config, flags } = context;
     if (!config) {
@@ -41,10 +41,25 @@ export async function fetchCommand(context) {
         setFetchHead(latestRemote.hash, projectRoot);
         spinner.succeed(`Fetched ${remoteCommits.length} commits (${newCommits} new)`);
         const localHead = getHead(projectRoot);
-        if (localHead && latestRemote.hash !== localHead) {
-            console.log('');
-            console.log(`${colors.muted('From')} ${getConnectionDescription(connection)}`);
-            console.log(`   ${shortHash(localHead)}..${shortHash(latestRemote.hash)}  ${colors.muted('main -> origin/main')}`);
+        const localCommits = localHead ? getAllLocalCommitHashes(projectRoot) : new Set();
+        const remoteHashes = new Set(remoteCommits.map(c => c.hash));
+        const behind = remoteCommits.filter(c => !localCommits.has(c.hash)).length;
+        const ahead = [...localCommits].filter(h => !remoteHashes.has(h)).length;
+        console.log('');
+        if (behind > 0 && ahead > 0) {
+            console.log(`Your branch and 'origin/main' have diverged.`);
+            console.log(`  ${colors.yellow(String(ahead))} commit(s) ahead, ${colors.yellow(String(behind))} commit(s) behind`);
+        }
+        else if (behind > 0) {
+            console.log(`Your branch is ${colors.yellow(String(behind))} commit(s) behind 'origin/main'.`);
+            console.log(`  ${colors.muted('Use')} ${colors.cyan('relq pull')} ${colors.muted('to update.')}`);
+        }
+        else if (ahead > 0) {
+            console.log(`Your branch is ${colors.green(String(ahead))} commit(s) ahead of 'origin/main'.`);
+            console.log(`  ${colors.muted('Use')} ${colors.cyan('relq push')} ${colors.muted('to publish.')}`);
+        }
+        else {
+            console.log(`${colors.green('✓')} Your branch is up to date with 'origin/main'.`);
         }
     }
     catch (error) {
@@ -54,3 +69,18 @@ export async function fetchCommand(context) {
     }
     console.log('');
 }
+function getAllLocalCommitHashes(projectRoot) {
+    const fs = require('fs');
+    const path = require('path');
+    const commitsDir = path.join(projectRoot, '.relq', 'commits');
+    const hashes = new Set();
+    if (fs.existsSync(commitsDir)) {
+        const files = fs.readdirSync(commitsDir);
+        for (const file of files) {
+            if (file.endsWith('.json')) {
+                hashes.add(file.replace('.json', ''));
+            }
+        }
+    }
+    return hashes;
+}

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

@@ -87,7 +87,7 @@ function getMigrationFiles(migrationsDir) {
         .sort();
 }
 async function getAppliedMigrations(connection, tableName) {
-    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/import.js

@@ -5,6 +5,7 @@ import { generateTypeScript } from "../utils/type-generator.js";
 import { saveSnapshot, loadSnapshot, isInitialized, initRepository, stageChanges, addUnstagedChanges } from "../utils/repo-manager.js";
 import { compareSchemas } from "../utils/schema-comparator.js";
 import { getChangeDisplayName } from "../utils/change-tracker.js";
+import { loadRelqignore, validateIgnoreDependencies, isTableIgnored, isColumnIgnored, isIndexIgnored, isConstraintIgnored, isEnumIgnored, isDomainIgnored, isSequenceIgnored, isCompositeTypeIgnored, isFunctionIgnored, } from "../utils/relqignore.js";
 import { colors, error, fatal, warning, hint, getWorkingTreeStatus, printDirtyWorkingTreeError, printMergeStrategyHelp, readSQLFile, createSpinner, formatBytes, } from "../utils/git-utils.js";
 export async function importCommand(sqlFilePath, options = {}) {
     const { includeFunctions = false, includeTriggers = false, force = false, dryRun = false } = options;
@@ -108,26 +109,143 @@ export async function importCommand(sqlFilePath, options = {}) {
         }
     }
     console.log('');
+    const ignorePatterns = loadRelqignore(projectRoot);
+    let ignoredCount = 0;
+    const filteredTables = parsedSchema.tables.filter(table => {
+        if (isTableIgnored(table.name, ignorePatterns).ignored) {
+            ignoredCount++;
+            return false;
+        }
+        return true;
+    }).map(table => {
+        const filteredColumns = table.columns.filter(col => {
+            if (isColumnIgnored(table.name, col.name, ignorePatterns).ignored) {
+                ignoredCount++;
+                return false;
+            }
+            return true;
+        });
+        const filteredIndexes = table.indexes.filter(idx => {
+            if (isIndexIgnored(table.name, idx.name, ignorePatterns).ignored) {
+                ignoredCount++;
+                return false;
+            }
+            return true;
+        });
+        const filteredConstraints = table.constraints.filter(con => {
+            if (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 (isEnumIgnored(e.name, ignorePatterns).ignored) {
+            ignoredCount++;
+            return false;
+        }
+        return true;
+    });
+    const filteredDomains = parsedSchema.domains.filter(d => {
+        if (isDomainIgnored(d.name, ignorePatterns).ignored) {
+            ignoredCount++;
+            return false;
+        }
+        return true;
+    });
+    const filteredCompositeTypes = parsedSchema.compositeTypes.filter(c => {
+        if (isCompositeTypeIgnored(c.name, ignorePatterns).ignored) {
+            ignoredCount++;
+            return false;
+        }
+        return true;
+    });
+    const filteredSequences = parsedSchema.sequences.filter(s => {
+        if (isSequenceIgnored(s.name, ignorePatterns).ignored) {
+            ignoredCount++;
+            return false;
+        }
+        return true;
+    });
+    const filteredFunctions = functions.filter(f => {
+        if (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(`${colors.gray(`ℹ ${ignoredCount} object(s) ignored by .relqignore`)}`);
+    }
+    const dependencyErrors = 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();
+        error('Dependency validation failed:');
+        console.log('');
+        for (const depError of dependencyErrors) {
+            console.log(`  ${colors.red('✗')} ${depError.message}`);
+        }
+        console.log('');
+        hint('Either un-ignore the type or add the column to .relqignore');
+        process.exit(1);
+    }
     spinner.start('Generating TypeScript schema');
-    const dbSchema = convertToDbSchema(parsedSchema, functions, triggers, comments);
+    const dbSchema = convertToDbSchema(filteredSchema, filteredFunctions, triggers, comments);
     const typescriptContent = 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 = 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 = compareSchemas(beforeSchema, afterSchema);
         spinner.stop();
         if (changes.length > 0) {
             console.log('');
-            console.log(`${colors.bold('Changes detected:')}`);
+            console.log(`${colors.bold('Changes detected:')}${replaceAll ? colors.yellow(' (--theirs: full replacement)') : ''}`);
             console.log('');
             const creates = changes.filter(c => c.type === 'CREATE');
             const alters = changes.filter(c => c.type === 'ALTER');
@@ -149,11 +267,17 @@ export async function importCommand(sqlFilePath, options = {}) {
                 }
             }
             if (drops.length > 0) {
-                for (const change of drops.slice(0, 10)) {
-                    console.log(`\t${colors.red(getChangeDisplayName(change))}`);
+                if (replaceAll) {
+                    for (const change of drops.slice(0, 10)) {
+                        console.log(`\t${colors.red(getChangeDisplayName(change))}`);
+                    }
+                    if (drops.length > 10) {
+                        console.log(`\t${colors.gray(`... and ${drops.length - 10} more deletions`)}`);
+                    }
                 }
-                if (drops.length > 10) {
-                    console.log(`\t${colors.gray(`... and ${drops.length - 10} more deletions`)}`);
+                else {
+                    console.log('');
+                    console.log(`${colors.gray(`ℹ ${drops.length} object(s) only in existing schema (preserved)`)}`);
                 }
             }
             console.log('');
@@ -165,15 +289,22 @@ export async function importCommand(sqlFilePath, options = {}) {
         }
     }
     else {
+        mergedSchema = incomingSchema;
         changes = [];
         console.log(`${colors.cyan('First import')} - creating initial snapshot`);
     }
+    const mergedDbSchema = snapshotToDbSchemaForGeneration(mergedSchema);
+    const finalTypescriptContent = generateTypeScript(mergedDbSchema, {
+        camelCase: true,
+        includeFunctions,
+        includeTriggers,
+    });
     if (dryRun) {
         console.log('');
         console.log(`${colors.yellow('Dry run mode')} - no files written`);
         console.log('');
         console.log('Would write:');
-        console.log(`  ${colors.cyan(options.output || './db/schema.ts')} ${colors.gray(`(${formatBytes(typescriptContent.length)})`)}`);
+        console.log(`  ${colors.cyan(options.output || './db/schema.ts')} ${colors.gray(`(${formatBytes(finalTypescriptContent.length)})`)}`);
         console.log(`  ${colors.cyan('.relq/snapshot.json')}`);
         if (changes.length > 0) {
             console.log(`  Stage ${changes.length} change(s)`);
@@ -187,9 +318,9 @@ export async function importCommand(sqlFilePath, options = {}) {
     if (!fs.existsSync(outputDir)) {
         fs.mkdirSync(outputDir, { recursive: true });
     }
-    fs.writeFileSync(absoluteOutputPath, typescriptContent, 'utf-8');
-    console.log(`Written ${colors.cyan(outputPath)} ${colors.gray(`(${formatBytes(typescriptContent.length)})`)}`);
-    saveSnapshot(normalizedSchema, projectRoot);
+    fs.writeFileSync(absoluteOutputPath, finalTypescriptContent, 'utf-8');
+    console.log(`Written ${colors.cyan(outputPath)} ${colors.gray(`(${formatBytes(finalTypescriptContent.length)})`)}`);
+    saveSnapshot(mergedSchema, projectRoot);
     if (changes.length > 0) {
         addUnstagedChanges(changes, projectRoot);
         stageChanges(['.'], projectRoot);
@@ -406,6 +537,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) {
@@ -485,4 +627,133 @@ 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,
+        })) || [],
+        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 || []),
+    };
+}
 export default importCommand;

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

@@ -56,4 +56,78 @@ export async function logCommand(context) {
         console.log('');
     }
 }
+export async function showCommand(context) {
+    const { args } = context;
+    const projectRoot = process.cwd();
+    const target = args[0];
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        console.log(`${colors.red('fatal:')} not a relq repository`);
+        return;
+    }
+    if (!target) {
+        console.log(`${colors.red('error:')} Please specify a commit or tag`);
+        console.log('');
+        console.log(`Usage: ${colors.cyan('relq show <commit|tag>')}`);
+        console.log('');
+        return;
+    }
+    const fs = require('fs');
+    const path = require('path');
+    const { resolveRef, loadCommit } = require('../utils/repo-manager');
+    const hash = resolveRef(target, projectRoot);
+    if (!hash) {
+        console.log(`${colors.red('error:')} Commit or tag not found: ${target}`);
+        console.log('');
+        console.log('Available commits:');
+        const commitsDir = path.join(projectRoot, '.relq', 'commits');
+        if (fs.existsSync(commitsDir)) {
+            const files = fs.readdirSync(commitsDir);
+            for (const f of files.slice(0, 5)) {
+                console.log(`   ${colors.yellow(shortHash(f.replace('.json', '')))}`);
+            }
+        }
+        return;
+    }
+    const commitPath = path.join(projectRoot, '.relq', 'commits', `${hash}.json`);
+    if (!fs.existsSync(commitPath)) {
+        console.log(`${colors.red('error:')} Commit not found: ${hash}`);
+        return;
+    }
+    const commitData = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+    console.log(`${colors.yellow(`commit ${commitData.hash}`)}`);
+    console.log(`Author: ${commitData.author}`);
+    console.log(`Date:   ${formatDate(commitData.timestamp)}`);
+    console.log('');
+    console.log(`    ${commitData.message}`);
+    console.log('');
+    if (commitData.stats) {
+        console.log(`${colors.bold('Stats:')}`);
+        console.log(`    Tables:  ${commitData.stats.tables}`);
+        console.log(`    Columns: ${commitData.stats.columns}`);
+        console.log(`    Indexes: ${commitData.stats.indexes || 0}`);
+        console.log('');
+    }
+    if (commitData.changes && commitData.changes.length > 0) {
+        console.log(`${colors.bold('Changes:')}`);
+        for (const change of commitData.changes.slice(0, 20)) {
+            const symbol = change.action === 'CREATE'
+                ? colors.green('+')
+                : change.action === 'DROP'
+                    ? colors.red('-')
+                    : colors.yellow('~');
+            console.log(`    ${symbol} ${change.objectType.toLowerCase()}: ${change.name}`);
+        }
+        if (commitData.changes.length > 20) {
+            console.log(`    ${colors.muted(`... and ${commitData.changes.length - 20} more`)}`);
+        }
+        console.log('');
+    }
+    if (commitData.sql && commitData.sql.trim()) {
+        console.log(`${colors.bold('SQL:')}`);
+        console.log('');
+        console.log(`${colors.cyan(commitData.sql)}`);
+        console.log('');
+    }
+}
 export { logCommand as historyCommand };