linkgress-orm 0.1.18 → 0.1.20

package/dist/query/query-builder.js

@@ -247,24 +247,27 @@ class QueryBuilder {
                 targetSchema = getTargetSchemaForRelation(this.schema, relName, relConfig);
             }
             if (relConfig.type === 'many') {
+                // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', this.schema.name, targetSchema, this.schemaRegistry // Pass schema registry for nested navigation resolution
                         );
                     },
-                    enumerable: true,
+                    enumerable: false,
                     configurable: true,
                 });
             }
             else {
                 // Single reference navigation (many-to-one, one-to-one)
+                // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow
+                // with circular relations like User->Posts->User)
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema, this.schemaRegistry // Pass schema registry for nested navigation resolution
                         );
                         return refBuilder.createMockTargetRow();
                     },
-                    enumerable: true,
+                    enumerable: false,
                     configurable: true,
                 });
             }
@@ -406,22 +409,24 @@ class QueryBuilder {
             const targetSchema = getTargetSchemaForRelation(schema, relName, relConfig);
             if (relConfig.type === 'many') {
                 // Collection navigation
+                // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', schema.name, targetSchema);
                     },
-                    enumerable: true,
+                    enumerable: false,
                     configurable: true,
                 });
             }
             else {
                 // Single reference navigation
+                // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema);
                         return refBuilder.createMockTargetRow();
                     },
-                    enumerable: true,
+                    enumerable: false,
                     configurable: true,
                 });
             }
@@ -786,22 +791,24 @@ class SelectQueryBuilder {
             const targetSchema = getTargetSchemaForRelation(schema, relName, relConfig);
             if (relConfig.type === 'many') {
                 // Collection navigation
+                // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', schema.name, targetSchema);
                     },
-                    enumerable: true,
+                    enumerable: false,
                     configurable: true,
                 });
             }
             else {
                 // Single reference navigation
+                // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema);
                         return refBuilder.createMockTargetRow();
                     },
-                    enumerable: true,
+                    enumerable: false,
                     configurable: true,
                 });
             }
@@ -1473,8 +1480,10 @@ class SelectQueryBuilder {
             }
             const condBuilder = new conditions_1.ConditionBuilder();
             const { sql: whereSql, params: whereParams } = condBuilder.build(queryBuilder.whereCond, 1);
-            // Build RETURNING clause
-            const returningClause = queryBuilder.buildDeleteReturningClause(returning);
+            // Build RETURNING clause (not needed for count-only)
+            const returningClause = returning !== 'count'
+                ? queryBuilder.buildDeleteReturningClause(returning)
+                : undefined;
             const qualifiedTableName = queryBuilder.getQualifiedTableName(queryBuilder.schema.name, queryBuilder.schema.schema);
             let sql = `DELETE FROM ${qualifiedTableName} WHERE ${whereSql}`;
             if (returningClause) {
@@ -1483,6 +1492,10 @@ class SelectQueryBuilder {
             const result = queryBuilder.executor
                 ? await queryBuilder.executor.query(sql, whereParams)
                 : await queryBuilder.client.query(sql, whereParams);
+            // Return affected count
+            if (returning === 'count') {
+                return result.rowCount ?? 0;
+            }
             if (!returningClause) {
                 return undefined;
             }
@@ -1492,6 +1505,13 @@ class SelectQueryBuilder {
             then(onfulfilled, onrejected) {
                 return executeDelete(undefined).then(onfulfilled, onrejected);
             },
+            affectedCount() {
+                return {
+                    then(onfulfilled, onrejected) {
+                        return executeDelete('count').then(onfulfilled, onrejected);
+                    }
+                };
+            },
             returning(selector) {
                 const returningConfig = selector ?? true;
                 return {
@@ -1550,8 +1570,10 @@ class SelectQueryBuilder {
             const condBuilder = new conditions_1.ConditionBuilder();
             const { sql: whereSql, params: whereParams } = condBuilder.build(queryBuilder.whereCond, paramIndex);
             values.push(...whereParams);
-            // Build RETURNING clause
-            const returningClause = queryBuilder.buildDeleteReturningClause(returning);
+            // Build RETURNING clause (not needed for count-only)
+            const returningClause = returning !== 'count'
+                ? queryBuilder.buildDeleteReturningClause(returning)
+                : undefined;
             const qualifiedTableName = queryBuilder.getQualifiedTableName(queryBuilder.schema.name, queryBuilder.schema.schema);
             let sql = `UPDATE ${qualifiedTableName} SET ${setClauses.join(', ')} WHERE ${whereSql}`;
             if (returningClause) {
@@ -1560,6 +1582,10 @@ class SelectQueryBuilder {
             const result = queryBuilder.executor
                 ? await queryBuilder.executor.query(sql, values)
                 : await queryBuilder.client.query(sql, values);
+            // Return affected count
+            if (returning === 'count') {
+                return result.rowCount ?? 0;
+            }
             if (!returningClause) {
                 return undefined;
             }
@@ -1569,6 +1595,13 @@ class SelectQueryBuilder {
             then(onfulfilled, onrejected) {
                 return executeUpdate(undefined).then(onfulfilled, onrejected);
             },
+            affectedCount() {
+                return {
+                    then(onfulfilled, onrejected) {
+                        return executeUpdate('count').then(onfulfilled, onrejected);
+                    }
+                };
+            },
             returning(selector) {
                 const returningConfig = selector ?? true;
                 return {
@@ -1737,18 +1770,20 @@ class SelectQueryBuilder {
                 targetSchema = getTargetSchemaForRelation(this.schema, relName, relConfig);
             }
             if (relConfig.type === 'many') {
+                // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         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
                         );
                     },
-                    enumerable: true,
+                    enumerable: false,
                     configurable: true,
                 });
             }
             else {
                 // For single reference (many-to-one), create a ReferenceQueryBuilder
+                // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
                 Object.defineProperty(mock, relName, {
                     get: () => {
                         const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema, // Pass the target schema directly
@@ -1757,7 +1792,7 @@ class SelectQueryBuilder {
                         // Return a mock object that exposes the target table's columns
                         return refBuilder.createMockTargetRow();
                     },
-                    enumerable: true,
+                    enumerable: false,
                     configurable: true,
                 });
             }
@@ -2640,26 +2675,58 @@ class SelectQueryBuilder {
         // Use pre-cached column metadata from target schema
         // This avoids repeated column.build() calls for each item
         const columnCache = targetSchema.columnMetadataCache;
-        if (!columnCache || columnCache.size === 0) {
-            // Fallback for schemas without cache (shouldn't happen, but be safe)
-            return items.map(item => {
-                const transformedItem = {};
-                for (const [key, value] of Object.entries(item)) {
-                    const column = targetSchema.columns[key];
-                    if (column) {
-                        const config = column.build();
-                        transformedItem[key] = config.mapper
-                            ? config.mapper.fromDriver(value)
-                            : value;
-                    }
-                    else {
-                        transformedItem[key] = value;
+        // Build alias-to-field-info mapping from selected field configs
+        // This allows us to find the correct mapper when:
+        // 1. alias differs from property name (e.g., reservationExpiry: i.expiresAt)
+        // 2. field comes from navigation (e.g., customerBirthdate: i.userEshop.birthdate)
+        const selectedFieldConfigs = collectionBuilder.getSelectedFieldConfigs();
+        const aliasToFieldInfo = new Map();
+        if (selectedFieldConfigs) {
+            for (const field of selectedFieldConfigs) {
+                if (field.propertyName) {
+                    aliasToFieldInfo.set(field.alias, {
+                        propertyName: field.propertyName,
+                        sourceTable: field.sourceTable,
+                    });
+                }
+            }
+        }
+        // Pre-build mapper cache for all fields (including navigation fields)
+        // This avoids repeated schema lookups per item
+        const mapperCache = new Map(); // alias -> mapper
+        for (const [alias, fieldInfo] of aliasToFieldInfo) {
+            let mapper = null;
+            const schemaRegistry = collectionBuilder.getSchemaRegistry() || this.schemaRegistry;
+            if (fieldInfo.sourceTable && schemaRegistry) {
+                // Navigation field - look up mapper from the source table's schema
+                const navSchema = schemaRegistry.get(fieldInfo.sourceTable);
+                if (navSchema?.columnMetadataCache) {
+                    const cached = navSchema.columnMetadataCache.get(fieldInfo.propertyName);
+                    if (cached?.hasMapper) {
+                        mapper = cached.mapper;
                     }
                 }
-                return transformedItem;
-            });
+            }
+            else {
+                // Regular field from target schema
+                const cached = columnCache?.get(fieldInfo.propertyName);
+                if (cached?.hasMapper) {
+                    mapper = cached.mapper;
+                }
+            }
+            if (mapper) {
+                mapperCache.set(alias, mapper);
+            }
+        }
+        // Also add direct property matches from target schema (when no alias mapping)
+        if (columnCache) {
+            for (const [propertyName, cached] of columnCache) {
+                if (!mapperCache.has(propertyName) && cached.hasMapper) {
+                    mapperCache.set(propertyName, cached.mapper);
+                }
+            }
         }
-        // Optimized path using cached metadata and while(i--) loop
+        // Transform items using pre-built mapper cache
         const results = new Array(items.length);
         let i = items.length;
         while (i--) {
@@ -2667,9 +2734,9 @@ class SelectQueryBuilder {
             const transformedItem = {};
             for (const key in item) {
                 const value = item[key];
-                const cached = columnCache.get(key);
-                if (cached && cached.hasMapper) {
-                    transformedItem[key] = cached.mapper.fromDriver(value);
+                const mapper = mapperCache.get(key);
+                if (mapper) {
+                    transformedItem[key] = mapper.fromDriver(value);
                 }
                 else {
                     transformedItem[key] = value;
@@ -2929,13 +2996,15 @@ exports.SelectQueryBuilder = SelectQueryBuilder;
  * Reference query builder for single navigation (many-to-one, one-to-one)
  */
 class ReferenceQueryBuilder {
-    constructor(relationName, targetTable, foreignKeys, matches, isMandatory, targetTableSchema, schemaRegistry) {
+    constructor(relationName, targetTable, foreignKeys, matches, isMandatory, targetTableSchema, schemaRegistry, navigationPath, sourceAlias) {
         this.relationName = relationName;
         this.targetTable = targetTable;
         this.foreignKeys = foreignKeys;
         this.matches = matches;
         this.isMandatory = isMandatory;
         this.schemaRegistry = schemaRegistry;
+        this.navigationPath = navigationPath || [];
+        this.sourceAlias = sourceAlias || '';
         // Prefer registry lookup (has full relations) over passed schema
         if (this.schemaRegistry) {
             this.targetTableSchema = this.schemaRegistry.get(targetTable);
@@ -3001,6 +3070,7 @@ class ReferenceQueryBuilder {
                     columnMappers[colName] = config.mapper;
                 }
             }
+            const sourceTable = this.targetTable; // Actual table name for schema lookup
             for (const [colName, dbColumnName] of columnNameMap) {
                 const mapper = columnMappers[colName];
                 Object.defineProperty(mock, colName, {
@@ -3010,7 +3080,8 @@ class ReferenceQueryBuilder {
                             cached = fieldRefCache[colName] = {
                                 __fieldName: colName,
                                 __dbColumnName: dbColumnName,
-                                __tableAlias: tableAlias, // Mark which table this belongs to
+                                __tableAlias: tableAlias, // Alias for SQL generation
+                                __sourceTable: sourceTable, // Actual table name for mapper lookup
                                 __mapper: mapper, // Include mapper for toDriver transformation in conditions
                             };
                         }
@@ -3020,6 +3091,23 @@ class ReferenceQueryBuilder {
                     configurable: true,
                 });
             }
+            // Build extended navigation path for nested collections
+            // Only build navigation path if we have a sourceAlias (meaning we're inside a collection's selector)
+            // If sourceAlias is empty, we're in the main query and references are joined in the FROM clause
+            let extendedNavPath = [];
+            if (this.sourceAlias) {
+                // Build the current navigation step to include in path for nested collections
+                // This represents the join from sourceAlias to this.relationName (this.targetTable)
+                const currentNavStep = {
+                    alias: this.relationName,
+                    targetTable: this.targetTable,
+                    foreignKeys: this.foreignKeys,
+                    matches: this.matches.length > 0 ? this.matches : ['id'], // Default to 'id' if not specified
+                    isMandatory: this.isMandatory,
+                    sourceAlias: this.sourceAlias,
+                };
+                extendedNavPath = [...this.navigationPath, currentNavStep];
+            }
             // Add navigation properties (both collections and references)
             if (this.targetTableSchema.relations) {
                 for (const [relName, relConfig] of Object.entries(this.targetTableSchema.relations)) {
@@ -3033,27 +3121,34 @@ class ReferenceQueryBuilder {
                     }
                     if (relConfig.type === 'many') {
                         // Collection navigation
+                        // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
                         Object.defineProperty(mock, relName, {
                             get: () => {
                                 const fk = relConfig.foreignKey || relConfig.foreignKeys?.[0] || '';
-                                return new CollectionQueryBuilder(relName, relConfig.targetTable, fk, this.targetTable, nestedTargetSchema, // Pass the target schema directly
-                                this.schemaRegistry // Pass schema registry for nested resolution
+                                return new CollectionQueryBuilder(relName, relConfig.targetTable, fk, this.relationName, // Use alias (relationName) for correlation in lateral joins
+                                nestedTargetSchema, // Pass the target schema directly
+                                this.schemaRegistry, // Pass schema registry for nested resolution
+                                extendedNavPath // Pass navigation path for intermediate joins (empty if main query)
                                 );
                             },
-                            enumerable: true,
+                            enumerable: false,
                             configurable: true,
                         });
                     }
                     else {
                         // Reference navigation
+                        // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow
+                        // with circular relations like User->Posts->User)
                         Object.defineProperty(mock, relName, {
                             get: () => {
                                 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
+                                this.schemaRegistry, // Pass schema registry for nested resolution
+                                extendedNavPath, // Pass navigation path for nested collections
+                                this.sourceAlias ? this.relationName : '' // Only set source if tracking path
                                 );
                                 return refBuilder.createMockTargetRow();
                             },
-                            enumerable: true,
+                            enumerable: false,
                             configurable: true,
                         });
                     }
@@ -3072,7 +3167,7 @@ exports.ReferenceQueryBuilder = ReferenceQueryBuilder;
  * Collection query builder for nested queries
  */
 class CollectionQueryBuilder {
-    constructor(relationName, targetTable, foreignKey, sourceTable, targetTableSchema, schemaRegistry) {
+    constructor(relationName, targetTable, foreignKey, sourceTable, targetTableSchema, schemaRegistry, navigationPath) {
         this.orderByFields = [];
         this.isMarkedAsList = false;
         this.isDistinct = false;
@@ -3082,6 +3177,7 @@ class CollectionQueryBuilder {
         this.foreignKey = foreignKey;
         this.sourceTable = sourceTable;
         this.schemaRegistry = schemaRegistry;
+        this.navigationPath = navigationPath || [];
         // Prefer registry lookup (has full relations) over passed schema
         if (this.schemaRegistry) {
             const registrySchema = this.schemaRegistry.get(targetTable);
@@ -3098,7 +3194,8 @@ class CollectionQueryBuilder {
      * Select specific fields from collection items
      */
     select(selector) {
-        const newBuilder = new CollectionQueryBuilder(this.relationName, this.targetTable, this.foreignKey, this.sourceTable, this.targetTableSchema, this.schemaRegistry // Pass schema registry for nested navigation resolution
+        const newBuilder = new CollectionQueryBuilder(this.relationName, this.targetTable, this.foreignKey, this.sourceTable, this.targetTableSchema, this.schemaRegistry, // Pass schema registry for nested navigation resolution
+        this.navigationPath // Pass navigation path for intermediate joins
         );
         newBuilder.selector = selector;
         newBuilder.whereCond = this.whereCond;
@@ -3148,7 +3245,8 @@ class CollectionQueryBuilder {
             const columnNameMap = getColumnNameMapForSchema(this.targetTableSchema);
             // Performance: Lazy-cache FieldRef objects
             const fieldRefCache = {};
-            // Add columns
+            // Add columns - include tableAlias for unambiguous column references in WHERE clauses
+            const tableAlias = this.targetTable;
             for (const [colName, dbColumnName] of columnNameMap) {
                 Object.defineProperty(mock, colName, {
                     get() {
@@ -3157,6 +3255,7 @@ class CollectionQueryBuilder {
                             cached = fieldRefCache[colName] = {
                                 __fieldName: colName,
                                 __dbColumnName: dbColumnName,
+                                __tableAlias: tableAlias, // Include table alias for unambiguous references
                             };
                         }
                         return cached;
@@ -3170,30 +3269,35 @@ class CollectionQueryBuilder {
                 for (const [relName, relConfig] of Object.entries(this.targetTableSchema.relations)) {
                     if (relConfig.type === 'many') {
                         // Collection navigation
+                        // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
                         Object.defineProperty(mock, relName, {
                             get: () => {
                                 // Don't call build() - it returns schema without relations
                                 const fk = relConfig.foreignKey || relConfig.foreignKeys?.[0] || '';
                                 return new CollectionQueryBuilder(relName, relConfig.targetTable, fk, this.targetTable, undefined, // Don't pass schema, force registry lookup
                                 this.schemaRegistry // Pass schema registry for nested resolution
+                                // No navigation path needed here - direct collection access from parent
                                 );
                             },
-                            enumerable: true,
+                            enumerable: false,
                             configurable: true,
                         });
                     }
                     else {
                         // Reference navigation
+                        // Non-enumerable to prevent Object.entries triggering getters (avoids stack overflow)
                         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
-                                this.schemaRegistry // Pass schema registry for nested resolution
+                                this.schemaRegistry, // Pass schema registry for nested resolution
+                                [], // Empty navigation path - this is the first reference in the chain
+                                this.targetTable // Source alias is this collection's target table
                                 );
                                 return refBuilder.createMockTargetRow();
                             },
-                            enumerable: true,
+                            enumerable: false,
                             configurable: true,
                         });
                     }
@@ -3328,6 +3432,18 @@ class CollectionQueryBuilder {
     getTargetTableSchema() {
         return this.targetTableSchema;
     }
+    /**
+     * Get selected field configs (for mapper lookup during transformation)
+     */
+    getSelectedFieldConfigs() {
+        return this._selectedFieldConfigs;
+    }
+    /**
+     * Get schema registry (for mapper lookup during transformation of navigation fields)
+     */
+    getSchemaRegistry() {
+        return this.schemaRegistry;
+    }
     /**
      * Check if this collection uses array aggregation (for flattened results)
      */
@@ -3613,7 +3729,9 @@ class CollectionQueryBuilder {
                     cteCounter: context.cteCounter,
                 };
                 const nestedResult = field.buildCTE(nestedCtx, client);
+                // Sync both counters back - cteCounter for CTE naming, paramCounter for parameter numbering
                 context.cteCounter = nestedCtx.cteCounter;
+                context.paramCounter = nestedCtx.paramCounter;
                 // For CTE/LATERAL strategy, we need to track the nested join
                 // The nested aggregation needs to be joined in the outer collection's subquery
                 if (nestedResult.tableName) {
@@ -3647,11 +3765,13 @@ class CollectionQueryBuilder {
                 // FieldRef object - use database column name with optional table alias
                 const dbColumnName = field.__dbColumnName;
                 const tableAlias = field.__tableAlias;
+                const fieldName = field.__fieldName; // Property name for mapper lookup
+                const sourceTable = field.__sourceTable; // Actual table name for schema lookup
                 // If tableAlias differs from the target table, it's a navigation property reference
                 if (tableAlias && tableAlias !== this.targetTable) {
-                    return { alias, expression: `"${tableAlias}"."${dbColumnName}"` };
+                    return { alias, expression: `"${tableAlias}"."${dbColumnName}"`, propertyName: fieldName, sourceTable };
                 }
-                return { alias, expression: `"${dbColumnName}"` };
+                return { alias, expression: `"${dbColumnName}"`, propertyName: fieldName };
             }
             else if (typeof field === 'string') {
                 // Simple string reference (for backward compatibility)
@@ -3682,9 +3802,11 @@ class CollectionQueryBuilder {
                 // Single field selection - use the field name as both alias and expression
                 const field = selectedFields;
                 const dbColumnName = field.__dbColumnName;
+                const fieldName = field.__fieldName; // Property name for mapper lookup
                 selectedFieldConfigs.push({
                     alias: dbColumnName,
                     expression: `"${dbColumnName}"`,
+                    propertyName: fieldName,
                 });
             }
             else {
@@ -3703,6 +3825,7 @@ class CollectionQueryBuilder {
                     selectedFieldConfigs.push({
                         alias: colName,
                         expression: `"${dbColumnName}"`,
+                        propertyName: colName, // Same as alias when selecting all fields
                     });
                 }
             }
@@ -3714,6 +3837,8 @@ class CollectionQueryBuilder {
                 });
             }
         }
+        // Cache selected field configs for mapper lookup during transformation
+        this._selectedFieldConfigs = selectedFieldConfigs;
         // Step 2: Build WHERE clause SQL (without WHERE keyword)
         let whereClause;
         let whereParams;
@@ -3780,6 +3905,12 @@ class CollectionQueryBuilder {
             const selectedFields = this.selector(mockItem);
             this.detectNavigationJoins(selectedFields, navigationJoins, this.targetTable, this.targetTableSchema);
         }
+        // Step 5b: Merge navigation path joins (for intermediate tables in navigation chains)
+        // These joins are needed when accessing a collection through a chain like:
+        // oi.productPrice.product.resort.productIntegrationDefinitions
+        // The navigation path contains joins for productPrice, product, resort
+        // which must be included in the lateral subquery for correlation
+        const allNavigationJoins = [...this.navigationPath, ...navigationJoins];
         // Step 6: Build CollectionAggregationConfig object
         const config = {
             relationName: this.relationName,
@@ -3799,7 +3930,7 @@ class CollectionQueryBuilder {
             arrayField,
             defaultValue,
             counter: context.cteCounter++,
-            navigationJoins: navigationJoins.length > 0 ? navigationJoins : undefined,
+            navigationJoins: allNavigationJoins.length > 0 ? allNavigationJoins : undefined,
         };
         // Step 6: Call the strategy
         const result = strategy.buildAggregation(config, context, client);