relq 1.0.1 → 1.0.3

package/dist/esm/cli/index.js

@@ -1,4 +1,3 @@
-#!/usr/bin/env node
 import { initCommand } from "./commands/init.js";
 import { pullCommand } from "./commands/pull.js";
 import { pushCommand } from "./commands/push.js";
@@ -7,13 +6,49 @@ import { introspectCommand } from "./commands/introspect.js";
 import { syncCommand } from "./commands/sync.js";
 import { statusCommand } from "./commands/status.js";
 import { diffCommand } from "./commands/diff.js";
-import { logCommand } from "./commands/log.js";
+import { logCommand, showCommand } from "./commands/log.js";
 import { rollbackCommand } from "./commands/rollback.js";
 import { commitCommand } from "./commands/commit.js";
 import { fetchCommand } from "./commands/fetch.js";
 import { addCommand } from "./commands/add.js";
 import { importCommand } from "./commands/import.js";
 import { exportCommand } from "./commands/export.js";
+import { resolveCommand } from "./commands/resolve.js";
+import { resetCommand } from "./commands/reset.js";
+import { stashCommand } from "./commands/stash.js";
+import { branchCommand } from "./commands/branch.js";
+import { mergeCommand } from "./commands/merge.js";
+import { tagCommand } from "./commands/tag.js";
+import { cherryPickCommand } from "./commands/cherry-pick.js";
+import { remoteCommand } from "./commands/remote.js";
+import * as fs from 'fs';
+import * as path from 'path';
+function loadEnvFile() {
+    let currentDir = process.cwd();
+    const root = path.parse(currentDir).root;
+    while (currentDir !== root) {
+        const envPath = path.join(currentDir, '.env');
+        if (fs.existsSync(envPath)) {
+            const envContent = fs.readFileSync(envPath, 'utf-8');
+            for (const line of envContent.split('\n')) {
+                const trimmed = line.trim();
+                if (!trimmed || trimmed.startsWith('#'))
+                    continue;
+                const match = trimmed.match(/^([^=]+)=(.*)$/);
+                if (match) {
+                    const key = match[1].trim();
+                    const value = match[2].trim().replace(/^["']|["']$/g, '');
+                    if (!process.env[key]) {
+                        process.env[key] = value;
+                    }
+                }
+            }
+            return;
+        }
+        currentDir = path.dirname(currentDir);
+    }
+}
+loadEnvFile();
 const VERSION = '1.1.0';
 function parseArgs(argv) {
     const args = [];
@@ -141,20 +176,56 @@ async function main() {
         process.exit(1);
     }
     let config = null;
+    let resolvedProjectRoot = process.cwd();
     if (requiresConfig(command)) {
         const configPath = flags.config;
         try {
-            const { loadConfigWithEnv, findConfigFile } = await import("./utils/config-loader.js");
-            const foundConfig = configPath || findConfigFile();
+            const { loadConfigWithEnv, findConfigFileRecursive } = await import("./utils/config-loader.js");
+            const { findProjectRoot } = await import("./utils/project-root.js");
+            const configResult = configPath ? { path: configPath, directory: path.dirname(path.resolve(configPath)) } : findConfigFileRecursive();
+            if (!configResult) {
+                const projectRoot = findProjectRoot();
+                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);
+                }
+            }
+            resolvedProjectRoot = configResult?.directory || findProjectRoot() || process.cwd();
+            const foundConfig = configResult?.path;
             if (!foundConfig) {
-                console.error('Error: relq.config.ts not found.');
-                console.error('Run "relq init" to create one or use --config to specify a path.');
+                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('error:') + ' relq.config.ts not found');
+                console.error('');
+                console.error(colors.yellow('hint:') + ` Run ${colors.cyan('relq init')} to create one or use ${colors.cyan('--config')} to specify a path.`);
+                console.error('');
                 process.exit(1);
             }
             config = await loadConfigWithEnv(configPath);
             if (requiresDbConnection(command, flags) && !config.connection?.host && !config.connection?.url) {
-                console.error('Error: No database connection configured.');
-                console.error('Run "relq init" or set DATABASE_* environment variables.');
+                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('error:') + ' No database connection configured');
+                console.error('');
+                console.error(colors.yellow('hint:') + ` Run ${colors.cyan('relq init')} or set DATABASE_* environment variables.`);
+                console.error('');
                 process.exit(1);
             }
         }
@@ -163,7 +234,7 @@ async function main() {
             process.exit(1);
         }
     }
-    const context = { config, args, flags };
+    const context = { config, args, flags, projectRoot: resolvedProjectRoot };
     try {
         switch (command) {
             case 'init':
@@ -194,6 +265,9 @@ async function main() {
             case 'log':
                 await logCommand(context);
                 break;
+            case 'show':
+                await showCommand(context);
+                break;
             case 'fetch':
                 await fetchCommand(context);
                 break;
@@ -201,6 +275,39 @@ async function main() {
             case 'revert':
                 await rollbackCommand(context);
                 break;
+            case 'resolve':
+                await resolveCommand(context);
+                break;
+            case 'reset':
+                await resetCommand(context);
+                break;
+            case 'stash':
+                await stashCommand(context);
+                break;
+            case 'branch':
+                await branchCommand(context);
+                break;
+            case 'checkout':
+            case 'switch':
+                console.log('');
+                console.log('⚠️  Branch switching is currently disabled.');
+                console.log('');
+                console.log('This feature will be available when Relq Postgres Native is officially launched.');
+                console.log('For now, work on a single branch and use merge to combine schemas.');
+                console.log('');
+                break;
+            case 'merge':
+                await mergeCommand(context);
+                break;
+            case 'tag':
+                await tagCommand(context);
+                break;
+            case 'cherry-pick':
+                await cherryPickCommand(context);
+                break;
+            case 'remote':
+                await remoteCommand(context);
+                break;
             case 'introspect':
                 await introspectCommand(context);
                 break;
@@ -217,7 +324,7 @@ async function main() {
                     theirs: Boolean(flags.theirs),
                     ours: Boolean(flags.ours),
                     abort: Boolean(flags.abort),
-                });
+                }, resolvedProjectRoot);
                 break;
             case 'export':
                 await exportCommand(context);
@@ -237,4 +344,4 @@ async function main() {
         process.exit(1);
     }
 }
-main().catch(console.error);
+export { main };

package/dist/esm/cli/utils/change-tracker.js

@@ -31,6 +31,12 @@ export function generateChangeSQL(change) {
             return generateConstraintSQL(change);
         case 'PARTITION':
             return generatePartitionSQL(change);
+        case 'PARTITION_CHILD':
+            return generatePartitionChildSQL(change);
+        case 'TABLE_COMMENT':
+            return generateTableCommentSQL(change);
+        case 'COLUMN_COMMENT':
+            return generateColumnCommentSQL(change);
         case 'VIEW':
             return generateViewSQL(change);
         case 'MATERIALIZED_VIEW':
@@ -44,6 +50,8 @@ export function generateChangeSQL(change) {
             return generateForeignServerSQL(change);
         case 'FOREIGN_TABLE':
             return generateForeignTableSQL(change);
+        case 'COLLATION':
+            return generateCollationSQL(change);
         default:
             return `-- Unsupported object type: ${change.objectType}`;
     }
@@ -144,8 +152,11 @@ function generateTableSQL(change) {
         }
         const allDefs = [...colDefs, ...constraintDefs].join(',\n');
         let sql = `CREATE TABLE "${data.name}" (\n${allDefs}\n)`;
-        if (data.isPartitioned && data.partitionType && data.partitionKey?.length) {
-            sql += ` PARTITION BY ${data.partitionType} (${data.partitionKey.join(', ')})`;
+        if (data.isPartitioned && data.partitionType && data.partitionKey) {
+            const keyArr = Array.isArray(data.partitionKey) ? data.partitionKey : [data.partitionKey];
+            if (keyArr.length) {
+                sql += ` PARTITION BY ${data.partitionType} (${keyArr.join(', ')})`;
+            }
         }
         return sql + ';';
     }
@@ -226,6 +237,9 @@ function generateConstraintSQL(change) {
     return '';
 }
 function generatePartitionSQL(change) {
+    return '';
+}
+function generatePartitionChildSQL(change) {
     const data = change.after;
     if (change.type === 'CREATE' && data) {
         return `CREATE TABLE "${data.name}" PARTITION OF "${data.parentTable}" ${data.bound};`;
@@ -235,6 +249,33 @@ function generatePartitionSQL(change) {
     }
     return '';
 }
+function generateTableCommentSQL(change) {
+    const data = change.after;
+    if ((change.type === 'CREATE' || change.type === 'ALTER') && data) {
+        const escaped = data.comment.replace(/'/g, "''");
+        return `COMMENT ON TABLE "${data.tableName}" IS '${escaped}';`;
+    }
+    else if (change.type === 'DROP') {
+        const beforeData = change.before;
+        const tableName = beforeData?.tableName || change.objectName;
+        return `COMMENT ON TABLE "${tableName}" IS NULL;`;
+    }
+    return '';
+}
+function generateColumnCommentSQL(change) {
+    const data = change.after;
+    if ((change.type === 'CREATE' || change.type === 'ALTER') && data) {
+        const escaped = data.comment.replace(/'/g, "''");
+        return `COMMENT ON COLUMN "${data.tableName}"."${data.columnName}" IS '${escaped}';`;
+    }
+    else if (change.type === 'DROP') {
+        const beforeData = change.before;
+        const tableName = beforeData?.tableName || change.parentName || '';
+        const columnName = beforeData?.columnName || change.objectName;
+        return `COMMENT ON COLUMN "${tableName}"."${columnName}" IS NULL;`;
+    }
+    return '';
+}
 function generateViewSQL(change) {
     const data = change.after;
     if (change.type === 'CREATE' && data) {
@@ -320,6 +361,28 @@ function generateForeignTableSQL(change) {
     }
     return '';
 }
+function generateCollationSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        const options = [];
+        if (data.locale)
+            options.push(`LOCALE = '${data.locale}'`);
+        if (data.lcCollate)
+            options.push(`LC_COLLATE = '${data.lcCollate}'`);
+        if (data.lcCtype)
+            options.push(`LC_CTYPE = '${data.lcCtype}'`);
+        if (data.provider)
+            options.push(`PROVIDER = ${data.provider}`);
+        if (data.deterministic !== undefined) {
+            options.push(`DETERMINISTIC = ${data.deterministic ? 'TRUE' : 'FALSE'}`);
+        }
+        return `CREATE COLLATION IF NOT EXISTS "${data.name}" (${options.join(', ')});`;
+    }
+    else if (change.type === 'DROP') {
+        return `DROP COLLATION IF EXISTS "${change.objectName}";`;
+    }
+    return '';
+}
 export function createChange(type, objectType, objectName, before, after, parentName) {
     const id = generateChangeId(type, objectType, objectName, parentName);
     const change = {
@@ -341,6 +404,42 @@ export function getChangeDisplayName(change) {
         change.type === 'DROP' ? '-' :
             change.type === 'ALTER' ? '~' :
                 '>';
+    if (change.objectType === 'INDEX') {
+        const data = change.after;
+        const tableName = data?.tableName || change.parentName;
+        if (tableName) {
+            return `${prefix} ${change.objectType} ${change.objectName} on ${tableName}`;
+        }
+    }
+    if (change.objectType === 'PARTITION') {
+        const data = change.after;
+        if (data?.tableName && data?.type && data?.key) {
+            let keyStr = Array.isArray(data.key) ? data.key.join(', ') : data.key;
+            keyStr = keyStr.replace(/[{}]/g, '');
+            return `${prefix} PARTITIONED ${data.tableName} by ${data.type.toUpperCase()}(${keyStr})`;
+        }
+    }
+    if (change.objectType === 'PARTITION_CHILD') {
+        const data = change.after;
+        if (data?.name && data?.parentTable) {
+            const bound = data.bound || '';
+            return `${prefix} PARTITION ${data.name} of ${data.parentTable} ${bound}`;
+        }
+    }
+    if (change.objectType === 'CHECK') {
+        const actionWord = change.type === 'CREATE' ? 'ADD' : change.type === 'DROP' ? 'DROP' : 'ALTER';
+        if (change.parentName) {
+            return `${prefix} ${actionWord} CHECK ${change.objectName} on ${change.parentName}`;
+        }
+        return `${prefix} ${actionWord} CHECK ${change.objectName}`;
+    }
+    if (change.objectType === 'PRIMARY_KEY' || change.objectType === 'FOREIGN_KEY' || change.objectType === 'EXCLUSION') {
+        const actionWord = change.type === 'CREATE' ? 'ADD' : change.type === 'DROP' ? 'DROP' : 'ALTER';
+        if (change.parentName) {
+            return `${prefix} ${actionWord} ${change.objectType.replace('_', ' ')} ${change.objectName} on ${change.parentName}`;
+        }
+        return `${prefix} ${actionWord} ${change.objectType.replace('_', ' ')} ${change.objectName}`;
+    }
     if (change.parentName) {
         return `${prefix} ${change.objectType} ${change.parentName}.${change.objectName}`;
     }
@@ -350,14 +449,18 @@ export function sortChangesByDependency(changes) {
     const order = {
         'EXTENSION': 1,
         'SCHEMA': 2,
+        'SCHEMA_FILE': 0,
         'ENUM': 3,
         'DOMAIN': 4,
         'COMPOSITE_TYPE': 5,
         'SEQUENCE': 6,
         'FOREIGN_SERVER': 7,
         'TABLE': 10,
+        'TABLE_COMMENT': 10,
         'PARTITION': 11,
-        'COLUMN': 12,
+        'PARTITION_CHILD': 12,
+        'COLUMN': 13,
+        'COLUMN_COMMENT': 12,
         'INDEX': 13,
         'CONSTRAINT': 14,
         'PRIMARY_KEY': 14,
@@ -370,6 +473,7 @@ export function sortChangesByDependency(changes) {
         'PROCEDURE': 31,
         'TRIGGER': 40,
         'ENUM_VALUE': 3,
+        'COLLATION': 4,
         'FOREIGN_TABLE': 8,
     };
     return [...changes].sort((a, b) => {

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

@@ -0,0 +1,169 @@
+import * as readline from 'readline';
+const isColorSupported = process.stdout.isTTY && !process.env.NO_COLOR;
+export const 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,
+};
+export 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(`${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;
+        }
+    };
+}
+export function fatal(message, hintMessage) {
+    console.error(`${colors.red('fatal:')} ${message}`);
+    if (hintMessage) {
+        hint(hintMessage);
+    }
+    process.exit(1);
+}
+export function error(message, hintMessage) {
+    console.error(`${colors.red('error:')} ${message}`);
+    if (hintMessage) {
+        hint(hintMessage);
+    }
+}
+export function warning(message) {
+    console.error(`${colors.yellow('warning:')} ${message}`);
+}
+export function hint(message) {
+    console.error(`${colors.yellow('hint:')} ${message}`);
+}
+export function success(message) {
+    console.log(colors.green(message));
+}
+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} ${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(`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`;
+}
+export 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}%`;
+}
+export 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/esm/cli/utils/commit-manager.js

@@ -69,7 +69,7 @@ CREATE INDEX IF NOT EXISTS idx_relq_commits_created
     ON _relq_commits(created_at DESC);
 `;
 export async function ensureCommitsTable(connection) {
-    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,
@@ -87,7 +87,7 @@ export async function ensureCommitsTable(connection) {
     }
 }
 export async function getRemoteCommits(connection, limit = 100) {
-    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,
@@ -124,7 +124,7 @@ export async function getLatestRemoteCommit(connection) {
     return commits.length > 0 ? commits[0] : null;
 }
 export async function addRemoteCommit(connection, commit, limit = 1000) {
-    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/utils/config-loader.js

@@ -64,7 +64,7 @@ export 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;
@@ -73,14 +73,40 @@ export function validateConfig(config) {
     }
     return errors;
 }
-export function requireValidConfig(config) {
+export 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 import("../commands/init.js");
+            const { findProjectRoot } = await import("./project-root.js");
+            const projectRoot = findProjectRoot() || process.cwd();
+            const flags = {};
+            if (options?.calledFrom) {
+                flags['called-from'] = options.calledFrom;
+            }
+            await initCommand({ args: [], flags, config, projectRoot });
+            return;
         }
-        console.error('\nRun "relq init" to create a configuration file.');
-        process.exit(1);
+        catch (e) {
+            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/esm/cli/utils/env-loader.js

@@ -1,5 +1,5 @@
 export function loadEnvConfig() {
-    const connectionString = process.env.DATABASE_CONNECTION_STRING;
+    const connectionString = process.env.RELQ_PG_CONN_URL || process.env.DATABASE_CONNECTION_STRING;
     if (connectionString) {
         return parseConnectionString(connectionString);
     }
@@ -37,7 +37,8 @@ function parseConnectionString(url) {
     }
 }
 export function hasEnvConfig() {
-    return !!(process.env.DATABASE_CONNECTION_STRING ||
+    return !!(process.env.RELQ_PG_CONN_URL ||
+        process.env.DATABASE_CONNECTION_STRING ||
         process.env.DATABASE_HOST);
 }
 export function getConnectionDescription(config) {