relq 1.0.5 → 1.0.7

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

@@ -2,11 +2,12 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { requireValidConfig } from "../utils/config-loader.js";
 import { fastIntrospectDatabase } from "../utils/fast-introspect.js";
-import { generateTypeScript } from "../utils/type-generator.js";
+import { introspectedToParsedSchema } from "../utils/ast-transformer.js";
+import { generateTypeScriptFromAST } from "../utils/ast-codegen.js";
 import { getConnectionDescription } from "../utils/env-loader.js";
-import { createSpinner, colors, formatBytes, formatDuration, fatal, confirm, warning } from "../utils/cli-utils.js";
+import { createSpinner, colors, formatBytes, formatDuration, fatal, confirm, warning, createMultiProgress } from "../utils/cli-utils.js";
 import { loadRelqignore, isTableIgnored, isColumnIgnored, isIndexIgnored, isConstraintIgnored, isEnumIgnored, isDomainIgnored, isCompositeTypeIgnored, isFunctionIgnored, } from "../utils/relqignore.js";
-import { isInitialized, initRepository, getHead, saveSnapshot, loadSnapshot, createCommit, shortHash, fetchRemoteCommits, ensureRemoteTable, setFetchHead, addUnstagedChanges, getStagedChanges, getUnstagedChanges, clearWorkingState, hashFileContent, saveFileHash, } from "../utils/repo-manager.js";
+import { isInitialized, initRepository, getHead, saveSnapshot, loadSnapshot, createCommit, shortHash, fetchRemoteCommits, ensureRemoteTable, setFetchHead, addUnstagedChanges, getStagedChanges, getUnstagedChanges, clearWorkingState, hashFileContent, saveFileHash, markCommitAsPulled, } from "../utils/repo-manager.js";
 import { compareSchemas } from "../utils/schema-comparator.js";
 function toCamelCase(str) {
     return str.replace(/_([a-z])/g, (_, letter) => letter.toUpperCase());
@@ -145,8 +146,8 @@ export async function pullCommand(context) {
     const author = config.author || 'Relq CLI';
     const schemaPathRaw = typeof config.schema === 'string' ? config.schema : './db/schema.ts';
     const schemaPath = path.resolve(projectRoot, schemaPathRaw);
-    const includeFunctions = config.generate?.includeFunctions ?? false;
-    const includeTriggers = config.generate?.includeTriggers ?? false;
+    const includeFunctions = config.includeFunctions ?? true;
+    const includeTriggers = config.includeTriggers ?? true;
     const spinner = createSpinner();
     const startTime = Date.now();
     console.log('');
@@ -202,12 +203,36 @@ export async function pullCommand(context) {
             setFetchHead(remoteHead, projectRoot);
         }
         spinner.succeed(`Fetched ${remoteCommits.length} remote commits`);
-        spinner.start('Introspecting database...');
+        console.log('');
+        console.log(colors.bold('Introspecting database...'));
+        console.log('');
+        const progress = createMultiProgress();
+        const progressItems = [
+            { id: 'tables', label: 'tables', status: 'pending', count: 0 },
+            { id: 'columns', label: 'columns', status: 'pending', count: 0 },
+            { id: 'constraints', label: 'constraints', status: 'pending', count: 0 },
+            { id: 'indexes', label: 'indexes', status: 'pending', count: 0 },
+            { id: 'checks', label: 'checks', status: 'pending', count: 0 },
+            { id: 'enums', label: 'enums', status: 'pending', count: 0 },
+            { id: 'partitions', label: 'partitions', status: 'pending', count: 0 },
+            { id: 'extensions', label: 'extensions', status: 'pending', count: 0 },
+            ...(includeFunctions ? [{ id: 'functions', label: 'functions', status: 'pending', count: 0 }] : []),
+            ...(includeTriggers ? [{ id: 'triggers', label: 'triggers', status: 'pending', count: 0 }] : []),
+            { id: 'collations', label: 'collations', status: 'pending', count: 0 },
+            { id: 'foreign_servers', label: 'foreign servers', status: 'pending', count: 0 },
+            { id: 'foreign_tables', label: 'foreign tables', status: 'pending', count: 0 },
+        ];
+        progress.setItems(progressItems);
+        progress.start();
         const dbSchema = await fastIntrospectDatabase(connection, undefined, {
             includeFunctions,
             includeTriggers,
+            onDetailedProgress: (update) => {
+                progress.updateItem(update.step, { status: update.status, count: update.count });
+            },
         });
-        spinner.succeed(`Found ${dbSchema.tables.length} tables`);
+        progress.complete();
+        console.log('');
         const ignorePatterns = loadRelqignore(projectRoot);
         const filteredTables = dbSchema.tables
             .filter(t => !isTableIgnored(t.name, ignorePatterns).ignored)
@@ -241,12 +266,21 @@ export async function pullCommand(context) {
                     default: c.defaultValue,
                     primaryKey: c.isPrimaryKey,
                     unique: c.isUnique,
+                    maxLength: c.maxLength ?? null,
+                    precision: c.precision ?? null,
+                    scale: c.scale ?? null,
+                    comment: c.comment || undefined,
+                    isGenerated: c.isGenerated || false,
+                    generationExpression: c.generationExpression ?? null,
                 })),
                 indexes: t.indexes.map(i => ({
                     name: i.name,
                     columns: i.columns,
                     unique: i.isUnique,
                     type: i.type,
+                    definition: i.definition || undefined,
+                    whereClause: i.whereClause || undefined,
+                    comment: i.comment || undefined,
                 })),
                 constraints: t.constraints.map(c => ({
                     name: c.name,
@@ -256,6 +290,12 @@ export async function pullCommand(context) {
                 isPartitioned: t.isPartitioned,
                 partitionType: t.partitionType,
                 partitionKey: normalizePartitionKey(t.partitionKey),
+                comment: t.comment || undefined,
+                partitions: t.childPartitions?.map((p) => ({
+                    name: p.name,
+                    bound: p.partitionBound || '',
+                    boundType: p.partitionType,
+                })) || undefined,
             })),
             enums: filteredEnums.map(e => ({
                 name: e.name,
@@ -359,24 +399,43 @@ export async function pullCommand(context) {
             }
         }
         else if (!schemaExists) {
-            console.log('First pull - creating schema');
+            console.log(colors.bold('Creating schema') + colors.dim(' (first pull)'));
             console.log('');
+            const tableCount = filteredTables.length;
+            const columnCount = filteredTables.reduce((sum, t) => sum + t.columns.length, 0);
             const indexCount = filteredTables.reduce((sum, t) => sum + (t.indexes?.filter(i => !i.isPrimary).length || 0), 0);
-            const partitionCount = filteredTables.filter(t => t.isPartitioned).length;
+            const partitionedCount = filteredTables.filter(t => t.isPartitioned).length;
+            const childPartitionCount = filteredTables.reduce((sum, t) => sum + (t.childPartitions?.length || 0), 0);
             const tableCommentCount = filteredTables.filter(t => t.comment).length;
             const columnCommentCount = filteredTables.reduce((sum, t) => sum + t.columns.filter(c => c.comment).length, 0);
-            console.log('Schema Summary:');
-            console.log(`   ${colors.green(String(filteredTables.length))} tables`);
+            const indexCommentCount = filteredTables.reduce((sum, t) => sum + t.indexes.filter(i => i.comment).length, 0);
+            const summaryItems = [];
+            summaryItems.push({ count: tableCount, label: 'tables' });
+            summaryItems.push({ count: columnCount, label: 'columns' });
             if (indexCount > 0)
-                console.log(`   ${colors.green(String(indexCount))} indexes`);
-            if (partitionCount > 0)
-                console.log(`   ${colors.green(String(partitionCount))} partitioned tables`);
-            if (tableCommentCount > 0)
-                console.log(`   ${colors.green(String(tableCommentCount))} table comments`);
-            if (columnCommentCount > 0)
-                console.log(`   ${colors.green(String(columnCommentCount))} column comments`);
+                summaryItems.push({ count: indexCount, label: 'indexes' });
+            if (partitionedCount > 0) {
+                const partLabel = childPartitionCount > 0
+                    ? `partitioned (${childPartitionCount} child partitions)`
+                    : 'partitioned';
+                summaryItems.push({ count: partitionedCount, label: partLabel });
+            }
+            if (tableCommentCount > 0 || columnCommentCount > 0 || indexCommentCount > 0) {
+                const commentParts = [];
+                if (tableCommentCount > 0)
+                    commentParts.push(`${tableCommentCount} table`);
+                if (columnCommentCount > 0)
+                    commentParts.push(`${columnCommentCount} column`);
+                if (indexCommentCount > 0)
+                    commentParts.push(`${indexCommentCount} index`);
+                summaryItems.push({ count: tableCommentCount + columnCommentCount + indexCommentCount, label: `comments (${commentParts.join(', ')})` });
+            }
             if (dbSchema.extensions.length > 0)
-                console.log(`   ${colors.green(String(dbSchema.extensions.length))} extensions`);
+                summaryItems.push({ count: dbSchema.extensions.length, label: 'extensions' });
+            for (const item of summaryItems) {
+                const countStr = String(item.count).padStart(4);
+                console.log(`${colors.green('[+]')} ${colors.green(countStr)} ${item.label}`);
+            }
             console.log('');
         }
         if (dryRun) {
@@ -385,13 +444,10 @@ export async function pullCommand(context) {
             return;
         }
         spinner.start('Generating TypeScript schema...');
-        const typescript = generateTypeScript(dbSchema, {
-            includeDefineTables: true,
-            includeSchema: true,
-            includeIndexes: true,
-            includeFunctions,
-            includeTriggers,
+        const parsedSchema = await introspectedToParsedSchema(dbSchema);
+        const typescript = generateTypeScriptFromAST(parsedSchema, {
             camelCase: config.generate?.camelCase ?? true,
+            importPath: 'relq/schema-builder',
         });
         spinner.succeed('Generated TypeScript schema');
         const schemaDir = path.dirname(schemaPath);
@@ -494,6 +550,7 @@ export async function pullCommand(context) {
             triggers: filteredTriggers || [],
         };
         const schemaChanges = compareSchemas(beforeSchema, afterSchema);
+        applyTrackingIdsToSnapshot(typescript, currentSchema);
         saveSnapshot(currentSchema, projectRoot);
         const duration = Date.now() - startTime;
         if (noCommit) {
@@ -516,6 +573,7 @@ export async function pullCommand(context) {
             const connectionDesc = getConnectionDescription(connection);
             const commitMessage = `pull: sync from ${connectionDesc}`;
             const commit = createCommit(currentSchema, author, commitMessage, projectRoot);
+            markCommitAsPulled(commit.hash, connection, projectRoot);
             clearWorkingState(projectRoot);
             console.log('');
             console.log(`Pull completed in ${formatDuration(duration)}`);
@@ -598,3 +656,26 @@ function detectObjectConflicts(local, remote) {
     }
     return conflicts;
 }
+function applyTrackingIdsToSnapshot(typescript, snapshot) {
+    for (const table of snapshot.tables) {
+        const tablePattern = new RegExp(`defineTable\\s*\\(\\s*['"]${table.name}['"]\\s*,\\s*\\{[^}]+\\}\\s*,\\s*\\{[^}]*\\$trackingId:\\s*['"]([^'"]+)['"]`, 's');
+        const tableMatch = typescript.match(tablePattern);
+        if (tableMatch) {
+            table.trackingId = tableMatch[1];
+        }
+        for (const col of table.columns) {
+            const colPattern = new RegExp(`(?:${col.tsName}|${col.name}):\\s*\\w+\\([^)]*\\)[^\\n]*\\.\\\$id\\(['"]([^'"]+)['"]\\)`);
+            const colMatch = typescript.match(colPattern);
+            if (colMatch) {
+                col.trackingId = colMatch[1];
+            }
+        }
+        for (const idx of table.indexes) {
+            const idxPattern = new RegExp(`index\\s*\\(\\s*['"]${idx.name}['"]\\s*\\)[^\\n]*\\.\\\$id\\(['"]([^'"]+)['"]\\)`);
+            const idxMatch = typescript.match(idxPattern);
+            if (idxMatch) {
+                idx.trackingId = idxMatch[1];
+            }
+        }
+    }
+}

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

@@ -5,7 +5,7 @@ import { getConnectionDescription } from "../utils/env-loader.js";
 import { colors, createSpinner, fatal, confirm, warning } from "../utils/cli-utils.js";
 import { fastIntrospectDatabase } from "../utils/fast-introspect.js";
 import { loadRelqignore, isTableIgnored, isColumnIgnored, isEnumIgnored, isDomainIgnored, isFunctionIgnored, } from "../utils/relqignore.js";
-import { isInitialized, getHead, shortHash, fetchRemoteCommits, pushCommit, ensureRemoteTable, getAllCommits, loadSnapshot, } from "../utils/repo-manager.js";
+import { isInitialized, getHead, shortHash, fetchRemoteCommits, pushCommit, ensureRemoteTable, getAllCommits, loadSnapshot, isCommitSyncedWith, markCommitAsPushed, getConnectionLabel, } from "../utils/repo-manager.js";
 export async function pushCommand(context) {
     const { config, flags } = context;
     if (!config) {
@@ -41,7 +41,15 @@ export async function pushCommand(context) {
         const localCommits = getAllCommits(projectRoot);
         const remoteHashes = new Set(remoteCommits.map(c => c.hash));
         const localHashes = new Set(localCommits.map(c => c.hash));
-        const toPush = localCommits.filter(c => !remoteHashes.has(c.hash));
+        const toPush = localCommits.filter(c => {
+            if (remoteHashes.has(c.hash))
+                return false;
+            const syncStatus = isCommitSyncedWith(c, connection);
+            if (syncStatus.synced) {
+                return false;
+            }
+            return true;
+        });
         const remoteMissing = remoteCommits.filter(c => !localHashes.has(c.hash));
         spinner.succeed('Checked remote commits');
         spinner.start('Introspecting remote database...');
@@ -131,9 +139,10 @@ export async function pushCommand(context) {
             const commitsToProcess = [...toPush].reverse();
             spinner.start(`Pushing ${toPush.length} commit(s)...`);
             for (const commit of commitsToProcess) {
-                await pushCommit(connection, commit);
+                await pushCommit(connection, commit, projectRoot);
+                markCommitAsPushed(commit.hash, connection, projectRoot);
             }
-            spinner.succeed(`Pushed ${toPush.length} commit(s)`);
+            spinner.succeed(`Pushed ${toPush.length} commit(s) to ${getConnectionLabel(connection)}`);
         }
         if (applySQL) {
             spinner.start('Applying SQL changes...');
@@ -173,6 +182,32 @@ export async function pushCommand(context) {
                 }
                 await client.query('COMMIT');
                 spinner.succeed(`Applied ${statementsRun} statement(s) from ${sqlExecuted} commit(s)`);
+                let hasRenameOperations = false;
+                for (const commit of commitsToProcess) {
+                    const commitPath = path.join(projectRoot, '.relq', 'commits', `${commit.hash}.json`);
+                    if (fs.existsSync(commitPath)) {
+                        const enhancedCommit = JSON.parse(fs.readFileSync(commitPath, 'utf-8'));
+                        if (enhancedCommit.changes?.some((c) => c.type === 'RENAME')) {
+                            hasRenameOperations = true;
+                            break;
+                        }
+                    }
+                }
+                if (hasRenameOperations) {
+                    spinner.start('Updating snapshot after RENAME...');
+                    try {
+                        const updatedSchema = await fastIntrospectDatabase(connection, undefined, {
+                            includeFunctions,
+                            includeTriggers,
+                        });
+                        const snapshotPath = path.join(projectRoot, '.relq', 'snapshot.json');
+                        fs.writeFileSync(snapshotPath, JSON.stringify(updatedSchema, null, 2));
+                        spinner.succeed('Snapshot updated with renamed objects');
+                    }
+                    catch (e) {
+                        spinner.warn('Could not update snapshot after RENAME - run "relq pull" manually');
+                    }
+                }
             }
             catch (error) {
                 try {

package/dist/esm/cli/index.js

@@ -62,7 +62,14 @@ function parseArgs(argv) {
                 flags[arg.slice(2, eqIndex)] = arg.slice(eqIndex + 1);
             }
             else {
-                flags[arg.slice(2)] = true;
+                const nextArg = argv[i + 1];
+                if (nextArg && !nextArg.startsWith('-')) {
+                    flags[arg.slice(2)] = nextArg;
+                    i++;
+                }
+                else {
+                    flags[arg.slice(2)] = true;
+                }
             }
         }
         else if (arg.startsWith('-') && arg.length === 2) {
@@ -175,6 +182,7 @@ async function main() {
         printHelp();
         process.exit(1);
     }
+    console.log('Command:', command);
     let config = null;
     let resolvedProjectRoot = process.cwd();
     if (requiresConfig(command)) {

package/dist/esm/cli/utils/ast/codegen/builder.js

@@ -0,0 +1,291 @@
+import { toCamelCase, escapeString } from "./utils.js";
+export const KNOWN_BUILDER_FUNCTIONS = {
+    'setweight': 'setweight',
+    'to_tsvector': 'toTsvector',
+    'to_tsquery': 'toTsquery',
+    'plainto_tsquery': 'plainToTsquery',
+    'phraseto_tsquery': 'phraseToTsquery',
+    'websearch_to_tsquery': 'websearchToTsquery',
+    'ts_headline': 'tsHeadline',
+    'ts_rank': 'tsRank',
+    'ts_rank_cd': 'tsRankCd',
+    'coalesce': 'coalesce',
+    'nullif': 'nullif',
+    'greatest': 'greatest',
+    'least': 'least',
+    'concat': 'concat',
+    'concat_ws': 'concatWs',
+    'lower': 'lower',
+    'upper': 'upper',
+    'trim': 'trim',
+    'ltrim': 'ltrim',
+    'rtrim': 'rtrim',
+    'length': 'length',
+    'substring': 'substring',
+    'replace': 'replace',
+    'regexp_replace': 'regexpReplace',
+    'split_part': 'splitPart',
+    'now': 'now',
+    'current_timestamp': 'currentTimestamp',
+    'current_date': 'currentDate',
+    'current_time': 'currentTime',
+    'date_trunc': 'dateTrunc',
+    'date_part': 'datePart',
+    'extract': 'extract',
+    'age': 'age',
+    'gen_random_uuid': 'genRandomUuid',
+    'uuid_generate_v4': 'uuidGenerateV4',
+    'jsonb_build_object': 'jsonbBuildObject',
+    'jsonb_agg': 'jsonbAgg',
+    'json_agg': 'jsonAgg',
+    'array_agg': 'arrayAgg',
+    'string_agg': 'stringAgg',
+    'count': 'count',
+    'sum': 'sum',
+    'avg': 'avg',
+    'min': 'min',
+    'max': 'max',
+    'abs': 'abs',
+    'ceil': 'ceil',
+    'floor': 'floor',
+    'round': 'round',
+    'sqrt': 'sqrt',
+    'power': 'power',
+    'mod': 'mod',
+    'random': 'random',
+};
+export function mapFunctionToBuilder(funcName) {
+    return KNOWN_BUILDER_FUNCTIONS[funcName] || null;
+}
+export function astToBuilder(node, prefixOrOptions = 'g') {
+    const opts = typeof prefixOrOptions === 'string'
+        ? { prefix: prefixOrOptions }
+        : prefixOrOptions;
+    const { prefix = 'g', useCamelCase = false, useTableRef = false } = opts;
+    if (!node)
+        return "''";
+    if (node.FuncCall) {
+        const func = node.FuncCall;
+        const funcName = func.funcname?.map((n) => n.String?.sval).filter(Boolean).join('.') || '';
+        const args = (func.args || []).map((a) => astToBuilder(a, opts));
+        const builderMethod = mapFunctionToBuilder(funcName.toLowerCase());
+        if (builderMethod) {
+            return `${prefix}.${builderMethod}(${args.join(', ')})`;
+        }
+        throw new Error(`Unsupported function in generated expression: "${funcName}". Add this function to KNOWN_BUILDER_FUNCTIONS in astToBuilder.`);
+    }
+    if (node.CoalesceExpr) {
+        const args = (node.CoalesceExpr.args || []).map((a) => astToBuilder(a, opts));
+        return `${prefix}.coalesce(${args.join(', ')})`;
+    }
+    if (node.A_Expr) {
+        const expr = node.A_Expr;
+        const op = expr.name?.[0]?.String?.sval || '';
+        const left = astToBuilder(expr.lexpr, opts);
+        const right = astToBuilder(expr.rexpr, opts);
+        switch (op) {
+            case '||':
+                return `__CONCAT__[${left}, ${right}]`;
+            case '->>':
+                return `${prefix}.jsonbExtractText(${left}, ${right})`;
+            case '->':
+                return `${prefix}.jsonbExtract(${left}, ${right})`;
+            case '@@':
+                return `${prefix}.tsMatch(${left}, ${right})`;
+            case '+':
+                return `${prefix}.add(${left}, ${right})`;
+            case '-':
+                return `${prefix}.subtract(${left}, ${right})`;
+            case '*':
+                return `${prefix}.multiply(${left}, ${right})`;
+            case '/':
+                return `${prefix}.divide(${left}, ${right})`;
+            case '%':
+                return `${prefix}.mod(${left}, ${right})`;
+            case '=':
+            case '<>':
+            case '!=':
+            case '<':
+            case '>':
+            case '<=':
+            case '>=':
+                if (useTableRef) {
+                    const methodMap = {
+                        '=': 'eq', '<>': 'ne', '!=': 'neq',
+                        '<': 'lt', '>': 'gt', '<=': 'lte', '>=': 'gte'
+                    };
+                    return `${left}.${methodMap[op]}(${right})`;
+                }
+                return `${prefix}.compare(${left}, '${op}', ${right})`;
+            case '~':
+            case '~*':
+            case '!~':
+            case '!~*':
+                return `${prefix}.regex(${left}, '${op}', ${right})`;
+            default:
+                throw new Error(`Unsupported operator in generated expression: "${op}". Add explicit handling for this operator in astToBuilder.`);
+        }
+    }
+    if (node.ColumnRef) {
+        const fields = (node.ColumnRef.fields || [])
+            .map((f) => f.String?.sval)
+            .filter(Boolean);
+        if (fields.length === 1) {
+            const colName = useCamelCase ? toCamelCase(fields[0]) : fields[0];
+            return `table.${colName}`;
+        }
+        else if (fields.length === 2) {
+            const colName = useCamelCase ? toCamelCase(fields[1]) : fields[1];
+            return `table.${colName}`;
+        }
+        const colName = useCamelCase ? toCamelCase(fields[fields.length - 1]) : fields[fields.length - 1];
+        return `table.${colName}`;
+    }
+    if (node.A_Const) {
+        const val = node.A_Const;
+        if (val.sval !== undefined) {
+            const s = val.sval?.sval ?? val.sval;
+            if (s === '' || s === ' ') {
+                return s === '' ? `${prefix}.asText()` : `${prefix}.asText(' ')`;
+            }
+            return `'${escapeString(String(s))}'`;
+        }
+        else if (val.ival !== undefined) {
+            const i = val.ival?.ival ?? val.ival;
+            return String(i);
+        }
+        else if (val.fval !== undefined) {
+            const f = val.fval?.fval ?? val.fval;
+            return String(f);
+        }
+        else if (val.boolval !== undefined) {
+            return val.boolval?.boolval ? 'true' : 'false';
+        }
+        return `${prefix}.asText()`;
+    }
+    if (node.TypeCast) {
+        const arg = astToBuilder(node.TypeCast.arg, opts);
+        const typeName = node.TypeCast.typeName?.names
+            ?.map((n) => n.String?.sval)
+            .filter(Boolean)
+            .join('.') || '';
+        if (typeName === 'regconfig' || typeName === 'pg_catalog.regconfig') {
+            return arg;
+        }
+        if (typeName === 'text' || typeName === 'pg_catalog.text') {
+            return `${prefix}.asText(${arg})`;
+        }
+        if (typeName === 'varchar' || typeName === 'pg_catalog.varchar' || typeName.includes('character varying')) {
+            return arg;
+        }
+        if (typeName === 'char' || typeName === 'bpchar' || typeName === 'pg_catalog.bpchar') {
+            return arg;
+        }
+        if (typeName === 'numeric' || typeName === 'pg_catalog.numeric') {
+            return arg;
+        }
+        if (typeName === 'int4' || typeName === 'integer' || typeName === 'pg_catalog.int4') {
+            return arg;
+        }
+        return `${prefix}.cast(${arg}, '${typeName}')`;
+    }
+    if (node.NullTest) {
+        const arg = astToBuilder(node.NullTest.arg, opts);
+        const isNull = node.NullTest.nulltesttype === 'IS_NULL';
+        return isNull ? `${prefix}.isNull(${arg})` : `${prefix}.isNotNull(${arg})`;
+    }
+    if (node.BoolExpr) {
+        const boolexpr = node.BoolExpr;
+        const args = (boolexpr.args || []).map((a) => astToBuilder(a, opts));
+        if (useTableRef && args.length >= 2) {
+            switch (boolexpr.boolop) {
+                case 'AND_EXPR': return args.reduce((acc, arg) => `${acc}.and(${arg})`);
+                case 'OR_EXPR': return args.reduce((acc, arg) => `${acc}.or(${arg})`);
+                case 'NOT_EXPR': return `${args[0]}.not()`;
+            }
+        }
+        switch (boolexpr.boolop) {
+            case 'AND_EXPR': return `${prefix}.and(${args.join(', ')})`;
+            case 'OR_EXPR': return `${prefix}.or(${args.join(', ')})`;
+            case 'NOT_EXPR': return `${prefix}.not(${args[0]})`;
+        }
+    }
+    if (node.CaseExpr) {
+        const caseExpr = node.CaseExpr;
+        let chain = `${prefix}.case()`;
+        for (const w of (caseExpr.args || [])) {
+            if (w.CaseWhen) {
+                const condition = astToBuilder(w.CaseWhen.expr, opts);
+                const result = astToBuilder(w.CaseWhen.result, opts);
+                chain += `.when(${condition}, ${result})`;
+            }
+        }
+        if (caseExpr.defresult) {
+            const defResult = astToBuilder(caseExpr.defresult, opts);
+            chain += `.else(${defResult})`;
+        }
+        else {
+            chain += '.end()';
+        }
+        return chain;
+    }
+    const nodeType = Object.keys(node)[0];
+    throw new Error(`Unsupported AST node type in generated expression: "${nodeType}". Add explicit handling for this node type in astToBuilder.`);
+}
+function extractConcatItems(expr) {
+    if (expr.startsWith('__CONCAT__[')) {
+        const inner = expr.slice('__CONCAT__['.length, -1);
+        const items = [];
+        let depth = 0;
+        let current = '';
+        let inQuote = false;
+        for (let i = 0; i < inner.length; i++) {
+            const c = inner[i];
+            if (c === "'" && inner[i - 1] !== '\\') {
+                inQuote = !inQuote;
+            }
+            if (!inQuote) {
+                if (c === '[' || c === '(')
+                    depth++;
+                if (c === ']' || c === ')')
+                    depth--;
+                if (c === ',' && depth === 0) {
+                    items.push(current.trim());
+                    current = '';
+                    continue;
+                }
+            }
+            current += c;
+        }
+        if (current.trim())
+            items.push(current.trim());
+        return items.flatMap(item => extractConcatItems(item));
+    }
+    return [expr];
+}
+function cleanAllConcats(expr) {
+    let result = expr;
+    let iterations = 0;
+    const maxIterations = 50;
+    while (result.includes('__CONCAT__[') && iterations < maxIterations) {
+        const match = result.match(/__CONCAT__\[([^\[\]]*)\]/);
+        if (match) {
+            const replacement = `F.concat(${match[1]})`;
+            result = result.replace(match[0], replacement);
+        }
+        else {
+            break;
+        }
+        iterations++;
+    }
+    return result;
+}
+export function formatGeneratedExpression(expr) {
+    if (expr.startsWith('__CONCAT__[')) {
+        const items = extractConcatItems(expr);
+        const cleanedItems = items.map(item => cleanAllConcats(item));
+        return { isArray: true, items: cleanedItems };
+    }
+    const cleaned = cleanAllConcats(expr);
+    return { isArray: false, items: [cleaned] };
+}