linkgress-orm 0.4.75 → 0.4.78

package/dist/query/strategies/lateral-collection-strategy.js

@@ -1,7 +1,61 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.LateralCollectionStrategy = void 0;
+exports.LateralCollectionStrategy = exports.lateralShapeKey = void 0;
+const query_utils_1 = require("../query-utils");
 const join_utils_1 = require("../join-utils");
+const lateral_sql_cache_1 = require("../lateral-sql-cache");
+/** Key-part separator: a control character no alias, column name or SQL text contains. */
+const KEY_SEP = String.fromCharCode(1);
+/** A column list as one key part; the one-column case (nearly every FK) needs no join allocation. */
+const listKey = (list) => (list === undefined ? '' : list.length === 1 ? list[0] : list.join(','));
+/** Appends what `buildNavigationJoinsWithAlias` reads from each join, including the alias-map resolution of its source. */
+const appendNavigationJoinsKey = (key, joins, aliasMap) => {
+    if (!joins) {
+        return key + '-' + KEY_SEP;
+    }
+    key += joins.length + KEY_SEP;
+    for (const join of joins) {
+        key += join.alias + KEY_SEP + join.targetTable + KEY_SEP + (join.targetSchema ?? '') + KEY_SEP
+            + listKey(join.foreignKeys) + KEY_SEP + listKey(join.matches) + KEY_SEP + (join.isMandatory ? 'I' : 'L') + KEY_SEP
+            + join.sourceAlias + KEY_SEP + (aliasMap?.get(join.sourceAlias) ?? '') + KEY_SEP;
+    }
+    return key;
+};
+/** Appends the projection: aliases, expressions, nesting, and nested laterals by memo id (or by text when not memoised). */
+const appendFieldsKey = (key, fields) => {
+    key += '[' + fields.length + KEY_SEP;
+    for (const field of fields) {
+        key += field.alias + KEY_SEP + (field.expression ?? '') + KEY_SEP + (field.isColumn === true ? 'c' : 'e') + KEY_SEP;
+        if (field.nestedCteJoin) {
+            key += field.nestedCteJoin.cteName + KEY_SEP + (field.nestedCteJoin.memoId ? '#' + field.nestedCteJoin.memoId : field.nestedCteJoin.joinClause) + KEY_SEP;
+        }
+        key = field.nested ? appendFieldsKey(key, field.nested) : key + '-' + KEY_SEP;
+    }
+    return key + ']' + KEY_SEP;
+};
+/**
+ * The LateralSqlCache key of an aggregation: every input `LateralCollectionStrategy.render` and
+ * its helpers read, in order — the alias inputs (counter, relation, tables), the correlation
+ * columns, the clause TEXT (which already carries the `$n` placeholder numbering), the scalar
+ * flags and limits, both navigation-join lists with their alias-map resolution, and the
+ * projection. Parameter VALUES never enter the strategy and never enter the key. Built by plain
+ * concatenation (a rope V8 flattens once, on the lookup) — cheaper than an array join.
+ */
+const lateralShapeKey = (config, context) => {
+    const aliasMap = context.lateralTableAliasMap;
+    let key = config.counter + KEY_SEP + config.relationName + KEY_SEP + config.targetTable + KEY_SEP + config.foreignKey + KEY_SEP
+        + listKey(config.foreignKeys) + KEY_SEP + listKey(config.matches) + KEY_SEP + (config.foreignKeyTableAlias ?? '') + KEY_SEP
+        + config.sourceTable + KEY_SEP + (aliasMap?.get(config.sourceTable) ?? '') + KEY_SEP
+        + (config.whereClause ?? '') + KEY_SEP + (config.orderByClause ?? '') + KEY_SEP + (config.orderByClauseAlias ?? '') + KEY_SEP
+        + (config.limitValue ?? '') + KEY_SEP + (config.offsetValue ?? '') + KEY_SEP
+        + (config.isDistinct === true ? 'D' : '') + (config.isSingleResult === true ? 'S' : '') + (config.useJsonArrayAggregation === true ? 'J' : '') + KEY_SEP
+        + config.aggregationType + KEY_SEP + (config.aggregateField ?? '') + KEY_SEP + (config.aggregateExpression ?? '') + KEY_SEP
+        + (config.arrayField ?? '') + KEY_SEP + config.defaultValue + KEY_SEP;
+    key = appendNavigationJoinsKey(key, config.navigationJoins, aliasMap);
+    key = appendNavigationJoinsKey(key, config.selectorNavigationJoins, aliasMap);
+    return appendFieldsKey(key, config.selectedFields);
+};
+exports.lateralShapeKey = lateralShapeKey;
 /**
  * LATERAL JOIN-based collection strategy
  *
@@ -70,6 +124,38 @@ class LateralCollectionStrategy {
         return `"${fkTableAlias}"."${foreignKey}" = "${sourceAlias}"."id"`;
     }
     buildAggregation(config, context) {
+        // Memoised per shape (see LateralSqlCache): the rendering below reads nothing but the
+        // config and the enclosing alias map, and mutates neither, so a hit is a pure lookup.
+        if (!lateral_sql_cache_1.LateralSqlCache.isEnabled()) {
+            return this.render(config, context);
+        }
+        const key = (0, exports.lateralShapeKey)(config, context);
+        const hit = lateral_sql_cache_1.LateralSqlCache.get(key);
+        if (hit) {
+            return {
+                sql: hit.sql,
+                params: context.allParams,
+                tableName: hit.tableName,
+                joinClause: hit.joinClause,
+                selectExpression: hit.selectExpression,
+                isCTE: false,
+                memoId: hit.id,
+            };
+        }
+        const rendered = this.render(config, context);
+        const entry = lateral_sql_cache_1.LateralSqlCache.store(key, {
+            sql: rendered.sql,
+            joinClause: rendered.joinClause,
+            selectExpression: rendered.selectExpression,
+            tableName: rendered.tableName,
+        });
+        if (entry.id > 0) {
+            rendered.memoId = entry.id;
+        }
+        return rendered;
+    }
+    /** The uncached rendering behind {@link buildAggregation}. */
+    render(config, context) {
         const lateralAlias = `lateral_${config.counter}`;
         // Optimization: For simple aggregations without LIMIT/OFFSET/ORDER BY,
         // use a correlated subquery in SELECT instead of LATERAL JOIN.
@@ -164,7 +250,10 @@ class LateralCollectionStrategy {
         // Helper to rewrite expressions that reference the collection's table to use inner alias
         const rewriteTableReference = (expression) => {
             // Replace the special marker alias `"__collection_tableName__".` with `"innerTableAlias".`
-            const markerPattern = new RegExp(`"__collection_${targetTable}__"\\.`, 'g');
+            if (!expression.includes('"__collection_')) {
+                return expression; // nothing to rewrite — skip the regex pass entirely
+            }
+            const markerPattern = (0, query_utils_1.collectionMarkerPattern)(targetTable, true);
             return expression.replace(markerPattern, `"${innerTableAlias}".`);
         };
         // Build navigation JOINs for multi-level navigation (selector joins only)
@@ -198,24 +287,24 @@ class LateralCollectionStrategy {
             // Pattern: (SELECT array_agg(x) FROM (SELECT DISTINCT x FROM ...) sub)
             // This is more efficient than array_agg(DISTINCT x) which forces a sort
             if (isDistinct) {
-                subquerySQL = `(SELECT COALESCE(${arrayAggFn}("${arrayField}"), ${defaultValue})
-FROM (SELECT DISTINCT ${fieldExpression} as "${arrayField}"
-FROM "${targetTable}" "${innerTableAlias}"
-${navJoinsSQL}
+                subquerySQL = `(SELECT COALESCE(${arrayAggFn}("${arrayField}"), ${defaultValue})
+FROM (SELECT DISTINCT ${fieldExpression} as "${arrayField}"
+FROM "${targetTable}" "${innerTableAlias}"
+${navJoinsSQL}
 WHERE ${whereSQL}) "sq")`;
             }
             else {
-                subquerySQL = `(SELECT COALESCE(${arrayAggFn}(${fieldExpression}), ${defaultValue})
-FROM "${targetTable}" "${innerTableAlias}"
-${navJoinsSQL}
+                subquerySQL = `(SELECT COALESCE(${arrayAggFn}(${fieldExpression}), ${defaultValue})
+FROM "${targetTable}" "${innerTableAlias}"
+${navJoinsSQL}
 WHERE ${whereSQL})`;
             }
         }
         else if (aggregationType === 'exists') {
             // EXISTS as correlated subquery: (SELECT EXISTS(SELECT 1 FROM ... WHERE ...))
-            subquerySQL = `(SELECT EXISTS(SELECT 1
-FROM "${targetTable}" "${innerTableAlias}"
-${navJoinsSQL}
+            subquerySQL = `(SELECT EXISTS(SELECT 1
+FROM "${targetTable}" "${innerTableAlias}"
+${navJoinsSQL}
 WHERE ${whereSQL}))`;
         }
         else {
@@ -243,9 +332,9 @@ WHERE ${whereSQL}))`;
                     throw new Error(`Unknown aggregation type: ${aggregationType}`);
             }
             // Build correlated subquery for scalar aggregation
-            subquerySQL = `(SELECT COALESCE(${aggregateSql}, ${defaultValue})
-FROM "${targetTable}" "${innerTableAlias}"
-${navJoinsSQL}
+            subquerySQL = `(SELECT COALESCE(${aggregateSql}, ${defaultValue})
+FROM "${targetTable}" "${innerTableAlias}"
+${navJoinsSQL}
 WHERE ${whereSQL})`;
         }
         // For correlated subquery, the select expression IS the subquery
@@ -260,20 +349,60 @@ WHERE ${whereSQL})`;
         };
     }
     /**
-     * Helper to collect nested CTE/LATERAL joins from selected fields
-     * These are joins to CTEs or LATERAL subqueries created for nested collections
+     * Rewrites the collection marker alias (`"__collection_<table>__".`) to the lateral's inner
+     * alias. The regex pass runs only when the marker is present at all.
+     */
+    rewriteMarker(expression, targetTable, innerTableAlias) {
+        if (!expression.includes('"__collection_')) {
+            return expression;
+        }
+        return expression.replace((0, query_utils_1.collectionMarkerPattern)(targetTable, true), '"' + innerTableAlias + '".');
+    }
+    /**
+     * One select-list entry for a leaf field. A bare quoted column (`"col"`, no dot, no inner
+     * quote) is qualified with the inner alias; anything else has the marker rewritten and is
+     * aliased unless it already renders as exactly `"<alias>"`.
      */
-    collectNestedCteJoins(fields) {
-        const joins = [];
+    renderLeafSelect(expression, fullAlias, targetTable, innerTableAlias) {
+        const length = expression.length;
+        const isSimpleColumn = length > 2
+            && expression.charCodeAt(0) === 34
+            && expression.charCodeAt(length - 1) === 34
+            && expression.indexOf('"', 1) === length - 1
+            && expression.indexOf('.') === -1;
+        if (isSimpleColumn) {
+            return '"' + innerTableAlias + '".' + expression + ' as "' + fullAlias + '"';
+        }
+        const rewritten = this.rewriteMarker(expression, targetTable, innerTableAlias);
+        return rewritten === '"' + fullAlias + '"' ? rewritten : rewritten + ' as "' + fullAlias + '"';
+    }
+    /**
+     * Renders the selected fields in ONE recursive pass: returns the `json_build_object(...)` text
+     * of this level and appends the flattened inner select list and the nested lateral joins to
+     * `out` (same order as the three separate walks this replaces — depth first, own join before
+     * the nested ones). No intermediate arrays: the select list of a wide collection projection was
+     * three allocations per field and three joins per statement.
+     */
+    renderFields(fields, prefix, targetTable, innerTableAlias, out) {
+        let json = '';
         for (const field of fields) {
+            const alias = field.alias;
+            const fullAlias = prefix ? prefix + '__' + alias : alias;
             if (field.nestedCteJoin) {
-                joins.push(field.nestedCteJoin.joinClause);
+                out.joins += (out.joins ? '\n  ' : '') + field.nestedCteJoin.joinClause;
             }
             if (field.nested) {
-                joins.push(...this.collectNestedCteJoins(field.nested));
+                const nestedJson = this.renderFields(field.nested, fullAlias, targetTable, innerTableAlias, out);
+                json += (json ? ', ' : '') + "'" + alias + "', " + nestedJson;
+            }
+            else {
+                json += (json ? ', ' : '') + "'" + alias + "', \"" + fullAlias + '"';
+                if (field.expression) {
+                    out.select += (out.select ? ', ' : '') + this.renderLeafSelect(field.expression, fullAlias, targetTable, innerTableAlias);
+                }
             }
         }
-        return joins;
+        return 'json_build_object(' + json + ')';
     }
     /**
      * Build navigation JOINs SQL for multi-level navigation in collection queries
@@ -309,14 +438,15 @@ WHERE ${whereSQL})`;
      * @param targetTable - Optional: the original target table name (e.g., "posts") to map to innerTableAlias
      * @param context - Optional: QueryContext containing lateralTableAliasMap for nested lateral references
      */
-    buildNavigationJoinsWithAlias(navigationJoins, innerTableAlias, targetTable, context) {
+    buildNavigationJoinsWithAlias(navigationJoins, innerTableAlias, targetTable, context, relationName) {
         if (!navigationJoins || navigationJoins.length === 0) {
             return '';
         }
-        // Extract the relation name from innerTableAlias (e.g., "lateral_0_posts" -> "posts")
-        // This is needed to know which source aliases should be remapped
-        const parts = innerTableAlias.split('_');
-        const relationName = parts.length >= 3 ? parts.slice(2).join('_') : innerTableAlias;
+        if (relationName === undefined) {
+            // `lateral_<n>_<relation>` — the relation name is everything after the second `_`
+            const parts = innerTableAlias.split('_');
+            relationName = parts.length >= 3 ? parts.slice(2).join('_') : innerTableAlias;
+        }
         // Get the lateral table alias map from context (for nested lateral references)
         // This is used when a nested collection's selector navigation references a parent collection's table
         const lateralAliasMap = context?.lateralTableAliasMap;
@@ -359,98 +489,24 @@ WHERE ${whereSQL})`;
      */
     buildJsonbAggregation(config, lateralAlias, context) {
         const { selectedFields, targetTable, foreignKey, sourceTable, whereClause, orderByClause, limitValue, offsetValue, isDistinct, navigationJoins, relationName } = config;
-        // Use a unique table alias to avoid conflicts with outer query tables
-        // This is important when the collection targets the same table as the outer query
-        // (e.g., post.user.posts where both outer and inner are "posts" table)
         const innerTableAlias = `${lateralAlias}_${relationName}`;
-        // Helper to collect all leaf fields from a potentially nested structure
-        const collectLeafFields = (fields, prefix = '') => {
-            const result = [];
-            for (const field of fields) {
-                const fullAlias = prefix ? `${prefix}__${field.alias}` : field.alias;
-                if (field.nested) {
-                    result.push(...collectLeafFields(field.nested, fullAlias));
-                }
-                else if (field.expression) {
-                    result.push({ alias: fullAlias, expression: field.expression });
-                }
-            }
-            return result;
-        };
-        // Helper to build json_build_object expression (handles nested structures)
-        const buildJsonbObject = (fields, prefix = '') => {
-            const parts = [];
-            for (const field of fields) {
-                if (field.nested) {
-                    const nestedJsonb = buildJsonbObject(field.nested, prefix ? `${prefix}__${field.alias}` : field.alias);
-                    parts.push(`'${field.alias}', ${nestedJsonb}`);
-                }
-                else {
-                    const fullAlias = prefix ? `${prefix}__${field.alias}` : field.alias;
-                    parts.push(`'${field.alias}', "${fullAlias}"`);
-                }
-            }
-            return `json_build_object(${parts.join(', ')})`;
-        };
-        // Collect all leaf fields for the SELECT clause
-        const leafFields = collectLeafFields(selectedFields);
-        // When there are navigation joins, we need to qualify unqualified field expressions
-        // with the inner table alias to avoid ambiguous column references
-        const hasNavigationJoins = navigationJoins && navigationJoins.length > 0;
-        // Helper to rewrite expressions that reference the collection's table to use inner alias
-        const rewriteTableReference = (expression) => {
-            // Replace the special marker alias `"__collection_tableName__".` with `"innerTableAlias".`
-            // This marker is set in CollectionQueryBuilder.createMockItem() to distinguish
-            // collection references from outer table references when both target the same table
-            const markerPattern = new RegExp(`"__collection_${targetTable}__"\\.`, 'g');
-            return expression.replace(markerPattern, `"${innerTableAlias}".`);
-        };
-        // Build the subquery SELECT fields (no foreign key needed since we correlate with parent)
-        const allSelectFields = leafFields.map(f => {
-            // If expression is just a quoted column name (e.g., `"id"`), qualify it with inner table alias
-            // But if it's already qualified (e.g., `"user"."username"`), rewrite if it references target table
-            const isSimpleColumn = /^"[^".]+"$/.test(f.expression);
-            if (isSimpleColumn) {
-                // Unqualified column - qualify with inner table alias
-                const columnName = f.expression.slice(1, -1); // Remove quotes
-                return `"${innerTableAlias}"."${columnName}" as "${f.alias}"`;
-            }
-            // Already qualified - rewrite target table references
-            const rewritten = rewriteTableReference(f.expression);
-            if (rewritten !== `"${f.alias}"`) {
-                return `${rewritten} as "${f.alias}"`;
-            }
-            return rewritten;
-        });
-        // Build the JSONB fields for json_build_object
-        const jsonbObjectExpr = buildJsonbObject(selectedFields);
-        // Build navigation JOINs for multi-level navigation
-        // Pass innerTableAlias so navigation joins can reference it properly
-        const navJoinsSQL = this.buildNavigationJoinsWithAlias(navigationJoins, innerTableAlias, targetTable, context);
-        // Collect nested CTE/LATERAL joins (for collections within collections)
-        const nestedCteJoins = this.collectNestedCteJoins(selectedFields);
-        const nestedCteJoinsSQL = nestedCteJoins.length > 0 ? nestedCteJoins.join('\n  ') : '';
-        // For nested collections, the source table may be aliased in a parent LATERAL
-        // Check the lateralTableAliasMap to get the correct alias
+        // Inner select list + json_build_object + nested lateral joins in one pass
+        const rendered = { select: '', joins: '' };
+        const jsonbObjectExpr = this.renderFields(selectedFields, '', targetTable, innerTableAlias, rendered);
+        const navJoinsSQL = this.buildNavigationJoinsWithAlias(navigationJoins, innerTableAlias, targetTable, context, relationName);
+        // Check if the source table has been aliased by a parent LATERAL (for nested collections)
         const effectiveSourceTable = context.lateralTableAliasMap?.get(sourceTable) || sourceTable;
-        // Build WHERE clause - LATERAL correlates with parent via foreign key
-        // The correlation is: innerAlias.foreignKey = source.id (plus any literal
-        // predicates carried by `config.foreignKeys`/`matches`).
-        // For selectMany, the FK is on the intermediate table (joined via navJoins)
+        // Build WHERE clause with correlation to parent
+        // For selectMany, the FK is on the intermediate table (joined via navJoins), not the target table
         const fkTableAlias = config.foreignKeyTableAlias || innerTableAlias;
         let whereSQL = `WHERE ${this.buildParentCorrelation(config, fkTableAlias, effectiveSourceTable, foreignKey)}`;
         if (whereClause) {
-            // Rewrite the user's WHERE clause to use inner alias for the collection's table
-            const rewrittenWhereClause = rewriteTableReference(whereClause);
-            whereSQL += ` AND ${rewrittenWhereClause}`;
+            whereSQL += ` AND ${this.rewriteMarker(whereClause, targetTable, innerTableAlias)}`;
         }
-        // Build ORDER BY clause - also rewrite table references
         let orderBySQL = '';
         if (orderByClause) {
-            const rewrittenOrderBy = rewriteTableReference(orderByClause);
-            orderBySQL = `ORDER BY ${rewrittenOrderBy}`;
+            orderBySQL = `ORDER BY ${this.rewriteMarker(orderByClause, targetTable, innerTableAlias)}`;
         }
-        // Build LIMIT/OFFSET
         let limitOffsetClause = '';
         if (limitValue !== undefined) {
             limitOffsetClause = `LIMIT ${limitValue}`;
@@ -458,25 +514,22 @@ WHERE ${whereSQL})`;
         if (offsetValue !== undefined) {
             limitOffsetClause += ` OFFSET ${offsetValue}`;
         }
-        // Build DISTINCT clause
         const distinctClause = isDistinct ? 'DISTINCT ' : '';
-        // Note: We don't add ORDER BY inside json_agg because:
-        // 1. The inner subquery already applies ORDER BY before LIMIT/OFFSET
-        // 2. Column aliases in the subquery may differ from original column names
-        // The order is preserved from the inner query's ORDER BY
-        const lateralSQL = `
-SELECT json_agg(
-  ${jsonbObjectExpr}
-) as data
-FROM (
-  SELECT ${distinctClause}${allSelectFields.join(', ')}
-  FROM "${targetTable}" "${innerTableAlias}"
-  ${navJoinsSQL}
-  ${nestedCteJoinsSQL}
-  ${whereSQL}
-  ${orderBySQL}
-  ${limitOffsetClause}
-) sub
+        // Build LATERAL subquery
+        // Structure: SELECT json_agg(json_build_object(...)) FROM (SELECT ... LIMIT/OFFSET) sub
+        const lateralSQL = `
+SELECT json_agg(
+  ${jsonbObjectExpr}
+) as data
+FROM (
+  SELECT ${distinctClause}${rendered.select}
+  FROM "${targetTable}" "${innerTableAlias}"
+  ${navJoinsSQL}
+  ${rendered.joins}
+  ${whereSQL}
+  ${orderBySQL}
+  ${limitOffsetClause}
+) sub
     `.trim();
         return lateralSQL;
     }
@@ -486,96 +539,34 @@ FROM (
      */
     buildSingleJsonAggregation(config, lateralAlias, context) {
         const { selectedFields, targetTable, foreignKey, sourceTable, whereClause, orderByClause, isDistinct, navigationJoins, relationName } = config;
-        // Use a unique table alias to avoid conflicts with outer query tables
         const innerTableAlias = `${lateralAlias}_${relationName}`;
-        // Helper to collect all leaf fields from a potentially nested structure
-        const collectLeafFields = (fields, prefix = '') => {
-            const result = [];
-            for (const field of fields) {
-                const fullAlias = prefix ? `${prefix}__${field.alias}` : field.alias;
-                if (field.nested) {
-                    result.push(...collectLeafFields(field.nested, fullAlias));
-                }
-                else if (field.expression) {
-                    result.push({ alias: fullAlias, expression: field.expression });
-                }
-            }
-            return result;
-        };
-        // Helper to build json_build_object expression (handles nested structures)
-        const buildJsonbObject = (fields, prefix = '') => {
-            const parts = [];
-            for (const field of fields) {
-                if (field.nested) {
-                    const nestedJsonb = buildJsonbObject(field.nested, prefix ? `${prefix}__${field.alias}` : field.alias);
-                    parts.push(`'${field.alias}', ${nestedJsonb}`);
-                }
-                else {
-                    const fullAlias = prefix ? `${prefix}__${field.alias}` : field.alias;
-                    parts.push(`'${field.alias}', "${fullAlias}"`);
-                }
-            }
-            return `json_build_object(${parts.join(', ')})`;
-        };
-        // Collect all leaf fields for the SELECT clause
-        const leafFields = collectLeafFields(selectedFields);
-        // Helper to rewrite expressions that reference the collection's table to use inner alias
-        const rewriteTableReference = (expression) => {
-            // Replace the special marker alias `"__collection_tableName__".` with `"innerTableAlias".`
-            const markerPattern = new RegExp(`"__collection_${targetTable}__"\\.`, 'g');
-            return expression.replace(markerPattern, `"${innerTableAlias}".`);
-        };
-        // Build the subquery SELECT fields using inner table alias
-        const allSelectFields = leafFields.map(f => {
-            const isSimpleColumn = /^"[^".]+"$/.test(f.expression);
-            if (isSimpleColumn) {
-                const columnName = f.expression.slice(1, -1);
-                return `"${innerTableAlias}"."${columnName}" as "${f.alias}"`;
-            }
-            const rewritten = rewriteTableReference(f.expression);
-            if (rewritten !== `"${f.alias}"`) {
-                return `${rewritten} as "${f.alias}"`;
-            }
-            return rewritten;
-        });
-        // Build the JSONB fields for json_build_object
-        const jsonbObjectExpr = buildJsonbObject(selectedFields);
-        // Build navigation JOINs for multi-level navigation
-        const navJoinsSQL = this.buildNavigationJoinsWithAlias(navigationJoins, innerTableAlias, targetTable, context);
-        // Collect nested CTE/LATERAL joins (for collections within collections)
-        const nestedCteJoins = this.collectNestedCteJoins(selectedFields);
-        const nestedCteJoinsSQL = nestedCteJoins.length > 0 ? nestedCteJoins.join('\n  ') : '';
-        // For nested collections, the source table may be aliased in a parent LATERAL
+        const rendered = { select: '', joins: '' };
+        const jsonbObjectExpr = this.renderFields(selectedFields, '', targetTable, innerTableAlias, rendered);
+        const navJoinsSQL = this.buildNavigationJoinsWithAlias(navigationJoins, innerTableAlias, targetTable, context, relationName);
         const effectiveSourceTable = context.lateralTableAliasMap?.get(sourceTable) || sourceTable;
-        // Build WHERE clause - LATERAL correlates with parent via foreign key
-        // For selectMany, the FK is on the intermediate table (joined via navJoins)
         const fkTableAlias2 = config.foreignKeyTableAlias || innerTableAlias;
         let whereSQL = `WHERE ${this.buildParentCorrelation(config, fkTableAlias2, effectiveSourceTable, foreignKey)}`;
         if (whereClause) {
-            const rewrittenWhereClause = rewriteTableReference(whereClause);
-            whereSQL += ` AND ${rewrittenWhereClause}`;
+            whereSQL += ` AND ${this.rewriteMarker(whereClause, targetTable, innerTableAlias)}`;
         }
-        // Build ORDER BY clause
         let orderBySQL = '';
         if (orderByClause) {
-            const rewrittenOrderBy = rewriteTableReference(orderByClause);
-            orderBySQL = `ORDER BY ${rewrittenOrderBy}`;
+            orderBySQL = `ORDER BY ${this.rewriteMarker(orderByClause, targetTable, innerTableAlias)}`;
         }
-        // Build DISTINCT clause
         const distinctClause = isDistinct ? 'DISTINCT ' : '';
-        // For single result, use row_to_json on the first row
-        // LIMIT 1 is applied inside the subquery
-        const lateralSQL = `
-SELECT ${jsonbObjectExpr} as data
-FROM (
-  SELECT ${distinctClause}${allSelectFields.join(', ')}
-  FROM "${targetTable}" "${innerTableAlias}"
-  ${navJoinsSQL}
-  ${nestedCteJoinsSQL}
-  ${whereSQL}
-  ${orderBySQL}
-  LIMIT 1
-) sub
+        // Structure: SELECT json_build_object(...) FROM (SELECT ... LIMIT 1) sub
+        // Returns null if no rows (LEFT JOIN LATERAL handles this)
+        const lateralSQL = `
+SELECT ${jsonbObjectExpr} as data
+FROM (
+  SELECT ${distinctClause}${rendered.select}
+  FROM "${targetTable}" "${innerTableAlias}"
+  ${navJoinsSQL}
+  ${rendered.joins}
+  ${whereSQL}
+  ${orderBySQL}
+  LIMIT 1
+) sub
     `.trim();
         return lateralSQL;
     }
@@ -592,7 +583,10 @@ FROM (
         // Helper to rewrite expressions that reference the collection's table to use inner alias
         const rewriteTableReference = (expression) => {
             // Replace the special marker alias `"__collection_tableName__".` with `"innerTableAlias".`
-            const markerPattern = new RegExp(`"__collection_${targetTable}__"\\.`, 'g');
+            if (!expression.includes('"__collection_')) {
+                return expression; // nothing to rewrite — skip the regex pass entirely
+            }
+            const markerPattern = (0, query_utils_1.collectionMarkerPattern)(targetTable, true);
             return expression.replace(markerPattern, `"${innerTableAlias}".`);
         };
         // Get the actual field expression from selectedFields (if available)
@@ -634,18 +628,18 @@ FROM (
         // Build DISTINCT clause
         const distinctClause = isDistinct ? 'DISTINCT ' : '';
         // Note: We don't add ORDER BY inside array_agg because the inner subquery already sorts
-        const lateralSQL = `
-SELECT ${config.useJsonArrayAggregation ? 'json_agg' : 'array_agg'}(
-  "${arrayField}"
-) as data
-FROM (
-  SELECT ${distinctClause}${fieldExpression} as "${arrayField}"
-  FROM "${targetTable}" "${innerTableAlias}"
-  ${navJoinsSQL}
-  ${whereSQL}
-  ${orderBySQL}
-  ${limitOffsetClause}
-) sub
+        const lateralSQL = `
+SELECT ${config.useJsonArrayAggregation ? 'json_agg' : 'array_agg'}(
+  "${arrayField}"
+) as data
+FROM (
+  SELECT ${distinctClause}${fieldExpression} as "${arrayField}"
+  FROM "${targetTable}" "${innerTableAlias}"
+  ${navJoinsSQL}
+  ${whereSQL}
+  ${orderBySQL}
+  ${limitOffsetClause}
+) sub
     `.trim();
         return lateralSQL;
     }
@@ -659,7 +653,10 @@ FROM (
         // Helper to rewrite expressions that reference the collection's table to use inner alias
         const rewriteTableReference = (expression) => {
             // Replace the special marker alias `"__collection_tableName__".` with `"innerTableAlias".`
-            const markerPattern = new RegExp(`"__collection_${targetTable}__"\\.`, 'g');
+            if (!expression.includes('"__collection_')) {
+                return expression; // nothing to rewrite — skip the regex pass entirely
+            }
+            const markerPattern = (0, query_utils_1.collectionMarkerPattern)(targetTable, true);
             return expression.replace(markerPattern, `"${innerTableAlias}".`);
         };
         // For nested collections, the source table may be aliased in a parent LATERAL
@@ -694,20 +691,20 @@ FROM (
                 break;
             case 'exists': {
                 // EXISTS as LATERAL: SELECT EXISTS(SELECT 1 FROM ... WHERE ...)
-                const lateralSQL = `
-SELECT EXISTS(SELECT 1
-FROM "${targetTable}" "${innerTableAlias}"
-${whereSQL}) as data
+                const lateralSQL = `
+SELECT EXISTS(SELECT 1
+FROM "${targetTable}" "${innerTableAlias}"
+${whereSQL}) as data
         `.trim();
                 return lateralSQL;
             }
             default:
                 throw new Error(`Unknown aggregation type: ${aggregationType}`);
         }
-        const lateralSQL = `
-SELECT ${aggregateExpression} as data
-FROM "${targetTable}" "${innerTableAlias}"
-${whereSQL}
+        const lateralSQL = `
+SELECT ${aggregateExpression} as data
+FROM "${targetTable}" "${innerTableAlias}"
+${whereSQL}
     `.trim();
         return lateralSQL;
     }