relq 1.0.0

package/dist/esm/cache/query-cache.js

@@ -0,0 +1,303 @@
+export class QueryCache {
+    cache = new Map();
+    options;
+    stats = { hits: 0, misses: 0, evictions: 0 };
+    constructor(options = {}) {
+        this.options = {
+            strategy: options.strategy ?? 'lru',
+            maxSize: options.maxSize ?? 100 * 1024 * 1024,
+            maxItems: options.maxItems ?? 1000,
+            ttl: options.ttl ?? 60000,
+            onEvict: options.onEvict ?? (() => { }),
+            keyGenerator: options.keyGenerator ?? this.defaultKeyGenerator
+        };
+    }
+    defaultKeyGenerator(query, params) {
+        const normalized = query.replace(/\s+/g, ' ').trim().toLowerCase();
+        const paramStr = params ? JSON.stringify(params) : '';
+        return `${normalized}::${paramStr}`;
+    }
+    generateKey(query, params) {
+        return this.options.keyGenerator(query, params);
+    }
+    get(key) {
+        const entry = this.cache.get(key);
+        if (!entry) {
+            this.stats.misses++;
+            return undefined;
+        }
+        if (this.options.strategy === 'ttl' || this.options.strategy === 'lru') {
+            const now = Date.now();
+            if (this.options.ttl > 0 && now - entry.createdAt > this.options.ttl) {
+                this.delete(key);
+                this.stats.misses++;
+                return undefined;
+            }
+        }
+        entry.accessedAt = Date.now();
+        entry.accessCount++;
+        this.stats.hits++;
+        if (this.options.strategy === 'lru') {
+            this.cache.delete(key);
+            this.cache.set(key, entry);
+        }
+        return entry.value;
+    }
+    set(key, value) {
+        const size = this.estimateSize(value);
+        this.evictIfNeeded(size);
+        const entry = {
+            value,
+            createdAt: Date.now(),
+            accessedAt: Date.now(),
+            accessCount: 1,
+            size
+        };
+        this.cache.set(key, entry);
+    }
+    has(key) {
+        const entry = this.cache.get(key);
+        if (!entry)
+            return false;
+        if (this.options.strategy === 'ttl' || this.options.strategy === 'lru') {
+            const now = Date.now();
+            if (this.options.ttl > 0 && now - entry.createdAt > this.options.ttl) {
+                this.delete(key);
+                return false;
+            }
+        }
+        return true;
+    }
+    delete(key) {
+        const entry = this.cache.get(key);
+        if (entry) {
+            this.options.onEvict(key, entry);
+            this.stats.evictions++;
+            return this.cache.delete(key);
+        }
+        return false;
+    }
+    clear() {
+        this.cache.forEach((entry, key) => {
+            this.options.onEvict(key, entry);
+        });
+        this.cache.clear();
+        this.stats.evictions = 0;
+    }
+    invalidateByPattern(pattern) {
+        let count = 0;
+        const keysToDelete = [];
+        this.cache.forEach((_, key) => {
+            if (pattern.test(key)) {
+                keysToDelete.push(key);
+            }
+        });
+        keysToDelete.forEach(key => {
+            this.delete(key);
+            count++;
+        });
+        return count;
+    }
+    invalidateByTable(tableName) {
+        const pattern = new RegExp(`\\b${tableName.toLowerCase()}\\b`, 'i');
+        return this.invalidateByPattern(pattern);
+    }
+    getStats() {
+        const totalSize = Array.from(this.cache.values()).reduce((sum, e) => sum + e.size, 0);
+        const total = this.stats.hits + this.stats.misses;
+        return {
+            hits: this.stats.hits,
+            misses: this.stats.misses,
+            evictions: this.stats.evictions,
+            size: totalSize,
+            itemCount: this.cache.size,
+            hitRate: total > 0 ? this.stats.hits / total : 0
+        };
+    }
+    resetStats() {
+        this.stats = { hits: 0, misses: 0, evictions: 0 };
+    }
+    keys() {
+        return Array.from(this.cache.keys());
+    }
+    values() {
+        return Array.from(this.cache.values()).map(e => e.value);
+    }
+    entries() {
+        return Array.from(this.cache.entries());
+    }
+    evictIfNeeded(incomingSize) {
+        if (this.options.strategy === 'none')
+            return;
+        while (this.cache.size >= this.options.maxItems) {
+            this.evictOne();
+        }
+        if (this.options.strategy === 'size') {
+            const currentSize = Array.from(this.cache.values()).reduce((sum, e) => sum + e.size, 0);
+            while (currentSize + incomingSize > this.options.maxSize && this.cache.size > 0) {
+                this.evictOne();
+            }
+        }
+    }
+    evictOne() {
+        if (this.cache.size === 0)
+            return;
+        let keyToEvict;
+        let entryToEvict;
+        switch (this.options.strategy) {
+            case 'lru':
+                keyToEvict = this.cache.keys().next().value;
+                break;
+            case 'ttl':
+                let oldestTime = Infinity;
+                this.cache.forEach((entry, key) => {
+                    if (entry.createdAt < oldestTime) {
+                        oldestTime = entry.createdAt;
+                        keyToEvict = key;
+                        entryToEvict = entry;
+                    }
+                });
+                break;
+            case 'size':
+                let largestSize = -1;
+                this.cache.forEach((entry, key) => {
+                    if (entry.size > largestSize) {
+                        largestSize = entry.size;
+                        keyToEvict = key;
+                        entryToEvict = entry;
+                    }
+                });
+                break;
+            default:
+                keyToEvict = this.cache.keys().next().value;
+        }
+        if (keyToEvict) {
+            this.delete(keyToEvict);
+        }
+    }
+    estimateSize(value) {
+        if (value === null || value === undefined)
+            return 8;
+        if (typeof value === 'boolean')
+            return 4;
+        if (typeof value === 'number')
+            return 8;
+        if (typeof value === 'string')
+            return value.length * 2;
+        if (Array.isArray(value)) {
+            return value.reduce((sum, item) => sum + this.estimateSize(item), 16);
+        }
+        if (typeof value === 'object') {
+            return JSON.stringify(value).length * 2;
+        }
+        return 64;
+    }
+}
+export class CacheKeyBuilder {
+    parts = [];
+    table(name) {
+        this.parts.push(`t:${name}`);
+        return this;
+    }
+    operation(op) {
+        this.parts.push(`o:${op}`);
+        return this;
+    }
+    columns(...cols) {
+        if (cols.length > 0) {
+            this.parts.push(`c:${cols.sort().join(',')}`);
+        }
+        return this;
+    }
+    where(condition) {
+        this.parts.push(`w:${condition}`);
+        return this;
+    }
+    orderBy(order) {
+        this.parts.push(`ob:${order}`);
+        return this;
+    }
+    limit(n) {
+        this.parts.push(`l:${n}`);
+        return this;
+    }
+    offset(n) {
+        this.parts.push(`of:${n}`);
+        return this;
+    }
+    params(...values) {
+        if (values.length > 0) {
+            this.parts.push(`p:${JSON.stringify(values)}`);
+        }
+        return this;
+    }
+    custom(key, value) {
+        this.parts.push(`${key}:${value}`);
+        return this;
+    }
+    build() {
+        return this.parts.join('|');
+    }
+    static from(query, params) {
+        const normalized = query.replace(/\s+/g, ' ').trim();
+        const hash = this.simpleHash(normalized + (params ? JSON.stringify(params) : ''));
+        return `q:${hash}`;
+    }
+    static simpleHash(str) {
+        let hash = 0;
+        for (let i = 0; i < str.length; i++) {
+            const char = str.charCodeAt(i);
+            hash = ((hash << 5) - hash) + char;
+            hash = hash & hash;
+        }
+        return Math.abs(hash).toString(36);
+    }
+}
+export function createQueryCacheMiddleware(options) {
+    const { cache, keyPrefix = '', invalidateOn = [] } = options;
+    return {
+        beforeQuery: (query, params) => {
+            const key = keyPrefix + CacheKeyBuilder.from(query, params);
+            const cached = cache.get(key);
+            if (cached !== undefined) {
+                return { cached: true, value: cached, key };
+            }
+            return { cached: false, key };
+        },
+        afterQuery: (key, result) => {
+            cache.set(key, result);
+        },
+        afterMutation: (tableName) => {
+            cache.invalidateByTable(tableName);
+            invalidateOn.forEach(pattern => {
+                if (pattern.includes(tableName)) {
+                    cache.invalidateByPattern(new RegExp(pattern, 'i'));
+                }
+            });
+        }
+    };
+}
+export function withCache(cache, key, fn, ttl) {
+    const cached = cache.get(key);
+    if (cached !== undefined) {
+        return cached;
+    }
+    const result = fn();
+    if (result instanceof Promise) {
+        return result.then(value => {
+            cache.set(key, value);
+            return value;
+        });
+    }
+    cache.set(key, result);
+    return result;
+}
+export function createTableCache(tableName, options = {}) {
+    const cache = new QueryCache({
+        ...options,
+        keyGenerator: (query, params) => {
+            return `${tableName}::${query.replace(/\s+/g, ' ').trim()}::${params ? JSON.stringify(params) : ''}`;
+        }
+    });
+    return Object.assign(cache, { table: tableName });
+}

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

@@ -0,0 +1,78 @@
+import { colors } from "../utils/spinner.js";
+import { isInitialized, getUnstagedChanges, getStagedChanges, stageChanges, } from "../utils/repo-manager.js";
+import { getChangeDisplayName } from "../utils/change-tracker.js";
+export async function addCommand(context) {
+    const { args } = context;
+    const projectRoot = process.cwd();
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        console.log(`${colors.red('error:')} relq not initialized`);
+        console.log('');
+        console.log(`${colors.muted('Run')} ${colors.cyan('relq init')} ${colors.muted('first.')}`);
+        return;
+    }
+    const unstaged = getUnstagedChanges(projectRoot);
+    const staged = getStagedChanges(projectRoot);
+    if (unstaged.length === 0) {
+        if (staged.length > 0) {
+            console.log(`${colors.green('✓')} All changes are already staged`);
+            console.log(`${colors.muted(`${staged.length} change(s) ready to commit`)}`);
+            console.log('');
+            console.log(`${colors.muted('Run')} ${colors.cyan('relq commit -m "message"')} ${colors.muted('to commit.')}`);
+        }
+        else {
+            console.log(`${colors.green('✓')} No changes to stage`);
+            console.log(`${colors.muted('Run')} ${colors.cyan('relq pull')} ${colors.muted('or')} ${colors.cyan('relq import')} ${colors.muted('to detect changes.')}`);
+        }
+        console.log('');
+        return;
+    }
+    const patterns = args.length > 0 ? args : ['.'];
+    const addAll = patterns.includes('.') || patterns.includes('*');
+    console.log(`${colors.cyan('Unstaged changes:')} ${unstaged.length}`);
+    console.log('');
+    for (const change of unstaged) {
+        const display = getChangeDisplayName(change);
+        const color = change.type === 'CREATE' ? colors.green :
+            change.type === 'DROP' ? colors.red :
+                colors.yellow;
+        console.log(`   ${color(display)}`);
+    }
+    console.log('');
+    const stagedNow = stageChanges(patterns, projectRoot);
+    if (stagedNow.length === 0) {
+        console.log(`${colors.yellow('⚠')} No changes matched the pattern(s): ${patterns.join(', ')}`);
+        console.log('');
+        return;
+    }
+    console.log(`${colors.green('✓')} Staged ${stagedNow.length} change(s):`);
+    console.log('');
+    for (const change of stagedNow) {
+        const display = getChangeDisplayName(change);
+        const color = change.type === 'CREATE' ? colors.green :
+            change.type === 'DROP' ? colors.red :
+                colors.yellow;
+        console.log(`   ${color(display)}`);
+    }
+    console.log('');
+    const remainingUnstaged = getUnstagedChanges(projectRoot);
+    if (remainingUnstaged.length > 0) {
+        console.log(`${colors.muted(`${remainingUnstaged.length} change(s) still unstaged`)}`);
+        console.log('');
+    }
+    console.log(`${colors.muted('Run')} ${colors.cyan('relq commit -m "message"')} ${colors.muted('to commit.')}`);
+    console.log('');
+}
+export function getRelatedChanges(tableName, changes) {
+    return changes.filter(c => {
+        if (c.objectName === tableName)
+            return true;
+        if (c.parentName === tableName)
+            return true;
+        const data = c.after;
+        if (data?.tableName === tableName)
+            return true;
+        return false;
+    });
+}
+export default addCommand;

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

@@ -0,0 +1,109 @@
+import * as crypto from 'crypto';
+import { colors } from "../utils/spinner.js";
+import { isInitialized, getHead, getStagedChanges, getUnstagedChanges, shortHash, } from "../utils/repo-manager.js";
+import { sortChangesByDependency, generateCombinedSQL, } from "../utils/change-tracker.js";
+import * as fs from 'fs';
+import * as path from 'path';
+export async function commitCommand(context) {
+    const { config, flags, args } = context;
+    const projectRoot = process.cwd();
+    const author = config?.author || 'Developer <dev@example.com>';
+    console.log('');
+    if (!isInitialized(projectRoot)) {
+        console.log(`${colors.red('error:')} relq not initialized`);
+        console.log('');
+        console.log(`${colors.muted('Run')} ${colors.cyan('relq init')} ${colors.muted('first.')}`);
+        return;
+    }
+    const staged = getStagedChanges(projectRoot);
+    if (staged.length === 0) {
+        console.log(`${colors.yellow('Nothing to commit')}`);
+        console.log('');
+        const unstaged = getUnstagedChanges(projectRoot);
+        if (unstaged.length > 0) {
+            console.log(`${colors.muted(`${unstaged.length} unstaged change(s).`)}`);
+            console.log(`${colors.muted('Use')} ${colors.cyan('relq add .')} ${colors.muted('to stage all changes.')}`);
+        }
+        else {
+            console.log(`${colors.muted('Use')} ${colors.cyan('relq add <table>')} ${colors.muted('to stage changes.')}`);
+        }
+        return;
+    }
+    let message = flags['m'] || flags['message'];
+    if (!message) {
+        if (args.length > 0) {
+            message = args.join(' ');
+        }
+        else {
+            console.log(`${colors.red('error:')} commit message required`);
+            console.log('');
+            console.log(`${colors.muted('Usage:')} relq commit -m "message"`);
+            return;
+        }
+    }
+    const sortedChanges = sortChangesByDependency(staged);
+    const sql = generateCombinedSQL(sortedChanges);
+    const creates = staged.filter(c => c.type === 'CREATE').length;
+    const alters = staged.filter(c => c.type === 'ALTER').length;
+    const drops = staged.filter(c => c.type === 'DROP').length;
+    const parentHash = getHead(projectRoot);
+    const hashInput = JSON.stringify({
+        changes: staged.map(c => c.id),
+        message,
+        timestamp: new Date().toISOString(),
+        parent: parentHash,
+    });
+    const hash = crypto.createHash('sha1').update(hashInput).digest('hex');
+    const commit = {
+        hash,
+        parentHash,
+        author,
+        message,
+        timestamp: new Date().toISOString(),
+        changes: sortedChanges,
+        sql,
+        snapshotHash: hash.substring(0, 12),
+        stats: {
+            creates,
+            alters,
+            drops,
+            total: staged.length,
+        },
+    };
+    const commitsDir = path.join(projectRoot, '.relq', 'commits');
+    if (!fs.existsSync(commitsDir)) {
+        fs.mkdirSync(commitsDir, { recursive: true });
+    }
+    fs.writeFileSync(path.join(commitsDir, `${hash}.json`), JSON.stringify(commit, null, 2), 'utf-8');
+    fs.writeFileSync(path.join(projectRoot, '.relq', 'HEAD'), hash, 'utf-8');
+    const workingPath = path.join(projectRoot, '.relq', 'working.json');
+    const unstaged = getUnstagedChanges(projectRoot);
+    if (unstaged.length > 0) {
+        fs.writeFileSync(workingPath, JSON.stringify({
+            timestamp: new Date().toISOString(),
+            staged: [],
+            unstaged,
+        }, null, 2), 'utf-8');
+    }
+    else {
+        if (fs.existsSync(workingPath)) {
+            fs.unlinkSync(workingPath);
+        }
+    }
+    console.log(`${colors.yellow(`[${shortHash(hash)}]`)} ${message}`);
+    console.log('');
+    if (creates > 0) {
+        console.log(` ${colors.green(`${creates} created`)}`);
+    }
+    if (alters > 0) {
+        console.log(` ${colors.yellow(`${alters} altered`)}`);
+    }
+    if (drops > 0) {
+        console.log(` ${colors.red(`${drops} dropped`)}`);
+    }
+    console.log('');
+    console.log(`${colors.muted('Run')} ${colors.cyan('relq push')} ${colors.muted('to apply changes to database.')}`);
+    console.log(`${colors.muted('Run')} ${colors.cyan('relq export')} ${colors.muted('to export as SQL file.')}`);
+    console.log('');
+}
+export default commitCommand;

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

@@ -0,0 +1,81 @@
+import { requireValidConfig } from "../utils/config-loader.js";
+import { introspectDatabase } from "../utils/schema-introspect.js";
+import { loadSnapshot, snapshotToDatabaseSchema } from "../utils/snapshot-manager.js";
+import { formatDiff } from "../utils/schema-diff.js";
+import { normalizeSchema } from "../utils/schema-hash.js";
+import { diffSchemas } from "../utils/schema-diff.js";
+import { generateMigration } from "../utils/migration-generator.js";
+import { getConnectionDescription } from "../utils/env-loader.js";
+const colors = {
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    dim: '\x1b[2m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    cyan: '\x1b[36m',
+    magenta: '\x1b[35m',
+};
+function filterDiff(diff, ignorePatterns) {
+    const patterns = ignorePatterns.map(p => {
+        const regexStr = p.replace(/\*/g, '.*').replace(/\?/g, '.');
+        return new RegExp(`^${regexStr}$`, 'i');
+    });
+    const matchesPattern = (name) => patterns.some(p => p.test(name));
+    const tables = diff.tables.filter(t => !matchesPattern(t.name));
+    const hasChanges = tables.length > 0 || diff.extensions.length > 0;
+    return {
+        ...diff,
+        tables,
+        hasChanges,
+    };
+}
+export async function diffCommand(context) {
+    const { config, flags } = context;
+    if (!config) {
+        console.error('Error: No configuration found.');
+        process.exit(1);
+    }
+    requireValidConfig(config);
+    const connection = config.connection;
+    const snapshotPath = config.sync?.snapshot || '.relq/snapshot.json';
+    const ignorePatterns = config.sync?.ignore || ['_relq_*'];
+    const showSQL = flags['sql'] === true;
+    console.log(`${colors.bold}Comparing:${colors.reset} local snapshot ↔ ${getConnectionDescription(connection)}`);
+    console.log('');
+    try {
+        const dbSchema = await introspectDatabase(connection);
+        const snapshot = loadSnapshot(snapshotPath);
+        if (!snapshot) {
+            console.log(`${colors.yellow}No snapshot found.${colors.reset}`);
+            console.log(`Run "${colors.cyan}relq pull${colors.reset}" to create initial snapshot.`);
+            return;
+        }
+        const localSchema = snapshotToDatabaseSchema(snapshot);
+        const normalizedLocal = normalizeSchema(localSchema);
+        const normalizedDb = normalizeSchema(dbSchema);
+        const diff = diffSchemas(normalizedLocal, normalizedDb);
+        const filteredDiff = filterDiff(diff, ignorePatterns);
+        if (!filteredDiff.hasChanges) {
+            console.log(`${colors.green}No differences.${colors.reset}`);
+            return;
+        }
+        console.log(formatDiff(filteredDiff));
+        if (showSQL) {
+            console.log('');
+            console.log(`${colors.bold}Generated SQL:${colors.reset}`);
+            console.log('');
+            const { up } = generateMigration(filteredDiff, { includeDown: false });
+            for (const sql of up) {
+                console.log(`${colors.cyan}${sql}${colors.reset}`);
+            }
+        }
+        console.log('');
+        console.log(`${colors.dim}Use "relq diff --sql" to see generated SQL statements.${colors.reset}`);
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+}