relq 1.0.0

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

@@ -0,0 +1,405 @@
+import * as crypto from 'crypto';
+export function generateChangeId(type, objectType, objectName, parentName) {
+    const input = `${type}:${objectType}:${parentName || ''}:${objectName}:${Date.now()}`;
+    return crypto.createHash('sha1').update(input).digest('hex').substring(0, 12);
+}
+export function generateChangeSQL(change) {
+    switch (change.objectType) {
+        case 'EXTENSION':
+            return generateExtensionSQL(change);
+        case 'ENUM':
+            return generateEnumSQL(change);
+        case 'ENUM_VALUE':
+            return generateEnumValueSQL(change);
+        case 'DOMAIN':
+            return generateDomainSQL(change);
+        case 'COMPOSITE_TYPE':
+            return generateCompositeTypeSQL(change);
+        case 'SEQUENCE':
+            return generateSequenceSQL(change);
+        case 'TABLE':
+            return generateTableSQL(change);
+        case 'COLUMN':
+            return generateColumnSQL(change);
+        case 'INDEX':
+            return generateIndexSQL(change);
+        case 'CONSTRAINT':
+        case 'PRIMARY_KEY':
+        case 'FOREIGN_KEY':
+        case 'CHECK':
+        case 'EXCLUSION':
+            return generateConstraintSQL(change);
+        case 'PARTITION':
+            return generatePartitionSQL(change);
+        case 'VIEW':
+            return generateViewSQL(change);
+        case 'MATERIALIZED_VIEW':
+            return generateMaterializedViewSQL(change);
+        case 'FUNCTION':
+        case 'PROCEDURE':
+            return generateFunctionSQL(change);
+        case 'TRIGGER':
+            return generateTriggerSQL(change);
+        case 'FOREIGN_SERVER':
+            return generateForeignServerSQL(change);
+        case 'FOREIGN_TABLE':
+            return generateForeignTableSQL(change);
+        default:
+            return `-- Unsupported object type: ${change.objectType}`;
+    }
+}
+function generateExtensionSQL(change) {
+    if (change.type === 'CREATE') {
+        return `CREATE EXTENSION IF NOT EXISTS "${change.objectName}";`;
+    }
+    else if (change.type === 'DROP') {
+        return `DROP EXTENSION IF EXISTS "${change.objectName}";`;
+    }
+    return '';
+}
+function generateEnumSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        const values = data.values.map(v => `'${v}'`).join(', ');
+        return `CREATE TYPE "${data.name}" AS ENUM (${values});`;
+    }
+    else if (change.type === 'DROP') {
+        return `DROP TYPE IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    return '';
+}
+function generateEnumValueSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        const afterClause = data.after ? ` AFTER '${data.after}'` : '';
+        return `ALTER TYPE "${data.enumName}" ADD VALUE IF NOT EXISTS '${data.value}'${afterClause};`;
+    }
+    return '';
+}
+function generateDomainSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        let sql = `CREATE DOMAIN "${data.name}" AS ${data.baseType}`;
+        if (data.default)
+            sql += ` DEFAULT ${data.default}`;
+        if (data.notNull)
+            sql += ' NOT NULL';
+        if (data.check)
+            sql += ` CHECK (${data.check})`;
+        return sql + ';';
+    }
+    else if (change.type === 'DROP') {
+        return `DROP DOMAIN IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    return '';
+}
+function generateCompositeTypeSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        const attrs = data.attributes.map(a => `    "${a.name}" ${a.type}`).join(',\n');
+        return `CREATE TYPE "${data.name}" AS (\n${attrs}\n);`;
+    }
+    else if (change.type === 'DROP') {
+        return `DROP TYPE IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    return '';
+}
+function generateSequenceSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        let sql = `CREATE SEQUENCE IF NOT EXISTS "${data.name}"`;
+        if (data.startWith)
+            sql += ` START WITH ${data.startWith}`;
+        if (data.incrementBy)
+            sql += ` INCREMENT BY ${data.incrementBy}`;
+        return sql + ';';
+    }
+    else if (change.type === 'DROP') {
+        return `DROP SEQUENCE IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    return '';
+}
+function generateTableSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        const colDefs = [];
+        const constraintDefs = [];
+        for (const col of data.columns) {
+            let def = `    "${col.name}" ${col.dataType}`;
+            if (col.isPrimaryKey)
+                def += ' PRIMARY KEY';
+            if (!col.isNullable && !col.isPrimaryKey)
+                def += ' NOT NULL';
+            if (col.isUnique && !col.isPrimaryKey)
+                def += ' UNIQUE';
+            if (col.defaultValue)
+                def += ` DEFAULT ${col.defaultValue}`;
+            if (col.references) {
+                def += ` REFERENCES "${col.references.table}"("${col.references.column}")`;
+            }
+            colDefs.push(def);
+        }
+        for (const con of data.constraints || []) {
+            constraintDefs.push(`    CONSTRAINT "${con.name}" ${con.definition}`);
+        }
+        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(', ')})`;
+        }
+        return sql + ';';
+    }
+    else if (change.type === 'DROP') {
+        return `DROP TABLE IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    return '';
+}
+function generateColumnSQL(change) {
+    const tableName = change.parentName;
+    if (!tableName)
+        return '';
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        let sql = `ALTER TABLE "${tableName}" ADD COLUMN "${data.name}" ${data.dataType}`;
+        if (!data.isNullable)
+            sql += ' NOT NULL';
+        if (data.defaultValue)
+            sql += ` DEFAULT ${data.defaultValue}`;
+        return sql + ';';
+    }
+    else if (change.type === 'DROP') {
+        return `ALTER TABLE "${tableName}" DROP COLUMN IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    else if (change.type === 'ALTER' && data) {
+        const before = change.before;
+        const lines = [];
+        if (before?.dataType !== data.dataType) {
+            lines.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${data.name}" TYPE ${data.dataType};`);
+        }
+        if (before?.isNullable !== data.isNullable) {
+            if (data.isNullable) {
+                lines.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${data.name}" DROP NOT NULL;`);
+            }
+            else {
+                lines.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${data.name}" SET NOT NULL;`);
+            }
+        }
+        if (before?.defaultValue !== data.defaultValue) {
+            if (data.defaultValue) {
+                lines.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${data.name}" SET DEFAULT ${data.defaultValue};`);
+            }
+            else {
+                lines.push(`ALTER TABLE "${tableName}" ALTER COLUMN "${data.name}" DROP DEFAULT;`);
+            }
+        }
+        return lines.join('\n');
+    }
+    return '';
+}
+function generateIndexSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        const unique = data.isUnique ? 'UNIQUE ' : '';
+        const using = data.type && data.type !== 'btree' ? ` USING ${data.type}` : '';
+        const cols = data.columns.map(c => `"${c}"`).join(', ');
+        let sql = `CREATE ${unique}INDEX IF NOT EXISTS "${data.name}" ON "${data.tableName}"${using} (${cols})`;
+        if (data.where)
+            sql += ` WHERE ${data.where}`;
+        return sql + ';';
+    }
+    else if (change.type === 'DROP') {
+        return `DROP INDEX IF EXISTS "${change.objectName}";`;
+    }
+    return '';
+}
+function generateConstraintSQL(change) {
+    const tableName = change.parentName;
+    if (!tableName)
+        return '';
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        return `ALTER TABLE "${tableName}" ADD CONSTRAINT "${data.name}" ${data.definition};`;
+    }
+    else if (change.type === 'DROP') {
+        return `ALTER TABLE "${tableName}" DROP CONSTRAINT IF EXISTS "${change.objectName}";`;
+    }
+    return '';
+}
+function generatePartitionSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        return `CREATE TABLE "${data.name}" PARTITION OF "${data.parentTable}" ${data.bound};`;
+    }
+    else if (change.type === 'DROP') {
+        return `DROP TABLE IF EXISTS "${change.objectName}";`;
+    }
+    return '';
+}
+function generateViewSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        return `CREATE OR REPLACE VIEW "${data.name}" AS ${data.definition};`;
+    }
+    else if (change.type === 'DROP') {
+        return `DROP VIEW IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    return '';
+}
+function generateMaterializedViewSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        return `CREATE MATERIALIZED VIEW IF NOT EXISTS "${data.name}" AS ${data.definition};`;
+    }
+    else if (change.type === 'DROP') {
+        return `DROP MATERIALIZED VIEW IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    return '';
+}
+function generateFunctionSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        const args = data.args || '';
+        const volatility = data.volatility || 'VOLATILE';
+        return `CREATE OR REPLACE FUNCTION "${data.name}"(${args})
+RETURNS ${data.returns}
+LANGUAGE ${data.language}
+${volatility}
+AS $$
+${data.body}
+$$;`;
+    }
+    else if (change.type === 'DROP') {
+        return `DROP FUNCTION IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    return '';
+}
+function generateTriggerSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        return `CREATE TRIGGER "${data.name}"
+    ${data.timing} ${data.event} ON "${data.tableName}"
+    FOR EACH ROW EXECUTE FUNCTION ${data.functionName}();`;
+    }
+    else if (change.type === 'DROP' && change.parentName) {
+        return `DROP TRIGGER IF EXISTS "${change.objectName}" ON "${change.parentName}";`;
+    }
+    return '';
+}
+function generateForeignServerSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        let sql = `CREATE SERVER IF NOT EXISTS "${data.name}" FOREIGN DATA WRAPPER ${data.fdw}`;
+        if (data.options && Object.keys(data.options).length > 0) {
+            const opts = Object.entries(data.options)
+                .map(([k, v]) => `${k} '${v}'`)
+                .join(', ');
+            sql += ` OPTIONS (${opts})`;
+        }
+        return sql + ';';
+    }
+    else if (change.type === 'DROP') {
+        return `DROP SERVER IF EXISTS "${change.objectName}" CASCADE;`;
+    }
+    return '';
+}
+function generateForeignTableSQL(change) {
+    const data = change.after;
+    if (change.type === 'CREATE' && data) {
+        const cols = data.columns.map(c => `    "${c.name}" ${c.type}`).join(',\n');
+        let sql = `CREATE FOREIGN TABLE IF NOT EXISTS "${data.name}" (\n${cols}\n) SERVER "${data.serverName}"`;
+        if (data.options && Object.keys(data.options).length > 0) {
+            const opts = Object.entries(data.options)
+                .map(([k, v]) => `${k} '${v}'`)
+                .join(', ');
+            sql += ` OPTIONS (${opts})`;
+        }
+        return sql + ';';
+    }
+    else if (change.type === 'DROP') {
+        return `DROP FOREIGN TABLE IF EXISTS "${change.objectName}";`;
+    }
+    return '';
+}
+export function createChange(type, objectType, objectName, before, after, parentName) {
+    const id = generateChangeId(type, objectType, objectName, parentName);
+    const change = {
+        id,
+        type,
+        objectType,
+        objectName,
+        parentName,
+        before,
+        after,
+        sql: '',
+        detectedAt: new Date().toISOString(),
+    };
+    change.sql = generateChangeSQL(change);
+    return change;
+}
+export function getChangeDisplayName(change) {
+    const prefix = change.type === 'CREATE' ? '+' :
+        change.type === 'DROP' ? '-' :
+            change.type === 'ALTER' ? '~' :
+                '>';
+    if (change.parentName) {
+        return `${prefix} ${change.objectType} ${change.parentName}.${change.objectName}`;
+    }
+    return `${prefix} ${change.objectType} ${change.objectName}`;
+}
+export function sortChangesByDependency(changes) {
+    const order = {
+        'EXTENSION': 1,
+        'SCHEMA': 2,
+        'ENUM': 3,
+        'DOMAIN': 4,
+        'COMPOSITE_TYPE': 5,
+        'SEQUENCE': 6,
+        'FOREIGN_SERVER': 7,
+        'TABLE': 10,
+        'PARTITION': 11,
+        'COLUMN': 12,
+        'INDEX': 13,
+        'CONSTRAINT': 14,
+        'PRIMARY_KEY': 14,
+        'FOREIGN_KEY': 15,
+        'CHECK': 14,
+        'EXCLUSION': 14,
+        'VIEW': 20,
+        'MATERIALIZED_VIEW': 21,
+        'FUNCTION': 30,
+        'PROCEDURE': 31,
+        'TRIGGER': 40,
+        'ENUM_VALUE': 3,
+        'FOREIGN_TABLE': 8,
+    };
+    return [...changes].sort((a, b) => {
+        if (a.type === 'CREATE' && b.type === 'DROP')
+            return -1;
+        if (a.type === 'DROP' && b.type === 'CREATE')
+            return 1;
+        return (order[a.objectType] || 50) - (order[b.objectType] || 50);
+    });
+}
+export function generateCombinedSQL(changes) {
+    const sorted = sortChangesByDependency(changes);
+    const lines = [
+        '--',
+        '-- Generated by Relq CLI',
+        `-- Generated at: ${new Date().toISOString()}`,
+        '--',
+        '',
+    ];
+    let currentSection = '';
+    for (const change of sorted) {
+        const section = change.objectType;
+        if (section !== currentSection) {
+            lines.push(`-- ${section}s`);
+            currentSection = section;
+        }
+        if (change.sql) {
+            lines.push(change.sql);
+            lines.push('');
+        }
+    }
+    return lines.join('\n');
+}

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

@@ -0,0 +1,191 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { normalizeSchema, generateSchemaHash } from "./schema-hash.js";
+const RELQ_DIR = '.relq';
+const COMMITS_FILE = 'commits.json';
+const HEAD_FILE = 'HEAD';
+export function ensureRelqDir(baseDir = process.cwd()) {
+    const relqPath = path.join(baseDir, RELQ_DIR);
+    if (!fs.existsSync(relqPath)) {
+        fs.mkdirSync(relqPath, { recursive: true });
+    }
+    return relqPath;
+}
+export function getLocalCommits(baseDir = process.cwd()) {
+    const filePath = path.join(baseDir, RELQ_DIR, COMMITS_FILE);
+    if (!fs.existsSync(filePath)) {
+        return [];
+    }
+    try {
+        const data = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(data);
+    }
+    catch {
+        return [];
+    }
+}
+export function saveLocalCommits(commits, baseDir = process.cwd()) {
+    ensureRelqDir(baseDir);
+    const filePath = path.join(baseDir, RELQ_DIR, COMMITS_FILE);
+    fs.writeFileSync(filePath, JSON.stringify(commits, null, 2), 'utf-8');
+}
+export function getLocalHead(baseDir = process.cwd()) {
+    const filePath = path.join(baseDir, RELQ_DIR, HEAD_FILE);
+    if (!fs.existsSync(filePath)) {
+        return null;
+    }
+    return fs.readFileSync(filePath, 'utf-8').trim() || null;
+}
+export function setLocalHead(hash, baseDir = process.cwd()) {
+    ensureRelqDir(baseDir);
+    const filePath = path.join(baseDir, RELQ_DIR, HEAD_FILE);
+    fs.writeFileSync(filePath, hash, 'utf-8');
+}
+export function addLocalCommit(commit, limit = 1000, baseDir = process.cwd()) {
+    const commits = getLocalCommits(baseDir);
+    commits.push(commit);
+    while (commits.length > limit) {
+        commits.shift();
+    }
+    saveLocalCommits(commits, baseDir);
+    setLocalHead(commit.hash, baseDir);
+}
+export function getLatestLocalCommit(baseDir = process.cwd()) {
+    const commits = getLocalCommits(baseDir);
+    return commits.length > 0 ? commits[commits.length - 1] : null;
+}
+const CREATE_TABLE_SQL = `
+CREATE TABLE IF NOT EXISTS _relq_commits (
+    id SERIAL PRIMARY KEY,
+    hash VARCHAR(40) UNIQUE NOT NULL,
+    parent_hash VARCHAR(40),
+    schema_snapshot JSONB NOT NULL,
+    author VARCHAR(255) NOT NULL,
+    message TEXT,
+    created_at TIMESTAMPTZ DEFAULT NOW()
+);
+
+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 = new Pool({
+        host: connection.host,
+        port: connection.port || 5432,
+        database: connection.database,
+        user: connection.user,
+        password: connection.password,
+        connectionString: connection.url,
+        ssl: connection.ssl,
+    });
+    try {
+        await pool.query(CREATE_TABLE_SQL);
+    }
+    finally {
+        await pool.end();
+    }
+}
+export async function getRemoteCommits(connection, limit = 100) {
+    const { Pool } = await import("../../addon/pg.js");
+    const pool = new Pool({
+        host: connection.host,
+        port: connection.port || 5432,
+        database: connection.database,
+        user: connection.user,
+        password: connection.password,
+        connectionString: connection.url,
+        ssl: connection.ssl,
+    });
+    try {
+        await ensureCommitsTable(connection);
+        const result = await pool.query(`
+            SELECT id, hash, parent_hash, schema_snapshot, author, message, created_at
+            FROM _relq_commits
+            ORDER BY created_at DESC
+            LIMIT $1
+        `, [limit]);
+        return result.rows.map((row) => ({
+            id: row.id,
+            hash: row.hash,
+            parentHash: row.parent_hash,
+            schemaSnapshot: row.schema_snapshot,
+            author: row.author,
+            message: row.message,
+            createdAt: new Date(row.created_at),
+        }));
+    }
+    finally {
+        await pool.end();
+    }
+}
+export async function getLatestRemoteCommit(connection) {
+    const commits = await getRemoteCommits(connection, 1);
+    return commits.length > 0 ? commits[0] : null;
+}
+export async function addRemoteCommit(connection, commit, limit = 1000) {
+    const { Pool } = await import("../../addon/pg.js");
+    const pool = new Pool({
+        host: connection.host,
+        port: connection.port || 5432,
+        database: connection.database,
+        user: connection.user,
+        password: connection.password,
+        connectionString: connection.url,
+        ssl: connection.ssl,
+    });
+    try {
+        await ensureCommitsTable(connection);
+        await pool.query(`
+            INSERT INTO _relq_commits (hash, parent_hash, schema_snapshot, author, message)
+            VALUES ($1, $2, $3, $4, $5)
+            ON CONFLICT (hash) DO NOTHING
+        `, [
+            commit.hash,
+            commit.parentHash || null,
+            JSON.stringify(commit.schemaSnapshot),
+            commit.author,
+            commit.message || null,
+        ]);
+        await pool.query(`
+            DELETE FROM _relq_commits
+            WHERE id NOT IN (
+                SELECT id FROM _relq_commits
+                ORDER BY created_at DESC
+                LIMIT $1
+            )
+        `, [limit]);
+    }
+    finally {
+        await pool.end();
+    }
+}
+export async function createCommit(connection, schema, author, message, commitLimit = 1000, baseDir = process.cwd()) {
+    const hash = generateSchemaHash(schema);
+    const normalized = normalizeSchema(schema);
+    const parentHash = getLocalHead(baseDir);
+    const commit = {
+        hash,
+        parentHash,
+        schemaSnapshot: normalized,
+        author,
+        message,
+        createdAt: new Date(),
+    };
+    addLocalCommit(commit, commitLimit, baseDir);
+    await addRemoteCommit(connection, commit, commitLimit);
+    return commit;
+}
+export async function checkSyncStatus(connection, baseDir = process.cwd()) {
+    const localHead = getLocalHead(baseDir);
+    const remoteCommit = await getLatestRemoteCommit(connection);
+    const remoteHead = remoteCommit?.hash || null;
+    const localCommits = getLocalCommits(baseDir);
+    const remoteCommits = await getRemoteCommits(connection, 100);
+    const inSync = localHead === remoteHead;
+    const localHashes = new Set(localCommits.map(c => c.hash));
+    const remoteHashes = new Set(remoteCommits.map(c => c.hash));
+    const localAhead = [...localHashes].filter(h => !remoteHashes.has(h)).length;
+    const remoteAhead = [...remoteHashes].filter(h => !localHashes.has(h)).length;
+    return { inSync, localHead, remoteHead, localAhead, remoteAhead };
+}

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

@@ -0,0 +1,86 @@
+import { loadConfig as baseLoadConfig } from "../../config/config.js";
+import { loadEnvConfig } from "./env-loader.js";
+import * as fs from 'fs';
+import * as path from 'path';
+const CONFIG_FILENAMES = [
+    'relq.config.ts',
+    'relq.config.js',
+    'relq.config.mjs',
+];
+export function findConfigFile(cwd = process.cwd()) {
+    for (const filename of CONFIG_FILENAMES) {
+        const filepath = path.join(cwd, filename);
+        if (fs.existsSync(filepath)) {
+            return filepath;
+        }
+    }
+    return null;
+}
+export function findConfigFileRecursive(startDir = process.cwd()) {
+    let currentDir = path.resolve(startDir);
+    const root = path.parse(currentDir).root;
+    while (currentDir !== root) {
+        const found = findConfigFile(currentDir);
+        if (found) {
+            return { path: found, directory: currentDir };
+        }
+        currentDir = path.dirname(currentDir);
+    }
+    return null;
+}
+export function configExists(cwd = process.cwd()) {
+    return findConfigFile(cwd) !== null;
+}
+export async function loadConfigWithEnv(configPath) {
+    let config;
+    if (configPath) {
+        config = await baseLoadConfig(configPath);
+    }
+    else {
+        const foundPath = findConfigFile();
+        if (foundPath) {
+            config = await baseLoadConfig(foundPath);
+        }
+        else {
+            config = {};
+        }
+    }
+    if (!config.connection?.host && !config.connection?.url) {
+        const envConfig = loadEnvConfig();
+        if (envConfig) {
+            config = {
+                ...config,
+                connection: {
+                    ...config.connection,
+                    ...envConfig,
+                },
+            };
+        }
+    }
+    return config;
+}
+export function validateConfig(config) {
+    const errors = [];
+    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 hasSchemaDir = typeof config.schema === 'object' && config.schema?.directory;
+    const hasTypeGenOutput = config.typeGeneration?.output;
+    const hasGenerateOutDir = config.generate?.outDir;
+    if (!hasSchemaPath && !hasSchemaDir && !hasTypeGenOutput && !hasGenerateOutDir) {
+        errors.push('No schema output path configured. Set schema, generate.outDir, or typeGeneration.output in relq.config.ts.');
+    }
+    return errors;
+}
+export function requireValidConfig(config) {
+    const errors = validateConfig(config);
+    if (errors.length > 0) {
+        console.error('Configuration errors:');
+        for (const error of errors) {
+            console.error(`  • ${error}`);
+        }
+        console.error('\nRun "relq init" to create a configuration file.');
+        process.exit(1);
+    }
+}