relq 1.0.2 → 1.0.4

package/dist/esm/cli/utils/fast-introspect.js

@@ -1,3 +1,15 @@
+function parseOptionsArray(options) {
+    if (!options)
+        return {};
+    const result = {};
+    for (const opt of options) {
+        const eqIdx = opt.indexOf('=');
+        if (eqIdx > 0) {
+            result[opt.substring(0, eqIdx)] = opt.substring(eqIdx + 1);
+        }
+    }
+    return result;
+}
 export async function fastIntrospectDatabase(connection, onProgress, options) {
     const { includeFunctions = false, includeTriggers = false } = options || {};
     const { Pool } = await import("../../addon/pg/index.js");
@@ -218,7 +230,7 @@ export async function fastIntrospectDatabase(connection, onProgress, options) {
         const tables = [];
         for (const row of tablesResult.rows) {
             const tableName = row.table_name;
-            if (tableName.startsWith('_relq'))
+            if (tableName.startsWith('_relq') || tableName.startsWith('_kuery'))
                 continue;
             tables.push({
                 name: tableName,
@@ -340,6 +352,99 @@ export async function fastIntrospectDatabase(connection, onProgress, options) {
                 isEnabled: t.is_enabled,
             }));
         }
+        onProgress?.('fetching_collations');
+        const collationsResult = await pool.query(`
+            SELECT 
+                c.collname as name,
+                n.nspname as schema,
+                c.collprovider as provider,
+                c.collcollate as lc_collate,
+                c.collctype as lc_ctype,
+                c.collisdeterministic as deterministic
+            FROM pg_collation c
+            JOIN pg_namespace n ON c.collnamespace = n.oid
+            WHERE n.nspname = 'public'
+            ORDER BY c.collname;
+        `);
+        const collations = collationsResult.rows.map(c => ({
+            name: c.name,
+            schema: c.schema,
+            provider: c.provider === 'i' ? 'icu' : c.provider === 'c' ? 'libc' : 'default',
+            lcCollate: c.lc_collate,
+            lcCtype: c.lc_ctype,
+            deterministic: c.deterministic,
+        }));
+        onProgress?.('fetching_foreign_servers');
+        const foreignServersResult = await pool.query(`
+            SELECT 
+                s.srvname as name,
+                f.fdwname as fdw,
+                s.srvoptions as options
+            FROM pg_foreign_server s
+            JOIN pg_foreign_data_wrapper f ON s.srvfdw = f.oid
+            ORDER BY s.srvname;
+        `);
+        const foreignServers = foreignServersResult.rows.map(s => ({
+            name: s.name,
+            foreignDataWrapper: s.fdw,
+            options: parseOptionsArray(s.options),
+        }));
+        onProgress?.('fetching_foreign_tables');
+        const foreignTablesResult = await pool.query(`
+            SELECT 
+                c.relname as name,
+                n.nspname as schema,
+                s.srvname as server_name,
+                ft.ftoptions as options
+            FROM pg_foreign_table ft
+            JOIN pg_class c ON ft.ftrelid = c.oid
+            JOIN pg_namespace n ON c.relnamespace = n.oid
+            JOIN pg_foreign_server s ON ft.ftserver = s.oid
+            WHERE n.nspname = 'public'
+            ORDER BY c.relname;
+        `);
+        const foreignTableNames = foreignTablesResult.rows.map(t => t.name);
+        let foreignTableColumns = new Map();
+        if (foreignTableNames.length > 0) {
+            const ftColsResult = await pool.query(`
+                SELECT 
+                    c.relname as table_name,
+                    a.attname as column_name,
+                    pg_catalog.format_type(a.atttypid, a.atttypmod) as data_type
+                FROM pg_attribute a
+                JOIN pg_class c ON a.attrelid = c.oid
+                JOIN pg_namespace n ON c.relnamespace = n.oid
+                WHERE n.nspname = 'public'
+                    AND c.relname = ANY($1)
+                    AND a.attnum > 0
+                    AND NOT a.attisdropped
+                ORDER BY c.relname, a.attnum;
+            `, [foreignTableNames]);
+            for (const row of ftColsResult.rows) {
+                const cols = foreignTableColumns.get(row.table_name) || [];
+                cols.push({ name: row.column_name, type: row.data_type });
+                foreignTableColumns.set(row.table_name, cols);
+            }
+        }
+        const foreignTables = foreignTablesResult.rows.map(t => ({
+            name: t.name,
+            schema: t.schema,
+            serverName: t.server_name,
+            columns: (foreignTableColumns.get(t.name) || []).map((c, i) => ({
+                name: c.name,
+                dataType: c.type,
+                isNullable: true,
+                defaultValue: null,
+                isPrimaryKey: false,
+                isUnique: false,
+                ordinalPosition: i + 1,
+                maxLength: null,
+                precision: null,
+                scale: null,
+                references: null,
+            })),
+            options: parseOptionsArray(t.options),
+        }));
         onProgress?.('complete');
         return {
             tables,
@@ -347,12 +452,13 @@ export async function fastIntrospectDatabase(connection, onProgress, options) {
             domains: [],
             compositeTypes: [],
             sequences: [],
+            collations,
             functions,
             triggers,
             policies: [],
             partitions,
-            foreignServers: [],
-            foreignTables: [],
+            foreignServers,
+            foreignTables,
             extensions,
         };
     }

package/dist/esm/cli/utils/git-utils.js

@@ -1,35 +1,8 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import { isInitialized, getStagedChanges, getUnstagedChanges, getHead, loadCommit, } from "./repo-manager.js";
-const isColorSupported = process.stdout.isTTY && !process.env.NO_COLOR;
-export const colors = {
-    red: (s) => isColorSupported ? `\x1b[31m${s}\x1b[0m` : s,
-    green: (s) => isColorSupported ? `\x1b[32m${s}\x1b[0m` : s,
-    yellow: (s) => isColorSupported ? `\x1b[33m${s}\x1b[0m` : s,
-    blue: (s) => isColorSupported ? `\x1b[34m${s}\x1b[0m` : s,
-    magenta: (s) => isColorSupported ? `\x1b[35m${s}\x1b[0m` : s,
-    cyan: (s) => isColorSupported ? `\x1b[36m${s}\x1b[0m` : s,
-    white: (s) => isColorSupported ? `\x1b[37m${s}\x1b[0m` : s,
-    gray: (s) => isColorSupported ? `\x1b[90m${s}\x1b[0m` : s,
-    bold: (s) => isColorSupported ? `\x1b[1m${s}\x1b[0m` : s,
-    dim: (s) => isColorSupported ? `\x1b[2m${s}\x1b[0m` : s,
-};
-export function error(message) {
-    console.error(`${colors.red('error:')} ${message}`);
-}
-export function fatal(message) {
-    console.error(`${colors.red('fatal:')} ${message}`);
-    process.exit(128);
-}
-export function warning(message) {
-    console.error(`${colors.yellow('warning:')} ${message}`);
-}
-export function hint(message) {
-    console.log(`${colors.yellow('hint:')} ${message}`);
-}
-export function success(message) {
-    console.log(`${colors.green('✓')} ${message}`);
-}
+export { colors, createSpinner, fatal, error, warning, hint, success, confirm, select, formatBytes, formatDuration, progressBar, requireInit, } from "./cli-utils.js";
+import { colors, error, hint, fatal } from "./cli-utils.js";
 export function info(message) {
     console.log(message);
 }
@@ -250,98 +223,3 @@ export function readSQLFile(filePath) {
     const validation = validatePostgresSQL(content);
     return { content, validation };
 }
-export function createSpinner() {
-    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-    let frameIndex = 0;
-    let interval = null;
-    let currentMessage = '';
-    return {
-        start(message) {
-            currentMessage = message;
-            if (process.stdout.isTTY) {
-                interval = setInterval(() => {
-                    process.stdout.write(`\r${frames[frameIndex]} ${currentMessage}`);
-                    frameIndex = (frameIndex + 1) % frames.length;
-                }, 80);
-            }
-            else {
-                console.log(`  ${message}...`);
-            }
-        },
-        stop() {
-            if (interval) {
-                clearInterval(interval);
-                interval = null;
-                if (process.stdout.isTTY) {
-                    process.stdout.write('\r' + ' '.repeat(currentMessage.length + 4) + '\r');
-                }
-            }
-        },
-        succeed(message) {
-            this.stop();
-            console.log(`${colors.green('✓')} ${message}`);
-        },
-        fail(message) {
-            this.stop();
-            console.log(`${colors.red('✗')} ${message}`);
-        },
-        info(message) {
-            this.stop();
-            console.log(`${colors.blue('ℹ')} ${message}`);
-        },
-    };
-}
-import * as readline from 'readline';
-export function confirm(question, defaultYes = true) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    const suffix = defaultYes ? '[Y/n]' : '[y/N]';
-    return new Promise((resolve) => {
-        rl.question(`${question} ${colors.gray(suffix)} `, (answer) => {
-            rl.close();
-            const a = answer.trim().toLowerCase();
-            if (!a)
-                resolve(defaultYes);
-            else
-                resolve(a === 'y' || a === 'yes');
-        });
-    });
-}
-export function select(question, options) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout,
-    });
-    console.log(question);
-    options.forEach((opt, i) => {
-        console.log(`  ${i + 1}) ${opt}`);
-    });
-    return new Promise((resolve) => {
-        rl.question(`${colors.gray('Select [1-' + options.length + ']:')} `, (answer) => {
-            rl.close();
-            const num = parseInt(answer.trim(), 10);
-            if (num >= 1 && num <= options.length) {
-                resolve(num - 1);
-            }
-            else {
-                resolve(0);
-            }
-        });
-    });
-}
-export function formatBytes(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(1)} KB`;
-    return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-}
-export function formatDuration(ms) {
-    if (ms < 1000)
-        return `${ms}ms`;
-    if (ms < 60000)
-        return `${(ms / 1000).toFixed(1)}s`;
-    return `${Math.floor(ms / 60000)}m ${Math.floor((ms % 60000) / 1000)}s`;
-}

package/dist/esm/cli/utils/pool-manager.js

@@ -0,0 +1,114 @@
+const pools = new Map();
+const IDLE_TIMEOUT = 30000;
+let cleanupInterval = null;
+function getPoolKey(config) {
+    if (config.url) {
+        return config.url;
+    }
+    return `${config.host || 'localhost'}:${config.port || 5432}/${config.database}@${config.user}`;
+}
+function startCleanupInterval() {
+    if (cleanupInterval)
+        return;
+    cleanupInterval = setInterval(() => {
+        const now = Date.now();
+        for (const [key, entry] of pools.entries()) {
+            if (entry.refCount === 0 && now - entry.lastUsed > IDLE_TIMEOUT) {
+                entry.pool.end().catch(() => { });
+                pools.delete(key);
+            }
+        }
+        if (pools.size === 0 && cleanupInterval) {
+            clearInterval(cleanupInterval);
+            cleanupInterval = null;
+        }
+    }, IDLE_TIMEOUT);
+    cleanupInterval.unref();
+}
+export async function getPool(config) {
+    const key = getPoolKey(config);
+    let entry = pools.get(key);
+    if (entry) {
+        entry.refCount++;
+        entry.lastUsed = Date.now();
+        return entry.pool;
+    }
+    const { Pool } = await import("../../addon/pg/index.js");
+    const pool = new Pool({
+        host: config.host,
+        port: config.port || 5432,
+        database: config.database,
+        user: config.user,
+        password: config.password,
+        connectionString: config.url,
+        ssl: config.ssl,
+        max: config.max || 10,
+        idleTimeoutMillis: config.idleTimeoutMillis || 10000,
+        connectionTimeoutMillis: config.connectionTimeoutMillis || 5000,
+    });
+    entry = {
+        pool,
+        refCount: 1,
+        lastUsed: Date.now(),
+    };
+    pools.set(key, entry);
+    startCleanupInterval();
+    return pool;
+}
+export function releasePool(config) {
+    const key = getPoolKey(config);
+    const entry = pools.get(key);
+    if (entry && entry.refCount > 0) {
+        entry.refCount--;
+        entry.lastUsed = Date.now();
+    }
+}
+export async function withPool(config, fn) {
+    const pool = await getPool(config);
+    try {
+        return await fn(pool);
+    }
+    finally {
+        releasePool(config);
+    }
+}
+export async function withClient(config, fn) {
+    const pool = await getPool(config);
+    const client = await pool.connect();
+    try {
+        return await fn(client);
+    }
+    finally {
+        client.release();
+        releasePool(config);
+    }
+}
+export async function withTransaction(config, fn) {
+    return withClient(config, async (client) => {
+        await client.query('BEGIN');
+        try {
+            const result = await fn(client);
+            await client.query('COMMIT');
+            return result;
+        }
+        catch (error) {
+            await client.query('ROLLBACK');
+            throw error;
+        }
+    });
+}
+export async function closeAllPools() {
+    if (cleanupInterval) {
+        clearInterval(cleanupInterval);
+        cleanupInterval = null;
+    }
+    const closePromises = [];
+    for (const [key, entry] of pools.entries()) {
+        closePromises.push(entry.pool.end());
+        pools.delete(key);
+    }
+    await Promise.all(closePromises);
+}
+export function getActivePoolCount() {
+    return pools.size;
+}

package/dist/esm/cli/utils/project-root.js

@@ -1,19 +1,69 @@
 import * as fs from 'fs';
 import * as path from 'path';
+import * as os from 'os';
+const CONFIG_FILENAMES = [
+    'relq.config.ts',
+    'relq.config.js',
+    'relq.config.mjs',
+];
+function hasProjectMarker(dir) {
+    for (const filename of CONFIG_FILENAMES) {
+        if (fs.existsSync(path.join(dir, filename))) {
+            return true;
+        }
+    }
+    if (fs.existsSync(path.join(dir, 'package.json'))) {
+        return true;
+    }
+    return false;
+}
 export function findProjectRoot(startDir = process.cwd()) {
     let currentDir = path.resolve(startDir);
     const root = path.parse(currentDir).root;
+    const homeDir = os.homedir();
     while (currentDir !== root) {
-        const packageJsonPath = path.join(currentDir, 'package.json');
-        if (fs.existsSync(packageJsonPath)) {
+        if (hasProjectMarker(currentDir)) {
             return currentDir;
         }
+        if (currentDir === homeDir) {
+            return null;
+        }
         currentDir = path.dirname(currentDir);
     }
-    return process.cwd();
+    return null;
 }
 export function getRelqDir(startDir = process.cwd()) {
-    const projectRoot = findProjectRoot(startDir) || process.cwd();
+    const projectRoot = findProjectRoot(startDir);
+    if (!projectRoot) {
+        const colors = {
+            red: (s) => `\x1b[31m${s}\x1b[0m`,
+            yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+            cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+        };
+        console.error('');
+        console.error(colors.red('fatal:') + ' not a relq project (or any of the parent directories)');
+        console.error('');
+        console.error(colors.yellow('hint:') + ` Run ${colors.cyan('relq init')} in your project directory to initialize relq.`);
+        console.error('');
+        process.exit(128);
+    }
     return path.join(projectRoot, '.relq');
 }
-export default { findProjectRoot, getRelqDir };
+export function getProjectRoot(startDir = process.cwd()) {
+    const projectRoot = findProjectRoot(startDir);
+    if (!projectRoot) {
+        const colors = {
+            red: (s) => `\x1b[31m${s}\x1b[0m`,
+            yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+            cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+        };
+        console.error('');
+        console.error(colors.red('fatal:') + ' not a relq project (or any of the parent directories)');
+        console.error('');
+        console.error(colors.yellow('hint:') + ` Run ${colors.cyan('relq init')} in your project directory to initialize relq.`);
+        console.error('');
+        process.exit(128);
+    }
+    return projectRoot;
+}
+export default { findProjectRoot, getRelqDir, getProjectRoot };

package/dist/esm/cli/utils/relqignore.js

@@ -6,6 +6,7 @@ const REQUIRES_PARENT = [
 ];
 const DEFAULT_PATTERNS = [
     'TABLE:_relq_*',
+    'TABLE:_kuery_*',
     'TABLE:pg_*',
     'TABLE:_temp_*',
     'TABLE:tmp_*',

package/dist/esm/cli/utils/repo-manager.js

@@ -8,6 +8,7 @@ const STAGED_FILE = 'staged.json';
 const WORKING_FILE = 'working.json';
 const SNAPSHOT_FILE = 'snapshot.json';
 const COMMITS_DIR = 'commits';
+const FILE_HASH_FILE = 'file_hash';
 export function isInitialized(projectRoot = process.cwd()) {
     const relqPath = path.join(projectRoot, RELQ_DIR);
     const headPath = path.join(relqPath, HEAD_FILE);
@@ -172,6 +173,41 @@ export function saveSnapshot(schema, projectRoot = process.cwd()) {
     const snapshotPath = path.join(projectRoot, RELQ_DIR, SNAPSHOT_FILE);
     fs.writeFileSync(snapshotPath, JSON.stringify(schema, null, 2), 'utf-8');
 }
+export function hashFileContent(content) {
+    return crypto.createHash('sha1').update(content, 'utf8').digest('hex');
+}
+export function getSavedFileHash(projectRoot = process.cwd()) {
+    const hashPath = path.join(projectRoot, RELQ_DIR, FILE_HASH_FILE);
+    if (!fs.existsSync(hashPath)) {
+        return null;
+    }
+    return fs.readFileSync(hashPath, 'utf-8').trim() || null;
+}
+export function saveFileHash(hash, projectRoot = process.cwd()) {
+    const hashPath = path.join(projectRoot, RELQ_DIR, FILE_HASH_FILE);
+    fs.writeFileSync(hashPath, hash, 'utf-8');
+}
+export function detectFileChanges(schemaPath, projectRoot = process.cwd()) {
+    if (!fs.existsSync(schemaPath)) {
+        return null;
+    }
+    const currentContent = fs.readFileSync(schemaPath, 'utf-8');
+    const currentHash = hashFileContent(currentContent);
+    const savedHash = getSavedFileHash(projectRoot);
+    if (!savedHash || currentHash === savedHash) {
+        return null;
+    }
+    return {
+        id: `file_${currentHash.substring(0, 8)}`,
+        type: 'ALTER',
+        objectType: 'SCHEMA_FILE',
+        objectName: path.basename(schemaPath),
+        before: { hash: savedHash },
+        after: { hash: currentHash },
+        sql: '-- Schema file modified (comments, formatting, or manual edits)',
+        detectedAt: new Date().toISOString(),
+    };
+}
 export function loadWorkingState(projectRoot = process.cwd()) {
     const workingPath = path.join(projectRoot, RELQ_DIR, WORKING_FILE);
     if (!fs.existsSync(workingPath)) {
@@ -206,6 +242,12 @@ export function addUnstagedChanges(changes, projectRoot = process.cwd()) {
     state.timestamp = new Date().toISOString();
     saveWorkingState(state, projectRoot);
 }
+export function clearUnstagedChanges(projectRoot = process.cwd()) {
+    const state = getOrCreateWorkingState(projectRoot);
+    state.unstaged = [];
+    state.timestamp = new Date().toISOString();
+    saveWorkingState(state, projectRoot);
+}
 export function stageChanges(patterns, projectRoot = process.cwd()) {
     const state = getOrCreateWorkingState(projectRoot);
     const staged = [];