relq 1.0.2 → 1.0.3

package/dist/cjs/cli/utils/cli-utils.cjs

@@ -0,0 +1,217 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colors = void 0;
+exports.createSpinner = createSpinner;
+exports.fatal = fatal;
+exports.error = error;
+exports.warning = warning;
+exports.hint = hint;
+exports.success = success;
+exports.confirm = confirm;
+exports.select = select;
+exports.formatBytes = formatBytes;
+exports.formatDuration = formatDuration;
+exports.progressBar = progressBar;
+exports.requireInit = requireInit;
+const readline = __importStar(require("readline"));
+const isColorSupported = process.stdout.isTTY && !process.env.NO_COLOR;
+exports.colors = {
+    reset: '\x1b[0m',
+    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,
+    muted: (s) => isColorSupported ? `\x1b[90m${s}\x1b[0m` : s,
+    success: (s) => isColorSupported ? `\x1b[32m${s}\x1b[0m` : s,
+    error: (s) => isColorSupported ? `\x1b[31m${s}\x1b[0m` : s,
+    warning: (s) => isColorSupported ? `\x1b[33m${s}\x1b[0m` : s,
+    info: (s) => isColorSupported ? `\x1b[34m${s}\x1b[0m` : s,
+};
+function createSpinner() {
+    const frames = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
+    let frameIndex = 0;
+    let interval = null;
+    let currentMessage = '';
+    let isSpinning = false;
+    const isTTY = process.stdout.isTTY;
+    const clearLine = () => {
+        if (isTTY)
+            process.stdout.write('\r\x1b[K');
+    };
+    const render = () => {
+        if (!isSpinning)
+            return;
+        clearLine();
+        process.stdout.write(`${exports.colors.cyan(frames[frameIndex])} ${currentMessage}`);
+        frameIndex = (frameIndex + 1) % frames.length;
+    };
+    return {
+        start(message) {
+            if (isSpinning)
+                this.stop();
+            currentMessage = message;
+            isSpinning = true;
+            frameIndex = 0;
+            if (isTTY) {
+                interval = setInterval(render, 80);
+                render();
+            }
+            else {
+                console.log(`${message}...`);
+            }
+        },
+        update(message) {
+            currentMessage = message;
+        },
+        succeed(message) {
+            this.stop();
+            console.log(message || currentMessage);
+        },
+        fail(message) {
+            this.stop();
+        },
+        info(message) {
+            this.stop();
+            console.log(message || currentMessage);
+        },
+        warn(message) {
+            this.stop();
+            warning(message || currentMessage);
+        },
+        stop() {
+            if (interval) {
+                clearInterval(interval);
+                interval = null;
+            }
+            if (isSpinning && isTTY) {
+                clearLine();
+            }
+            isSpinning = false;
+        }
+    };
+}
+function fatal(message, hintMessage) {
+    console.error(`${exports.colors.red('fatal:')} ${message}`);
+    if (hintMessage) {
+        hint(hintMessage);
+    }
+    process.exit(1);
+}
+function error(message, hintMessage) {
+    console.error(`${exports.colors.red('error:')} ${message}`);
+    if (hintMessage) {
+        hint(hintMessage);
+    }
+}
+function warning(message) {
+    console.error(`${exports.colors.yellow('warning:')} ${message}`);
+}
+function hint(message) {
+    console.error(`${exports.colors.yellow('hint:')} ${message}`);
+}
+function success(message) {
+    console.log(exports.colors.green(message));
+}
+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} ${suffix} `, (answer) => {
+            rl.close();
+            const a = answer.trim().toLowerCase();
+            if (!a)
+                resolve(defaultYes);
+            else
+                resolve(a === 'y' || a === 'yes');
+        });
+    });
+}
+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(`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);
+            }
+        });
+    });
+}
+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`;
+}
+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`;
+}
+function progressBar(current, total, width = 30) {
+    const percentage = Math.min(100, Math.round((current / total) * 100));
+    const filled = Math.round((percentage / 100) * width);
+    const empty = width - filled;
+    return `${'#'.repeat(filled)}${'.'.repeat(empty)} ${percentage}%`;
+}
+function requireInit(isInitialized, projectRoot) {
+    if (!isInitialized) {
+        fatal('not a relq repository (or any of the parent directories): .relq', "run 'relq init' to initialize a repository");
+    }
+}

package/dist/cjs/cli/utils/config-loader.cjs

@@ -105,7 +105,7 @@ function validateConfig(config) {
     if (!config.connection?.host && !config.connection?.url) {
         errors.push('No database connection configured. Set connection in relq.config.ts or use DATABASE_* env vars.');
     }
-    const hasSchemaPath = typeof config.schema === 'string';
+    const hasSchemaPath = typeof config.schema === 'string' && config.schema.length > 0;
     const hasSchemaDir = typeof config.schema === 'object' && config.schema?.directory;
     const hasTypeGenOutput = config.typeGeneration?.output;
     const hasGenerateOutDir = config.generate?.outDir;
@@ -114,14 +114,40 @@ function validateConfig(config) {
     }
     return errors;
 }
-function requireValidConfig(config) {
+async function requireValidConfig(config, options) {
     const errors = validateConfig(config);
-    if (errors.length > 0) {
-        console.error('Configuration errors:');
-        for (const error of errors) {
-            console.error(`  • ${error}`);
+    if (errors.length === 0)
+        return;
+    const colors = {
+        red: (s) => `\x1b[31m${s}\x1b[0m`,
+        yellow: (s) => `\x1b[33m${s}\x1b[0m`,
+        cyan: (s) => `\x1b[36m${s}\x1b[0m`,
+        bold: (s) => `\x1b[1m${s}\x1b[0m`,
+    };
+    const isInteractive = process.stdin.isTTY && process.stdout.isTTY;
+    if (options?.autoComplete !== false && isInteractive) {
+        try {
+            const { initCommand } = await Promise.resolve().then(() => __importStar(require("../commands/init.cjs")));
+            const { findProjectRoot } = await Promise.resolve().then(() => __importStar(require("./project-root.cjs")));
+            const projectRoot = findProjectRoot() || process.cwd();
+            const flags = {};
+            if (options?.calledFrom) {
+                flags['called-from'] = options.calledFrom;
+            }
+            await initCommand({ args: [], flags, config, projectRoot });
+            return;
+        }
+        catch (e) {
+            process.exit(1);
         }
-        console.error('\nRun "relq init" to create a configuration file.');
-        process.exit(1);
     }
+    console.error('');
+    console.error(colors.red('error:') + ' Configuration errors:');
+    for (const error of errors) {
+        console.error(`   ${colors.yellow('•')} ${error}`);
+    }
+    console.error('');
+    console.error(colors.yellow('hint:') + ` Run ${colors.cyan('relq init')} to create a configuration file or check your config settings.`);
+    console.error('');
+    process.exit(1);
 }

package/dist/cjs/cli/utils/fast-introspect.cjs

@@ -34,6 +34,18 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.fastIntrospectDatabase = fastIntrospectDatabase;
+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;
+}
 async function fastIntrospectDatabase(connection, onProgress, options) {
     const { includeFunctions = false, includeTriggers = false } = options || {};
     const { Pool } = await Promise.resolve().then(() => __importStar(require("../../addon/pg/index.cjs")));
@@ -254,7 +266,7 @@ 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,
@@ -376,6 +388,99 @@ 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,
@@ -383,12 +488,13 @@ async function fastIntrospectDatabase(connection, onProgress, options) {
             domains: [],
             compositeTypes: [],
             sequences: [],
+            collations,
             functions,
             triggers,
             policies: [],
             partitions,
-            foreignServers: [],
-            foreignTables: [],
+            foreignServers,
+            foreignTables,
             extensions,
         };
     }