linkgress-orm 0.0.3 → 0.1.1

package/dist/query/query-builder.js

@@ -1,11 +1,117 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CollectionQueryBuilder = exports.ReferenceQueryBuilder = exports.SelectQueryBuilder = exports.QueryBuilder = void 0;
+exports.getColumnNameMapForSchema = getColumnNameMapForSchema;
+exports.getRelationEntriesForSchema = getRelationEntriesForSchema;
+exports.getTargetSchemaForRelation = getTargetSchemaForRelation;
+exports.createNestedFieldRefProxy = createNestedFieldRefProxy;
 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");
 const collection_strategy_factory_1 = require("./collection-strategy.factory");
+/**
+ * Performance utility: Get column name map from schema, using cached version if available
+ */
+function getColumnNameMapForSchema(schema) {
+    if (schema.columnNameMap) {
+        return schema.columnNameMap;
+    }
+    // Fallback: build the map (for schemas that weren't built with the new TableBuilder)
+    const map = new Map();
+    for (const [colName, colBuilder] of Object.entries(schema.columns)) {
+        map.set(colName, colBuilder.build().name);
+    }
+    return map;
+}
+/**
+ * Performance utility: Get relation entries array from schema, using cached version if available
+ */
+function getRelationEntriesForSchema(schema) {
+    if (schema.relationEntries) {
+        return schema.relationEntries;
+    }
+    // Fallback: build the array (for schemas that weren't built with the new TableBuilder)
+    return Object.entries(schema.relations);
+}
+/**
+ * Performance utility: Get target schema for a relation, using cached version if available
+ */
+function getTargetSchemaForRelation(schema, relName, relConfig) {
+    // Try cached version first
+    if (schema.relationSchemaCache) {
+        const cached = schema.relationSchemaCache.get(relName);
+        if (cached)
+            return cached;
+    }
+    // Fallback: build the schema
+    if (relConfig.targetTableBuilder) {
+        return relConfig.targetTableBuilder.build();
+    }
+    return undefined;
+}
+// Performance: Cache nested field ref proxies per table alias
+const nestedFieldRefProxyCache = new Map();
+/**
+ * Creates a nested proxy that supports accessing properties at any depth.
+ * This allows patterns like `p.product.priceMode` to work even without full schema information.
+ * Each property access returns an object that is both a FieldRef and can be further accessed.
+ *
+ * @param tableAlias The table alias to use for the FieldRef
+ * @returns A proxy that creates FieldRefs for any property access
+ */
+function createNestedFieldRefProxy(tableAlias) {
+    // Return cached proxy if available
+    const cached = nestedFieldRefProxyCache.get(tableAlias);
+    if (cached)
+        return cached;
+    const handler = {
+        get: (_target, prop) => {
+            // Handle Symbol.toPrimitive for string conversion (used in template literals)
+            if (prop === Symbol.toPrimitive || prop === 'toString' || prop === 'valueOf') {
+                return () => `[NestedFieldRefProxy:${tableAlias}]`;
+            }
+            if (typeof prop === 'symbol')
+                return undefined;
+            // Return an object that is both a FieldRef AND a proxy for further nesting
+            const fieldRef = {
+                __fieldName: prop,
+                __dbColumnName: prop,
+                __tableAlias: tableAlias,
+            };
+            // Return a proxy that acts as both the FieldRef and allows further property access
+            return new Proxy(fieldRef, {
+                get: (fieldTarget, nestedProp) => {
+                    // Handle Symbol.toPrimitive for string conversion (used in template literals)
+                    if (nestedProp === Symbol.toPrimitive || nestedProp === 'toString' || nestedProp === 'valueOf') {
+                        return () => fieldTarget.__dbColumnName;
+                    }
+                    if (typeof nestedProp === 'symbol')
+                        return undefined;
+                    // If accessing FieldRef properties, return them
+                    if (nestedProp === '__fieldName' || nestedProp === '__dbColumnName' || nestedProp === '__tableAlias') {
+                        return fieldTarget[nestedProp];
+                    }
+                    // Otherwise, treat as nested navigation and create a new nested proxy
+                    // The nested table alias is the property name (e.g., 'product' for p.product)
+                    return createNestedFieldRefProxy(prop)[nestedProp];
+                },
+                has: (_fieldTarget, _nestedProp) => true,
+            });
+        },
+        has: (_target, prop) => {
+            // The outer proxy doesn't have FieldRef properties - only field names
+            if (prop === '__fieldName' || prop === '__dbColumnName' || prop === '__tableAlias') {
+                return false;
+            }
+            return true;
+        },
+    };
+    const proxy = new Proxy({}, handler);
+    nestedFieldRefProxyCache.set(tableAlias, proxy);
+    return proxy;
+}
 /**
  * Cached regex for numeric string detection
  * Used to convert PostgreSQL NUMERIC/BIGINT strings to numbers
@@ -38,6 +144,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 +154,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
      */
@@ -62,14 +182,10 @@ class QueryBuilder {
             return this._cachedMockRow;
         }
         const mock = {};
-        // Performance: Build column configs once and cache them
-        const columnEntries = Object.entries(this.schema.columns);
-        const columnConfigs = new Map();
-        for (const [colName, colBuilder] of columnEntries) {
-            columnConfigs.set(colName, colBuilder.build().name);
-        }
+        // Performance: Use pre-computed column name map if available
+        const columnNameMap = getColumnNameMapForSchema(this.schema);
         // Add columns as FieldRef objects - type-safe with property name and database column name
-        for (const [colName, dbColumnName] of columnConfigs) {
+        for (const [colName, dbColumnName] of columnNameMap) {
             Object.defineProperty(mock, colName, {
                 get: () => ({
                     __fieldName: colName,
@@ -80,17 +196,13 @@ class QueryBuilder {
                 configurable: true,
             });
         }
-        // Performance: Cache target schemas for relations to avoid repeated .build() calls
-        const relationSchemas = new Map();
-        for (const [relName, relConfig] of Object.entries(this.schema.relations)) {
-            if (relConfig.targetTableBuilder) {
-                relationSchemas.set(relName, relConfig.targetTableBuilder.build());
-            }
-        }
+        // Performance: Use pre-computed relation entries and cached schemas
+        const relationEntries = getRelationEntriesForSchema(this.schema);
         // Add relations (both collections and single references)
-        for (const [relName, relConfig] of Object.entries(this.schema.relations)) {
+        for (const [relName, relConfig] of relationEntries) {
+            // Performance: Use cached target schema
+            const targetSchema = getTargetSchemaForRelation(this.schema, relName, relConfig);
             if (relConfig.type === 'many') {
-                const targetSchema = relationSchemas.get(relName);
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', this.schema.name, targetSchema);
@@ -101,7 +213,6 @@ class QueryBuilder {
             }
             else {
                 // Single reference navigation (many-to-one, one-to-one)
-                const targetSchema = relationSchemas.get(relName);
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema);
@@ -118,6 +229,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 +278,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
@@ -217,14 +330,10 @@ class QueryBuilder {
      */
     createMockRowForTable(schema, alias) {
         const mock = {};
-        // Performance: Build column configs once and cache them
-        const columnEntries = Object.entries(schema.columns);
-        const columnConfigs = new Map();
-        for (const [colName, colBuilder] of columnEntries) {
-            columnConfigs.set(colName, colBuilder.build().name);
-        }
+        // Performance: Use pre-computed column name map if available
+        const columnNameMap = getColumnNameMapForSchema(schema);
         // Add columns as FieldRef objects with table alias
-        for (const [colName, dbColumnName] of columnConfigs) {
+        for (const [colName, dbColumnName] of columnNameMap) {
             Object.defineProperty(mock, colName, {
                 get: () => ({
                     __fieldName: colName,
@@ -235,18 +344,14 @@ class QueryBuilder {
                 configurable: true,
             });
         }
-        // Performance: Cache target schemas for relations
-        const relationSchemas = new Map();
-        for (const [relName, relConfig] of Object.entries(schema.relations)) {
-            if (relConfig.targetTableBuilder) {
-                relationSchemas.set(relName, relConfig.targetTableBuilder.build());
-            }
-        }
+        // Performance: Use pre-computed relation entries and cached schemas
+        const relationEntries = getRelationEntriesForSchema(schema);
         // Add navigation properties (single references and collections)
-        for (const [relName, relConfig] of Object.entries(schema.relations)) {
+        for (const [relName, relConfig] of relationEntries) {
+            // Performance: Use cached target schema
+            const targetSchema = getTargetSchemaForRelation(schema, relName, relConfig);
             if (relConfig.type === 'many') {
                 // Collection navigation
-                const targetSchema = relationSchemas.get(relName);
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', schema.name, targetSchema);
@@ -257,7 +362,6 @@ class QueryBuilder {
             }
             else {
                 // Single reference navigation
-                const targetSchema = relationSchemas.get(relName);
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema);
@@ -287,35 +391,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 +429,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 +441,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;
     }
     /**
@@ -384,7 +470,12 @@ class SelectQueryBuilder {
      *   .toList();
      */
     with(...ctes) {
-        this.ctes.push(...ctes);
+        // Add CTEs, avoiding duplicates by name
+        for (const cte of ctes) {
+            if (!this.ctes.some(existing => existing.name === cte.name)) {
+                this.ctes.push(cte);
+            }
+        }
         return this;
     }
     /**
@@ -404,36 +495,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 +550,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 +660,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
@@ -637,14 +702,10 @@ class SelectQueryBuilder {
      */
     createMockRowForTable(schema, alias) {
         const mock = {};
-        // Performance: Build column configs once and cache them
-        const columnEntries = Object.entries(schema.columns);
-        const columnConfigs = new Map();
-        for (const [colName, colBuilder] of columnEntries) {
-            columnConfigs.set(colName, colBuilder.build().name);
-        }
+        // Performance: Use pre-computed column name map if available
+        const columnNameMap = getColumnNameMapForSchema(schema);
         // Add columns as FieldRef objects with table alias
-        for (const [colName, dbColumnName] of columnConfigs) {
+        for (const [colName, dbColumnName] of columnNameMap) {
             Object.defineProperty(mock, colName, {
                 get: () => ({
                     __fieldName: colName,
@@ -655,18 +716,14 @@ class SelectQueryBuilder {
                 configurable: true,
             });
         }
-        // Performance: Cache target schemas for relations
-        const relationSchemas = new Map();
-        for (const [relName, relConfig] of Object.entries(schema.relations)) {
-            if (relConfig.targetTableBuilder) {
-                relationSchemas.set(relName, relConfig.targetTableBuilder.build());
-            }
-        }
+        // Performance: Use pre-computed relation entries and cached schemas
+        const relationEntries = getRelationEntriesForSchema(schema);
         // Add navigation properties (single references and collections)
-        for (const [relName, relConfig] of Object.entries(schema.relations)) {
+        for (const [relName, relConfig] of relationEntries) {
+            // Performance: Use cached target schema
+            const targetSchema = getTargetSchemaForRelation(schema, relName, relConfig);
             if (relConfig.type === 'many') {
                 // Collection navigation
-                const targetSchema = relationSchemas.get(relName);
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', schema.name, targetSchema);
@@ -677,7 +734,6 @@ class SelectQueryBuilder {
             }
             else {
                 // Single reference navigation
-                const targetSchema = relationSchemas.get(relName);
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema);
@@ -1265,9 +1321,10 @@ class SelectQueryBuilder {
      */
     createMockRow() {
         const mock = {};
+        // Performance: Use pre-computed column name map if available
+        const columnNameMap = getColumnNameMapForSchema(this.schema);
         // Add columns as FieldRef objects - type-safe with property name and database column name
-        for (const [colName, colBuilder] of Object.entries(this.schema.columns)) {
-            const dbColumnName = colBuilder.build().name;
+        for (const [colName, dbColumnName] of columnNameMap) {
             Object.defineProperty(mock, colName, {
                 get: () => ({
                     __fieldName: colName,
@@ -1284,13 +1341,12 @@ class SelectQueryBuilder {
             if (join.isSubquery || !join.schema) {
                 continue;
             }
-            for (const [colName, colBuilder] of Object.entries(join.schema.columns)) {
-                const dbColumnName = colBuilder.build().name;
-                // Create a unique property name by prefixing with table alias or using the column name directly
-                // For now, we'll create nested objects for each joined table
-                if (!mock[join.alias]) {
-                    mock[join.alias] = {};
-                }
+            // Performance: Use pre-computed column name map for joined schema
+            const joinColumnNameMap = getColumnNameMapForSchema(join.schema);
+            if (!mock[join.alias]) {
+                mock[join.alias] = {};
+            }
+            for (const [colName, dbColumnName] of joinColumnNameMap) {
                 Object.defineProperty(mock[join.alias], colName, {
                     get: () => ({
                         __fieldName: colName,
@@ -1302,13 +1358,23 @@ class SelectQueryBuilder {
                 });
             }
         }
+        // Performance: Use pre-computed relation entries
+        const relationEntries = getRelationEntriesForSchema(this.schema);
         // Add relations as CollectionQueryBuilder or ReferenceQueryBuilder
-        for (const [relName, relConfig] of Object.entries(this.schema.relations)) {
+        for (const [relName, relConfig] of relationEntries) {
+            // Try to get target schema from registry (preferred, has full relations) or cached schema
+            let targetSchema;
+            if (this.schemaRegistry) {
+                targetSchema = this.schemaRegistry.get(relConfig.targetTable);
+            }
+            if (!targetSchema) {
+                // Performance: Use cached target schema
+                targetSchema = getTargetSchemaForRelation(this.schema, relName, relConfig);
+            }
             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 +1386,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 +1399,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
      */
@@ -1344,9 +1470,66 @@ class SelectQueryBuilder {
         for (const [key, value] of Object.entries(selection)) {
             if (value && typeof value === 'object' && '__tableAlias' in value && '__dbColumnName' in value) {
                 // This is a FieldRef with a table alias - check if it's from a related table
-                const tableAlias = value.__tableAlias;
+                this.addJoinForFieldRef(value, joins);
+            }
+            else if (value instanceof conditions_1.SqlFragment) {
+                // SqlFragment may contain navigation property references - extract them
+                const fieldRefs = value.getFieldRefs();
+                for (const fieldRef of fieldRefs) {
+                    this.addJoinForFieldRef(fieldRef, joins);
+                }
+            }
+            else if (value && typeof value === 'object' && !Array.isArray(value)) {
+                // Recursively check nested objects
+                this.detectAndAddJoinsFromSelection(value, joins);
+            }
+        }
+    }
+    /**
+     * Add a JOIN for a FieldRef if it references a related table
+     */
+    addJoinForFieldRef(fieldRef, joins) {
+        if (!fieldRef || typeof fieldRef !== 'object' || !('__tableAlias' in fieldRef) || !('__dbColumnName' in fieldRef)) {
+            return;
+        }
+        const tableAlias = fieldRef.__tableAlias;
+        if (tableAlias && tableAlias !== this.schema.name && !joins.some(j => j.alias === tableAlias)) {
+            // This references a related table - find the relation and add a JOIN
+            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,
+                });
+            }
+        }
+    }
+    /**
+     * 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)) {
-                    // This references a related table - find the relation and add a JOIN
+                    // 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
@@ -1367,10 +1550,6 @@ class SelectQueryBuilder {
                     }
                 }
             }
-            else if (value && typeof value === 'object' && !Array.isArray(value)) {
-                // Recursively check nested objects
-                this.detectAndAddJoinsFromSelection(value, joins);
-            }
         }
     }
     /**
@@ -1387,6 +1566,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 +1592,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
@@ -1512,9 +1701,10 @@ class SelectQueryBuilder {
                                 // Select all columns from the target table and group them
                                 // We'll need to use JSON object building in SQL
                                 const fieldParts = [];
-                                for (const [colKey, col] of Object.entries(targetSchema.columns)) {
-                                    const config = col.build();
-                                    fieldParts.push(`'${colKey}', "${alias}"."${config.name}"`);
+                                // Performance: Use cached column name map
+                                const targetColMap = getColumnNameMapForSchema(targetSchema);
+                                for (const [colKey, dbColName] of targetColMap) {
+                                    fieldParts.push(`'${colKey}', "${alias}"."${dbColName}"`);
                                 }
                                 selectParts.push(`json_build_object(${fieldParts.join(', ')}) as "${key}"`);
                             }
@@ -1544,11 +1734,8 @@ class SelectQueryBuilder {
                                             const relConfig = this.schema.relations[alias];
                                             if (relConfig && relConfig.type === 'one') {
                                                 // This is a reference navigation - select all fields from the target table
-                                                // Find the target table schema
-                                                let targetSchema;
-                                                if (relConfig.targetTableBuilder) {
-                                                    targetSchema = relConfig.targetTableBuilder.build();
-                                                }
+                                                // Performance: Use cached target schema
+                                                const targetSchema = getTargetSchemaForRelation(this.schema, alias, relConfig);
                                                 if (targetSchema) {
                                                     // Add JOIN if not already added
                                                     if (!joins.find(j => j.alias === alias)) {
@@ -1567,9 +1754,10 @@ class SelectQueryBuilder {
                                                     }
                                                     // Select all columns from the target table and group them into a JSON object
                                                     const fieldParts = [];
-                                                    for (const [colKey, col] of Object.entries(targetSchema.columns)) {
-                                                        const config = col.build();
-                                                        fieldParts.push(`'${colKey}', "${alias}"."${config.name}"`);
+                                                    // Performance: Use cached column name map
+                                                    const targetColMap = getColumnNameMapForSchema(targetSchema);
+                                                    for (const [colKey, dbColName] of targetColMap) {
+                                                        fieldParts.push(`'${colKey}', "${alias}"."${dbColName}"`);
                                                     }
                                                     selectParts.push(`json_build_object(${fieldParts.join(', ')}) as "${key}"`);
                                                     continue;
@@ -1601,8 +1789,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 +1922,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 +2307,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 +2349,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
@@ -2170,9 +2402,9 @@ class ReferenceQueryBuilder {
     createMockTargetRow() {
         if (this.targetTableSchema) {
             const mock = {};
-            // Add columns
-            for (const [colName, colBuilder] of Object.entries(this.targetTableSchema.columns)) {
-                const dbColumnName = colBuilder.build().name;
+            // Add columns - use pre-computed column name map if available
+            const columnNameMap = getColumnNameMapForSchema(this.targetTableSchema);
+            for (const [colName, dbColumnName] of columnNameMap) {
                 Object.defineProperty(mock, colName, {
                     get: () => ({
                         __fieldName: colName,
@@ -2186,14 +2418,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 +2443,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();
@@ -2221,15 +2457,8 @@ class ReferenceQueryBuilder {
             return mock;
         }
         else {
-            // Fallback: generic proxy
-            const handler = {
-                get: (target, prop) => ({
-                    __fieldName: prop,
-                    __dbColumnName: prop,
-                    __tableAlias: this.relationName,
-                }),
-            };
-            return new Proxy({}, handler);
+            // Fallback: use the shared nested proxy that supports deep property access
+            return createNestedFieldRefProxy(this.relationName);
         }
     }
 }
@@ -2248,9 +2477,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 +2513,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;
     }
     /**
@@ -2295,14 +2538,10 @@ class CollectionQueryBuilder {
         if (this.targetTableSchema) {
             // If we have schema information, create a properly typed mock
             const mock = {};
-            // Performance: Build column configs once and cache them
-            const columnEntries = Object.entries(this.targetTableSchema.columns);
-            const columnConfigs = new Map();
-            for (const [colName, colBuilder] of columnEntries) {
-                columnConfigs.set(colName, colBuilder.build().name);
-            }
+            // Performance: Use pre-computed column name map if available
+            const columnNameMap = getColumnNameMapForSchema(this.targetTableSchema);
             // Add columns
-            for (const [colName, dbColumnName] of columnConfigs) {
+            for (const [colName, dbColumnName] of columnNameMap) {
                 Object.defineProperty(mock, colName, {
                     get: () => ({
                         __fieldName: colName,
@@ -2351,14 +2590,8 @@ class CollectionQueryBuilder {
             return mock;
         }
         else {
-            // Fallback: generic proxy (don't cache as it's dynamic)
-            const handler = {
-                get: (target, prop) => ({
-                    __fieldName: prop,
-                    __dbColumnName: prop,
-                }),
-            };
-            return new Proxy({}, handler);
+            // Fallback: use the shared nested proxy that supports deep property access
+            return createNestedFieldRefProxy(this.targetTable);
         }
     }
     /**
@@ -2378,35 +2611,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 +2729,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 +2799,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) {
+                // Performance: Use cached column name map
+                const colNameMap = getColumnNameMapForSchema(this.targetTableSchema);
+                for (const [colName, dbColumnName] of colNameMap) {
+                    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;
@@ -2611,13 +2840,11 @@ class CollectionQueryBuilder {
         // Step 3: Build ORDER BY clause SQL (without ORDER BY keyword)
         let orderByClause;
         if (this.orderByFields.length > 0) {
+            // Performance: Pre-compute column name map for ORDER BY lookups
+            const colNameMap = this.targetTableSchema ? getColumnNameMapForSchema(this.targetTableSchema) : null;
             const orderParts = this.orderByFields.map(({ field, direction }) => {
-                // Look up the database column name from the schema if available
-                let dbColumnName = field;
-                if (this.targetTableSchema && this.targetTableSchema.columns[field]) {
-                    const colBuilder = this.targetTableSchema.columns[field];
-                    dbColumnName = colBuilder.build().name;
-                }
+                // Look up the database column name from the cached map if available
+                const dbColumnName = colNameMap?.get(field) ?? field;
                 return `"${dbColumnName}" ${direction}`;
             });
             orderByClause = orderParts.join(', ');
@@ -2687,10 +2914,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,
         };
     }
 }