linkgress-orm 0.0.2 → 0.1.0

package/dist/query/query-builder.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CollectionQueryBuilder = exports.ReferenceQueryBuilder = exports.SelectQueryBuilder = exports.QueryBuilder = void 0;
 const conditions_1 = require("./conditions");
+const query_utils_1 = require("./query-utils");
 const subquery_1 = require("./subquery");
 const grouped_query_1 = require("./grouped-query");
 const cte_builder_1 = require("./cte-builder");
@@ -38,6 +39,7 @@ class QueryBuilder {
     }
     /**
      * Define the selection with support for nested queries
+     * UnwrapSelection extracts the value types from SqlFragment<T> expressions
      */
     select(selector) {
         return new SelectQueryBuilder(this.schema, this.client, selector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, this.manualJoins, this.joinCounter, false, // isDistinct defaults to false
@@ -47,12 +49,25 @@ class QueryBuilder {
     }
     /**
      * Add WHERE condition
+     * Multiple where() calls are chained with AND logic
      */
     where(condition) {
         const mockRow = this.createMockRow();
-        this.whereCond = condition(mockRow);
+        const newCondition = condition(mockRow);
+        if (this.whereCond) {
+            this.whereCond = (0, conditions_1.and)(this.whereCond, newCondition);
+        }
+        else {
+            this.whereCond = newCondition;
+        }
         return this;
     }
+    /**
+     * Add CTEs (Common Table Expressions) to the query
+     */
+    with(...ctes) {
+        return new SelectQueryBuilder(this.schema, this.client, (row) => row, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, this.manualJoins, this.joinCounter, false, undefined, ctes, this.collectionStrategy);
+    }
     /**
      * Create mock row for analysis
      */
@@ -118,6 +133,7 @@ class QueryBuilder {
     }
     /**
      * Add a LEFT JOIN to the query with a selector (supports both tables and subqueries)
+     * UnwrapSelection extracts the value types from SqlFragment<T> expressions
      */
     leftJoin(rightTable, condition, selector, alias) {
         // Check if rightTable is a Subquery
@@ -166,6 +182,7 @@ class QueryBuilder {
     }
     /**
      * Add an INNER JOIN to the query with a selector (supports both tables and subqueries)
+     * UnwrapSelection extracts the value types from SqlFragment<T> expressions
      */
     innerJoin(rightTable, condition, selector, alias) {
         // Check if rightTable is a Subquery
@@ -287,35 +304,7 @@ class QueryBuilder {
     orderBy(selector) {
         const mockRow = this.createMockRow();
         const result = selector(mockRow);
-        // Handle array of [field, direction] tuples
-        if (Array.isArray(result) && result.length > 0 && Array.isArray(result[0])) {
-            for (const [fieldRef, direction] of result) {
-                if (fieldRef && typeof fieldRef === 'object' && '__fieldName' in fieldRef) {
-                    this.orderByFields.push({
-                        field: fieldRef.__dbColumnName || fieldRef.__fieldName,
-                        direction: direction || 'ASC'
-                    });
-                }
-            }
-        }
-        // Handle array of fields (all ASC)
-        else if (Array.isArray(result)) {
-            for (const fieldRef of result) {
-                if (fieldRef && typeof fieldRef === 'object' && '__fieldName' in fieldRef) {
-                    this.orderByFields.push({
-                        field: fieldRef.__dbColumnName || fieldRef.__fieldName,
-                        direction: 'ASC'
-                    });
-                }
-            }
-        }
-        // Handle single field
-        else if (result && typeof result === 'object' && '__fieldName' in result) {
-            this.orderByFields.push({
-                field: result.__dbColumnName || result.__fieldName,
-                direction: 'ASC'
-            });
-        }
+        (0, query_utils_1.parseOrderBy)(result, this.orderByFields);
         return this;
     }
 }
@@ -353,6 +342,7 @@ class SelectQueryBuilder {
     }
     /**
      * Transform the selection with a new selector
+     * UnwrapSelection extracts the value types from SqlFragment<T> expressions
      */
     select(selector) {
         // Create a composed selector that applies both transformations
@@ -364,13 +354,22 @@ class SelectQueryBuilder {
     }
     /**
      * Add WHERE condition
+     * Multiple where() calls are chained with AND logic
      * Note: The row parameter represents the selected shape (after select())
      */
     where(condition) {
         const mockRow = this.createMockRow();
         // Apply the selector to get the selected shape that the user sees in the WHERE condition
         const selectedMock = this.selector(mockRow);
-        this.whereCond = condition(selectedMock);
+        // Wrap in proxy - for WHERE, we preserve original column names
+        const fieldRefProxy = this.createFieldRefProxy(selectedMock, true);
+        const newCondition = condition(fieldRefProxy);
+        if (this.whereCond) {
+            this.whereCond = (0, conditions_1.and)(this.whereCond, newCondition);
+        }
+        else {
+            this.whereCond = newCondition;
+        }
         return this;
     }
     /**
@@ -404,36 +403,12 @@ class SelectQueryBuilder {
     orderBy(selector) {
         const mockRow = this.createMockRow();
         const selectedMock = this.selector(mockRow);
-        const result = selector(selectedMock);
-        // Handle array of [field, direction] tuples
-        if (Array.isArray(result) && result.length > 0 && Array.isArray(result[0])) {
-            for (const [fieldRef, direction] of result) {
-                if (fieldRef && typeof fieldRef === 'object' && '__fieldName' in fieldRef) {
-                    this.orderByFields.push({
-                        field: fieldRef.__dbColumnName || fieldRef.__fieldName,
-                        direction: direction || 'ASC'
-                    });
-                }
-            }
-        }
-        // Handle array of fields (all ASC)
-        else if (Array.isArray(result)) {
-            for (const fieldRef of result) {
-                if (fieldRef && typeof fieldRef === 'object' && '__fieldName' in fieldRef) {
-                    this.orderByFields.push({
-                        field: fieldRef.__dbColumnName || fieldRef.__fieldName,
-                        direction: 'ASC'
-                    });
-                }
-            }
-        }
-        // Handle single field
-        else if (result && typeof result === 'object' && '__fieldName' in result) {
-            this.orderByFields.push({
-                field: result.__dbColumnName || result.__fieldName,
-                direction: 'ASC'
-            });
-        }
+        // Wrap selectedMock in a proxy that returns FieldRefs for property access
+        const fieldRefProxy = this.createFieldRefProxy(selectedMock);
+        const result = selector(fieldRefProxy);
+        // Clear previous orderBy - last one takes precedence
+        this.orderByFields = [];
+        (0, query_utils_1.parseOrderBy)(result, this.orderByFields);
         return this;
     }
     /**
@@ -483,10 +458,7 @@ class SelectQueryBuilder {
         };
         return new SelectQueryBuilder(this.schema, this.client, composedSelector, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, updatedJoins, newJoinCounter, this.isDistinct, this.schemaRegistry, this.ctes, this.collectionStrategy);
     }
-    /**
-     * Add a LEFT JOIN to the query with a selector
-     * Note: After select(), the left parameter in the join will be the selected shape (TSelection)
-     */
+    // Implementation
     leftJoin(rightTable, condition, selector, alias) {
         // Check if rightTable is a CTE
         if ((0, cte_builder_1.isCte)(rightTable)) {
@@ -596,6 +568,7 @@ class SelectQueryBuilder {
     /**
      * Add an INNER JOIN to the query with a selector
      * Note: After select(), the left parameter in the join will be the selected shape (TSelection)
+     * UnwrapSelection extracts the value types from SqlFragment<T> expressions
      */
     innerJoin(rightTable, condition, selector, alias) {
         // Check if rightTable is a Subquery
@@ -1304,11 +1277,18 @@ class SelectQueryBuilder {
         }
         // Add relations as CollectionQueryBuilder or ReferenceQueryBuilder
         for (const [relName, relConfig] of Object.entries(this.schema.relations)) {
+            // Try to get target schema from registry (preferred, has full relations) or targetTableBuilder
+            let targetSchema;
+            if (this.schemaRegistry) {
+                targetSchema = this.schemaRegistry.get(relConfig.targetTable);
+            }
+            if (!targetSchema && relConfig.targetTableBuilder) {
+                targetSchema = relConfig.targetTableBuilder.build();
+            }
             if (relConfig.type === 'many') {
                 Object.defineProperty(mock, relName, {
                     get: () => {
-                        // Don't call build() - force registry lookup to get schema with relations
-                        return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', this.schema.name, undefined, // Don't pass schema, force registry lookup
+                        return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', this.schema.name, targetSchema, // Pass the target schema directly
                         this.schemaRegistry // Pass schema registry for nested resolution
                         );
                     },
@@ -1320,8 +1300,7 @@ class SelectQueryBuilder {
                 // For single reference (many-to-one), create a ReferenceQueryBuilder
                 Object.defineProperty(mock, relName, {
                     get: () => {
-                        // Don't call build() - force registry lookup to get schema with relations
-                        const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, undefined, // Don't pass schema, force registry lookup
+                        const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema, // Pass the target schema directly
                         this.schemaRegistry // Pass schema registry for nested resolution
                         );
                         // Return a mock object that exposes the target table's columns
@@ -1334,6 +1313,67 @@ class SelectQueryBuilder {
         }
         return mock;
     }
+    /**
+     * Create a proxy that wraps selected values and returns FieldRefs for property access
+     * This enables orderBy and other operations to work with chained selects
+     * @param preserveOriginal - If true (for WHERE), preserve original column names; if false (for ORDER BY), use alias names
+     */
+    createFieldRefProxy(selectedMock, preserveOriginal = false) {
+        if (!selectedMock || typeof selectedMock !== 'object') {
+            return selectedMock;
+        }
+        // If it already has FieldRef properties, return as-is
+        if ('__fieldName' in selectedMock && '__dbColumnName' in selectedMock) {
+            return selectedMock;
+        }
+        // Create a proxy that returns FieldRefs for each property access
+        return new Proxy(selectedMock, {
+            get: (target, prop) => {
+                if (typeof prop === 'symbol' || prop === 'constructor' || prop === 'then') {
+                    return target[prop];
+                }
+                const value = target[prop];
+                // If the value is already a FieldRef
+                if (value && typeof value === 'object' && '__fieldName' in value && '__dbColumnName' in value) {
+                    if (preserveOriginal) {
+                        // For WHERE: preserve original column name and table alias
+                        // This ensures WHERE references the actual database column
+                        return {
+                            __fieldName: prop,
+                            __dbColumnName: value.__dbColumnName,
+                            __tableAlias: value.__tableAlias,
+                        };
+                    }
+                    else {
+                        // For ORDER BY: use the alias (property name) as the column name
+                        // In chained selects, the alias becomes the column name in the subquery
+                        return {
+                            __fieldName: prop,
+                            __dbColumnName: prop,
+                            // No table alias - column comes from the selection/subquery
+                        };
+                    }
+                }
+                // If the value is a SqlFragment, treat it as a FieldRef using the property name as the alias
+                if (value && typeof value === 'object' && value instanceof conditions_1.SqlFragment) {
+                    return {
+                        __fieldName: prop,
+                        __dbColumnName: prop,
+                    };
+                }
+                // If the value is an object (nested selection), recursively wrap it
+                if (value && typeof value === 'object' && !Array.isArray(value)) {
+                    return this.createFieldRefProxy(value, preserveOriginal);
+                }
+                // For primitive values or arrays, create a FieldRef
+                // Use the property name as both fieldName and dbColumnName
+                return {
+                    __fieldName: prop,
+                    __dbColumnName: prop,
+                };
+            }
+        });
+    }
     /**
      * Detect navigation property references in selection and add necessary JOINs
      */
@@ -1373,6 +1413,43 @@ class SelectQueryBuilder {
             }
         }
     }
+    /**
+     * Detect navigation property references in a WHERE condition and add necessary JOINs
+     */
+    detectAndAddJoinsFromCondition(condition, joins) {
+        if (!condition) {
+            return;
+        }
+        // Get all field references from the condition
+        const fieldRefs = condition.getFieldRefs();
+        for (const fieldRef of fieldRefs) {
+            if ('__tableAlias' in fieldRef && fieldRef.__tableAlias) {
+                const tableAlias = fieldRef.__tableAlias;
+                // Check if this references a related table that isn't already joined
+                if (tableAlias !== this.schema.name && !joins.some(j => j.alias === tableAlias)) {
+                    // Find the relation config for this navigation
+                    const relation = this.schema.relations[tableAlias];
+                    if (relation && relation.type === 'one') {
+                        // Get target schema from targetTableBuilder if available
+                        let targetSchema;
+                        if (relation.targetTableBuilder) {
+                            const targetTableSchema = relation.targetTableBuilder.build();
+                            targetSchema = targetTableSchema.schema;
+                        }
+                        // Add a JOIN for this reference
+                        joins.push({
+                            alias: tableAlias,
+                            targetTable: relation.targetTable,
+                            targetSchema,
+                            foreignKeys: relation.foreignKeys || [relation.foreignKey || ''],
+                            matches: relation.matches || [],
+                            isMandatory: relation.isMandatory ?? false,
+                        });
+                    }
+                }
+            }
+        }
+    }
     /**
      * Build SQL query
      */
@@ -1387,6 +1464,8 @@ class SelectQueryBuilder {
         const joins = [];
         // Scan selection for navigation property references and add JOINs
         this.detectAndAddJoinsFromSelection(selection, joins);
+        // Scan WHERE condition for navigation property references and add JOINs
+        this.detectAndAddJoinsFromCondition(this.whereCond, joins);
         // Handle case where selection is a single value (not an object with properties)
         if (selection instanceof conditions_1.SqlFragment) {
             // Single SQL fragment - just build it directly
@@ -1411,11 +1490,19 @@ class SelectQueryBuilder {
             // Process selection object properties
             for (const [key, value] of Object.entries(selection)) {
                 if (value instanceof CollectionQueryBuilder || (value && typeof value === 'object' && '__collectionResult' in value)) {
-                    // Handle collection - create CTE (works for both CollectionQueryBuilder and CollectionResult)
-                    const cteName = `cte_${context.cteCounter++}`;
+                    // Handle collection - delegate to strategy pattern via buildCTE
+                    // The strategy handles CTE/LATERAL specifics and returns necessary info
                     const cteData = value.buildCTE ? value.buildCTE(context) : value.buildCTE(context);
-                    context.ctes.set(cteName, cteData);
-                    collectionFields.push({ name: key, cteName });
+                    const isCTE = cteData.isCTE !== false; // Default to CTE if not specified
+                    // Note: For CTE strategy, context.ctes is already populated by the strategy
+                    // We don't need to add it again - the strategy has already done this
+                    collectionFields.push({
+                        name: key,
+                        cteName: cteData.tableName || `cte_${context.cteCounter - 1}`, // Use tableName from result or infer from counter
+                        isCTE,
+                        joinClause: cteData.joinClause,
+                        selectExpression: cteData.selectExpression,
+                    });
                 }
                 else if (value instanceof subquery_1.Subquery || (value && typeof value === 'object' && 'buildSql' in value && typeof value.buildSql === 'function' && '__mode' in value)) {
                     // Handle Subquery - build SQL and wrap in parentheses
@@ -1601,8 +1688,14 @@ class SelectQueryBuilder {
                 }
             } // End of for loop
         } // End of else block
-        // Add collection fields as JSON/array aggregations joined from CTEs
-        for (const { name, cteName } of collectionFields) {
+        // Add collection fields as JSON/array aggregations joined from CTEs or LATERAL joins
+        for (const { name, cteName, selectExpression } of collectionFields) {
+            // If selectExpression is provided (from strategy), use it directly
+            if (selectExpression) {
+                selectParts.push(`${selectExpression} as "${name}"`);
+                continue;
+            }
+            // Fallback to old logic for backward compatibility
             // Check if this is an array aggregation (from toNumberList/toStringList)
             const collectionValue = selection[name];
             const isArrayAgg = collectionValue && typeof collectionValue === 'object' && 'isArrayAggregation' in collectionValue && collectionValue.isArrayAggregation();
@@ -1728,9 +1821,16 @@ class SelectQueryBuilder {
             const joinTableName = this.getQualifiedTableName(join.targetTable, join.targetSchema);
             fromClause += `\n${joinType} ${joinTableName} AS "${join.alias}" ON ${onConditions.join(' AND ')}`;
         }
-        // Join CTEs for collections
-        for (const { cteName } of collectionFields) {
-            fromClause += `\nLEFT JOIN "${cteName}" ON "${cteName}".parent_id = ${qualifiedTableName}.id`;
+        // Join CTEs and LATERAL subqueries for collections
+        for (const { cteName, isCTE, joinClause } of collectionFields) {
+            if (isCTE) {
+                // CTE strategy - join by parent_id
+                fromClause += `\nLEFT JOIN "${cteName}" ON "${cteName}".parent_id = ${qualifiedTableName}.id`;
+            }
+            else if (joinClause) {
+                // LATERAL strategy - use the provided join clause (contains full LATERAL subquery)
+                fromClause += `\n${joinClause}`;
+            }
         }
         // Add DISTINCT if needed
         const distinctClause = this.isDistinct ? 'DISTINCT ' : '';
@@ -2106,7 +2206,35 @@ class SelectQueryBuilder {
             const mockRow = this.createMockRow();
             selectionMetadata = this.selector(mockRow);
         }
-        return new subquery_1.Subquery(sqlBuilder, mode, selectionMetadata);
+        // Extract outer field refs from the WHERE condition
+        // These are field refs that reference tables other than this subquery's table
+        // and need to be propagated to the outer query for JOIN detection
+        const outerFieldRefs = this.extractOuterFieldRefs();
+        return new subquery_1.Subquery(sqlBuilder, mode, selectionMetadata, outerFieldRefs);
+    }
+    /**
+     * Extract field refs from the WHERE condition that reference outer queries.
+     * These are field refs with a __tableAlias that doesn't match this query's schema.
+     */
+    extractOuterFieldRefs() {
+        if (!this.whereCond) {
+            return [];
+        }
+        const allRefs = this.whereCond.getFieldRefs();
+        const outerRefs = [];
+        const currentTableName = this.schema.name;
+        for (const ref of allRefs) {
+            // Check if this ref is from an outer query (different table alias)
+            if ('__tableAlias' in ref && ref.__tableAlias) {
+                const tableAlias = ref.__tableAlias;
+                // If the table alias doesn't match our current schema, it's from an outer query
+                // Also check if it's not a navigation property of this table (which would be in schema.relations)
+                if (tableAlias !== currentTableName && !this.schema.relations[tableAlias]) {
+                    outerRefs.push(ref);
+                }
+            }
+        }
+        return outerRefs;
     }
 }
 exports.SelectQueryBuilder = SelectQueryBuilder;
@@ -2120,12 +2248,15 @@ class ReferenceQueryBuilder {
         this.foreignKeys = foreignKeys;
         this.matches = matches;
         this.isMandatory = isMandatory;
-        this.targetTableSchema = targetTableSchema;
         this.schemaRegistry = schemaRegistry;
-        // If targetTableSchema is not provided but we have a registry, look it up
-        if (!this.targetTableSchema && this.schemaRegistry) {
+        // Prefer registry lookup (has full relations) over passed schema
+        if (this.schemaRegistry) {
             this.targetTableSchema = this.schemaRegistry.get(targetTable);
         }
+        // Fallback to passed schema if registry lookup failed
+        if (!this.targetTableSchema) {
+            this.targetTableSchema = targetTableSchema;
+        }
     }
     /**
      * Get the alias to use for this reference in the query
@@ -2186,14 +2317,20 @@ class ReferenceQueryBuilder {
             // Add navigation properties (both collections and references)
             if (this.targetTableSchema.relations) {
                 for (const [relName, relConfig] of Object.entries(this.targetTableSchema.relations)) {
+                    // Try to get target schema from registry (preferred, has full relations) or targetTableBuilder
+                    let nestedTargetSchema;
+                    if (this.schemaRegistry) {
+                        nestedTargetSchema = this.schemaRegistry.get(relConfig.targetTable);
+                    }
+                    if (!nestedTargetSchema && relConfig.targetTableBuilder) {
+                        nestedTargetSchema = relConfig.targetTableBuilder.build();
+                    }
                     if (relConfig.type === 'many') {
                         // Collection navigation
                         Object.defineProperty(mock, relName, {
                             get: () => {
-                                // Don't call build() - it returns schema without relations
-                                // Instead, pass undefined and let CollectionQueryBuilder look it up from registry
                                 const fk = relConfig.foreignKey || relConfig.foreignKeys?.[0] || '';
-                                return new CollectionQueryBuilder(relName, relConfig.targetTable, fk, this.targetTable, undefined, // Don't pass schema, force registry lookup
+                                return new CollectionQueryBuilder(relName, relConfig.targetTable, fk, this.targetTable, nestedTargetSchema, // Pass the target schema directly
                                 this.schemaRegistry // Pass schema registry for nested resolution
                                 );
                             },
@@ -2205,9 +2342,7 @@ class ReferenceQueryBuilder {
                         // Reference navigation
                         Object.defineProperty(mock, relName, {
                             get: () => {
-                                // Don't call build() - it returns schema without relations
-                                // Instead, pass undefined and let ReferenceQueryBuilder look it up from registry
-                                const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, undefined, // Don't pass schema, force registry lookup
+                                const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, nestedTargetSchema, // Pass the target schema directly
                                 this.schemaRegistry // Pass schema registry for nested resolution
                                 );
                                 return refBuilder.createMockTargetRow();
@@ -2248,9 +2383,16 @@ class CollectionQueryBuilder {
         this.foreignKey = foreignKey;
         this.sourceTable = sourceTable;
         this.schemaRegistry = schemaRegistry;
-        // If targetTableSchema is not provided but we have a registry, look it up
-        if (!this.targetTableSchema && this.schemaRegistry) {
-            this.targetTableSchema = this.schemaRegistry.get(targetTable);
+        // Prefer registry lookup (has full relations) over passed schema
+        if (this.schemaRegistry) {
+            const registrySchema = this.schemaRegistry.get(targetTable);
+            if (registrySchema) {
+                this.targetTableSchema = registrySchema;
+            }
+        }
+        // Fallback to passed schema if registry lookup failed
+        if (!this.targetTableSchema) {
+            this.targetTableSchema = targetTableSchema;
         }
     }
     /**
@@ -2277,11 +2419,18 @@ class CollectionQueryBuilder {
     }
     /**
      * Filter collection items
+     * Multiple where() calls are chained with AND logic
      */
     where(condition) {
         // Create mock item with proper schema if available
         const mockItem = this.createMockItem();
-        this.whereCond = condition(mockItem);
+        const newCondition = condition(mockItem);
+        if (this.whereCond) {
+            this.whereCond = (0, conditions_1.and)(this.whereCond, newCondition);
+        }
+        else {
+            this.whereCond = newCondition;
+        }
         return this;
     }
     /**
@@ -2378,35 +2527,7 @@ class CollectionQueryBuilder {
     orderBy(selector) {
         const mockItem = this.createMockItem();
         const result = selector(mockItem);
-        // Handle array of [field, direction] tuples
-        if (Array.isArray(result) && result.length > 0 && Array.isArray(result[0])) {
-            for (const [fieldRef, direction] of result) {
-                if (fieldRef && typeof fieldRef === 'object' && '__fieldName' in fieldRef) {
-                    this.orderByFields.push({
-                        field: fieldRef.__dbColumnName || fieldRef.__fieldName,
-                        direction: direction || 'ASC'
-                    });
-                }
-            }
-        }
-        // Handle array of fields (all ASC)
-        else if (Array.isArray(result)) {
-            for (const fieldRef of result) {
-                if (fieldRef && typeof fieldRef === 'object' && '__fieldName' in fieldRef) {
-                    this.orderByFields.push({
-                        field: fieldRef.__dbColumnName || fieldRef.__fieldName,
-                        direction: 'ASC'
-                    });
-                }
-            }
-        }
-        // Handle single field
-        else if (result && typeof result === 'object' && '__fieldName' in result) {
-            this.orderByFields.push({
-                field: result.__dbColumnName || result.__fieldName,
-                direction: 'ASC'
-            });
-        }
+        (0, query_utils_1.parseOrderBy)(result, this.orderByFields);
         return this;
     }
     /**
@@ -2524,14 +2645,61 @@ class CollectionQueryBuilder {
     /**
      * Build CTE for this collection query
      * Now delegates to collection strategy pattern
+     * Returns full CollectionAggregationResult for strategies that need special handling (like LATERAL)
      */
     buildCTE(context, client, parentIds) {
-        // Determine strategy type - default to 'jsonb' if not specified
-        const strategyType = context.collectionStrategy || 'jsonb';
+        // Determine strategy type - default to 'lateral' if not specified
+        const strategyType = context.collectionStrategy || 'lateral';
         const strategy = collection_strategy_factory_1.CollectionStrategyFactory.getStrategy(strategyType);
-        // Build selected fields configuration
+        // Build selected fields configuration (supports nested objects)
         const selectedFieldConfigs = [];
         const localParams = [];
+        // Helper function to check if a value is a plain object (not FieldRef, SqlFragment, etc.)
+        const isPlainObject = (val) => {
+            return typeof val === 'object' &&
+                val !== null &&
+                !('__dbColumnName' in val) &&
+                !(val instanceof conditions_1.SqlFragment) &&
+                !Array.isArray(val) &&
+                val.constructor === Object;
+        };
+        // Helper function to recursively process fields and build SelectedField structures
+        const processField = (alias, field) => {
+            if (field instanceof conditions_1.SqlFragment) {
+                // SQL Fragment - build the SQL expression
+                const sqlBuildContext = {
+                    paramCounter: context.paramCounter,
+                    params: context.allParams,
+                };
+                const fragmentSql = field.buildSql(sqlBuildContext);
+                context.paramCounter = sqlBuildContext.paramCounter;
+                return { alias, expression: fragmentSql };
+            }
+            else if (typeof field === 'object' && field !== null && '__dbColumnName' in field) {
+                // FieldRef object - use database column name
+                const dbColumnName = field.__dbColumnName;
+                return { alias, expression: `"${dbColumnName}"` };
+            }
+            else if (typeof field === 'string') {
+                // Simple string reference (for backward compatibility)
+                return { alias, expression: `"${field}"` };
+            }
+            else if (isPlainObject(field)) {
+                // Nested object - recursively process its fields
+                const nestedFields = [];
+                for (const [nestedAlias, nestedField] of Object.entries(field)) {
+                    nestedFields.push(processField(nestedAlias, nestedField));
+                }
+                return { alias, nested: nestedFields };
+            }
+            else {
+                // Literal value or expression
+                const expression = `$${context.paramCounter++}`;
+                context.allParams.push(field);
+                localParams.push(field);
+                return { alias, expression };
+            }
+        };
         // Step 1: Build field selection configuration
         if (this.selector) {
             const mockItem = this.createMockItem();
@@ -2547,54 +2715,31 @@ class CollectionQueryBuilder {
                 });
             }
             else {
-                // Object selection - extract each field
+                // Object selection - extract each field (with support for nested objects)
                 for (const [alias, field] of Object.entries(selectedFields)) {
-                    if (field instanceof conditions_1.SqlFragment) {
-                        // SQL Fragment - build the SQL expression
-                        const sqlBuildContext = {
-                            paramCounter: context.paramCounter,
-                            params: context.allParams,
-                        };
-                        const fragmentSql = field.buildSql(sqlBuildContext);
-                        context.paramCounter = sqlBuildContext.paramCounter;
-                        selectedFieldConfigs.push({
-                            alias,
-                            expression: fragmentSql,
-                        });
-                    }
-                    else if (typeof field === 'object' && field !== null && '__dbColumnName' in field) {
-                        // FieldRef object - use database column name
-                        const dbColumnName = field.__dbColumnName;
-                        selectedFieldConfigs.push({
-                            alias,
-                            expression: `"${dbColumnName}"`,
-                        });
-                    }
-                    else if (typeof field === 'string') {
-                        // Simple string reference (for backward compatibility)
-                        selectedFieldConfigs.push({
-                            alias,
-                            expression: `"${field}"`,
-                        });
-                    }
-                    else {
-                        // Literal value or expression
-                        selectedFieldConfigs.push({
-                            alias,
-                            expression: `$${context.paramCounter++}`,
-                        });
-                        context.allParams.push(field);
-                        localParams.push(field);
-                    }
+                    selectedFieldConfigs.push(processField(alias, field));
                 }
             }
         }
         else {
-            // No selector - select all fields (use * for now, strategy will handle it)
-            selectedFieldConfigs.push({
-                alias: '*',
-                expression: '*',
-            });
+            // No selector - select all fields from the target table schema
+            if (this.targetTableSchema && this.targetTableSchema.columns) {
+                for (const [colName, colBuilder] of Object.entries(this.targetTableSchema.columns)) {
+                    const colConfig = colBuilder.build ? colBuilder.build() : colBuilder;
+                    const dbColumnName = colConfig.name || colName;
+                    selectedFieldConfigs.push({
+                        alias: colName,
+                        expression: `"${dbColumnName}"`,
+                    });
+                }
+            }
+            else {
+                // Fallback: use * (less ideal, may cause issues)
+                selectedFieldConfigs.push({
+                    alias: '*',
+                    expression: '*',
+                });
+            }
         }
         // Step 2: Build WHERE clause SQL (without WHERE keyword)
         let whereClause;
@@ -2687,10 +2832,14 @@ class CollectionQueryBuilder {
             // Async strategy - return special marker with the promise
             return result;
         }
-        // Synchronous strategy (JSONB/CTE)
+        // Synchronous strategy (JSONB/CTE/LATERAL)
         return {
             sql: result.sql,
             params: localParams,
+            isCTE: result.isCTE,
+            joinClause: result.joinClause,
+            selectExpression: result.selectExpression,
+            tableName: result.tableName,
         };
     }
 }