linkgress-orm 0.1.1 → 0.1.4

package/dist/query/query-builder.js

@@ -121,7 +121,7 @@ const NUMERIC_REGEX = /^-?\d+(\.\d+)?$/;
  * Query builder for a table
  */
 class QueryBuilder {
-    constructor(schema, client, whereCond, limit, offset, orderBy, executor, manualJoins, joinCounter, collectionStrategy) {
+    constructor(schema, client, whereCond, limit, offset, orderBy, executor, manualJoins, joinCounter, collectionStrategy, schemaRegistry) {
         this.orderByFields = [];
         this.manualJoins = [];
         this.joinCounter = 0;
@@ -135,6 +135,7 @@ class QueryBuilder {
         this.manualJoins = manualJoins || [];
         this.joinCounter = joinCounter || 0;
         this.collectionStrategy = collectionStrategy;
+        this.schemaRegistry = schemaRegistry;
     }
     /**
      * Get qualified table name with schema prefix if specified
@@ -148,7 +149,7 @@ class QueryBuilder {
      */
     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
-        undefined, // schemaRegistry
+        this.schemaRegistry, // Pass schema registry for nested navigation resolution
         [], // ctes - start with empty array
         this.collectionStrategy);
     }
@@ -171,7 +172,8 @@ class QueryBuilder {
      * 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);
+        return new SelectQueryBuilder(this.schema, this.client, (row) => row, this.whereCond, this.limitValue, this.offsetValue, this.orderByFields, this.executor, this.manualJoins, this.joinCounter, false, this.schemaRegistry, // Pass schema registry for nested navigation resolution
+        ctes, this.collectionStrategy);
     }
     /**
      * Create mock row for analysis
@@ -200,12 +202,16 @@ class QueryBuilder {
         const relationEntries = getRelationEntriesForSchema(this.schema);
         // Add relations (both collections and single references)
         for (const [relName, relConfig] of relationEntries) {
-            // Performance: Use cached target schema
-            const targetSchema = getTargetSchemaForRelation(this.schema, relName, relConfig);
+            // Performance: Use cached target schema, but prefer registry lookup for full relations
+            let targetSchema = this.schemaRegistry?.get(relConfig.targetTable);
+            if (!targetSchema) {
+                targetSchema = getTargetSchemaForRelation(this.schema, relName, relConfig);
+            }
             if (relConfig.type === 'many') {
                 Object.defineProperty(mock, relName, {
                     get: () => {
-                        return new CollectionQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKey || relConfig.foreignKeys?.[0] || '', this.schema.name, targetSchema);
+                        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,
                     configurable: true,
@@ -215,7 +221,8 @@ class QueryBuilder {
                 // Single reference navigation (many-to-one, one-to-one)
                 Object.defineProperty(mock, relName, {
                     get: () => {
-                        const refBuilder = new ReferenceQueryBuilder(relName, relConfig.targetTable, relConfig.foreignKeys || [relConfig.foreignKey || ''], relConfig.matches || [], relConfig.isMandatory ?? false, targetSchema);
+                        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,
@@ -806,7 +813,7 @@ class SelectQueryBuilder {
             get(target, prop) {
                 if (typeof prop === 'symbol')
                     return undefined;
-                // If we have selection metadata, check if this property has a mapper
+                // If we have selection metadata, check if this property has a mapper or is an aggregation array
                 if (cte.selectionMetadata && prop in cte.selectionMetadata) {
                     const value = cte.selectionMetadata[prop];
                     // If it's a SqlFragment with a mapper, preserve it
@@ -819,6 +826,16 @@ class SelectQueryBuilder {
                             getMapper: () => value.getMapper(),
                         };
                     }
+                    // If it's a CTE aggregation array marker, preserve it with inner metadata
+                    if (typeof value === 'object' && value !== null && '__isAggregationArray' in value && value.__isAggregationArray) {
+                        return {
+                            __fieldName: prop,
+                            __dbColumnName: prop,
+                            __tableAlias: cte.name,
+                            __isAggregationArray: true,
+                            __innerSelectionMetadata: value.__innerSelectionMetadata,
+                        };
+                    }
                 }
                 // Return a regular FieldRef for any property accessed
                 return {
@@ -1462,31 +1479,117 @@ class SelectQueryBuilder {
     }
     /**
      * Detect navigation property references in selection and add necessary JOINs
+     * Supports multi-level navigation like task.level.createdBy
      */
     detectAndAddJoinsFromSelection(selection, joins) {
         if (!selection || typeof selection !== 'object') {
             return;
         }
-        for (const [key, value] of Object.entries(selection)) {
+        // First pass: collect all table aliases
+        const allTableAliases = new Set();
+        this.collectTableAliasesFromSelection(selection, allTableAliases);
+        // Second pass: resolve all joins through the schema graph
+        this.resolveJoinsForTableAliases(allTableAliases, joins);
+    }
+    /**
+     * Collect all table aliases from a selection
+     */
+    collectTableAliasesFromSelection(selection, allTableAliases) {
+        if (!selection || typeof selection !== 'object') {
+            return;
+        }
+        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
-                this.addJoinForFieldRef(value, joins);
+                // This is a FieldRef with a table alias
+                const tableAlias = value.__tableAlias;
+                if (tableAlias && tableAlias !== this.schema.name) {
+                    allTableAliases.add(tableAlias);
+                }
             }
             else if (value instanceof conditions_1.SqlFragment) {
-                // SqlFragment may contain navigation property references - extract them
+                // SqlFragment may contain navigation property references
                 const fieldRefs = value.getFieldRefs();
                 for (const fieldRef of fieldRefs) {
-                    this.addJoinForFieldRef(fieldRef, joins);
+                    if ('__tableAlias' in fieldRef && fieldRef.__tableAlias) {
+                        const tableAlias = fieldRef.__tableAlias;
+                        if (tableAlias && tableAlias !== this.schema.name) {
+                            allTableAliases.add(tableAlias);
+                        }
+                    }
                 }
             }
-            else if (value && typeof value === 'object' && !Array.isArray(value)) {
+            else if (value && typeof value === 'object' && !Array.isArray(value) && !(value instanceof CollectionQueryBuilder)) {
                 // Recursively check nested objects
-                this.detectAndAddJoinsFromSelection(value, joins);
+                this.collectTableAliasesFromSelection(value, allTableAliases);
+            }
+        }
+    }
+    /**
+     * Resolve all navigation joins by finding the correct path through the schema graph
+     * This handles multi-level navigation like task.level.createdBy
+     */
+    resolveJoinsForTableAliases(allTableAliases, joins) {
+        if (allTableAliases.size === 0) {
+            return;
+        }
+        // Keep resolving until we've resolved all aliases or can't make progress
+        const resolved = new Set();
+        let maxIterations = allTableAliases.size * 3; // Prevent infinite loops
+        while (resolved.size < allTableAliases.size && maxIterations-- > 0) {
+            // Build a map of already joined schemas for path resolution
+            const joinedSchemas = new Map();
+            joinedSchemas.set(this.schema.name, this.schema);
+            for (const join of joins) {
+                let schema;
+                if (this.schemaRegistry) {
+                    schema = this.schemaRegistry.get(join.targetTable);
+                }
+                if (schema) {
+                    joinedSchemas.set(join.alias, schema);
+                }
+            }
+            // Try to resolve each unresolved alias
+            for (const alias of allTableAliases) {
+                if (resolved.has(alias) || joins.some(j => j.alias === alias)) {
+                    resolved.add(alias);
+                    continue;
+                }
+                // Look for this alias in any of the already joined schemas
+                for (const [sourceAlias, schema] of joinedSchemas) {
+                    if (schema.relations && schema.relations[alias]) {
+                        const relation = schema.relations[alias];
+                        if (relation.type === 'one') {
+                            // Get target schema
+                            let targetSchema;
+                            let targetSchemaName;
+                            if (this.schemaRegistry) {
+                                targetSchema = this.schemaRegistry.get(relation.targetTable);
+                                targetSchemaName = targetSchema?.schema;
+                            }
+                            if (!targetSchema && relation.targetTableBuilder) {
+                                targetSchema = relation.targetTableBuilder.build();
+                                targetSchemaName = targetSchema?.schema;
+                            }
+                            joins.push({
+                                alias,
+                                targetTable: relation.targetTable,
+                                targetSchema: targetSchemaName,
+                                foreignKeys: relation.foreignKeys || [relation.foreignKey || ''],
+                                matches: relation.matches || ['id'],
+                                isMandatory: relation.isMandatory ?? false,
+                                sourceAlias, // Track where this join comes from
+                            });
+                            resolved.add(alias);
+                            break;
+                        }
+                    }
+                }
             }
         }
     }
     /**
      * Add a JOIN for a FieldRef if it references a related table
+     * @deprecated Use detectAndAddJoinsFromSelection with multi-level resolution instead
      */
     addJoinForFieldRef(fieldRef, joins) {
         if (!fieldRef || typeof fieldRef !== 'object' || !('__tableAlias' in fieldRef) || !('__dbColumnName' in fieldRef)) {
@@ -1522,35 +1625,19 @@ class SelectQueryBuilder {
         if (!condition) {
             return;
         }
-        // Get all field references from the condition
+        // Collect all table aliases from the condition
+        const allTableAliases = new Set();
         const fieldRefs = condition.getFieldRefs();
         for (const fieldRef of fieldRefs) {
             if ('__tableAlias' in fieldRef && fieldRef.__tableAlias) {
                 const tableAlias = fieldRef.__tableAlias;
-                // Check if this references a related table that isn't already joined
-                if (tableAlias !== this.schema.name && !joins.some(j => j.alias === tableAlias)) {
-                    // Find the relation config for this navigation
-                    const relation = this.schema.relations[tableAlias];
-                    if (relation && relation.type === 'one') {
-                        // Get target schema from targetTableBuilder if available
-                        let targetSchema;
-                        if (relation.targetTableBuilder) {
-                            const targetTableSchema = relation.targetTableBuilder.build();
-                            targetSchema = targetTableSchema.schema;
-                        }
-                        // Add a JOIN for this reference
-                        joins.push({
-                            alias: tableAlias,
-                            targetTable: relation.targetTable,
-                            targetSchema,
-                            foreignKeys: relation.foreignKeys || [relation.foreignKey || ''],
-                            matches: relation.matches || [],
-                            isMandatory: relation.isMandatory ?? false,
-                        });
-                    }
+                if (tableAlias !== this.schema.name) {
+                    allTableAliases.add(tableAlias);
                 }
             }
         }
+        // Resolve all joins through the schema graph
+        this.resolveJoinsForTableAliases(allTableAliases, joins);
     }
     /**
      * Build SQL query
@@ -1632,6 +1719,7 @@ class SelectQueryBuilder {
                     if ('__tableAlias' in value && value.__tableAlias && typeof value.__tableAlias === 'string') {
                         // This is a field from a joined table
                         const tableAlias = value.__tableAlias;
+                        const columnName = value.__dbColumnName;
                         // Find the relation config for this navigation
                         const relConfig = this.schema.relations[tableAlias];
                         if (relConfig) {
@@ -1653,7 +1741,15 @@ class SelectQueryBuilder {
                                 });
                             }
                         }
-                        selectParts.push(`"${tableAlias}"."${value.__dbColumnName}" as "${key}"`);
+                        // Check if this is a CTE aggregation column that needs COALESCE
+                        const cteJoin = this.manualJoins.find(j => j.cte && j.cte.name === tableAlias);
+                        if (cteJoin && cteJoin.cte && cteJoin.cte.isAggregationColumn(columnName)) {
+                            // CTE aggregation column - wrap with COALESCE to return empty array instead of null
+                            selectParts.push(`COALESCE("${tableAlias}"."${columnName}", '[]'::jsonb) as "${key}"`);
+                        }
+                        else {
+                            selectParts.push(`"${tableAlias}"."${columnName}" as "${key}"`);
+                        }
                     }
                     else {
                         // Regular field from the main table
@@ -1912,11 +2008,14 @@ class SelectQueryBuilder {
         for (const join of joins) {
             const joinType = join.isMandatory ? 'INNER JOIN' : 'LEFT JOIN';
             // Build ON clause for the join
+            // For multi-level navigation, use the sourceAlias (the intermediate table)
+            // For direct navigation, use the main table name
+            const sourceTable = join.sourceAlias || this.schema.name;
             const onConditions = [];
             for (let i = 0; i < join.foreignKeys.length; i++) {
                 const fk = join.foreignKeys[i];
                 const match = join.matches[i];
-                onConditions.push(`"${this.schema.name}"."${fk}" = "${join.alias}"."${match}"`);
+                onConditions.push(`"${sourceTable}"."${fk}" = "${join.alias}"."${match}"`);
             }
             // Use schema-qualified table name if schema is specified
             const joinTableName = this.getQualifiedTableName(join.targetTable, join.targetSchema);
@@ -2048,6 +2147,17 @@ class SelectQueryBuilder {
                         }
                     }
                 }
+                else if (typeof value === 'object' && value !== null && '__isAggregationArray' in value && value.__isAggregationArray) {
+                    // CTE withAggregation array - apply mappers to items inside
+                    const collectionItems = row[key] || [];
+                    const innerMetadata = value.__innerSelectionMetadata;
+                    if (innerMetadata && !disableMappers) {
+                        result[key] = this.transformCteAggregationItems(collectionItems, innerMetadata);
+                    }
+                    else {
+                        result[key] = collectionItems;
+                    }
+                }
                 else if (typeof value === 'object' && value !== null && typeof value.getMapper === 'function') {
                     // SqlFragment with custom mapper (check this BEFORE FieldRef to handle subquery/CTE fields with mappers)
                     const rawValue = row[key];
@@ -2160,6 +2270,54 @@ class SelectQueryBuilder {
             return transformedItem;
         });
     }
+    /**
+     * Transform CTE aggregation items applying fromDriver mappers from selection metadata
+     */
+    transformCteAggregationItems(items, selectionMetadata) {
+        if (!items || items.length === 0) {
+            return [];
+        }
+        // Build mapper cache from selection metadata
+        const mapperCache = {};
+        for (const [key, value] of Object.entries(selectionMetadata)) {
+            // Check if value has getMapper (SqlFragment or field with mapper)
+            if (typeof value === 'object' && value !== null && typeof value.getMapper === 'function') {
+                let mapper = value.getMapper();
+                // If mapper is a CustomTypeBuilder, get the actual type
+                if (mapper && typeof mapper.getType === 'function') {
+                    mapper = mapper.getType();
+                }
+                if (mapper && typeof mapper.fromDriver === 'function') {
+                    mapperCache[key] = mapper;
+                }
+            }
+            // Check if it's a FieldRef with schema column mapper
+            else if (typeof value === 'object' && value !== null && '__fieldName' in value) {
+                const fieldName = value.__fieldName;
+                const column = this.schema.columns[fieldName];
+                if (column) {
+                    const config = column.build();
+                    if (config.mapper && typeof config.mapper.fromDriver === 'function') {
+                        mapperCache[key] = config.mapper;
+                    }
+                }
+            }
+        }
+        // Transform items
+        return items.map(item => {
+            const transformedItem = {};
+            for (const [key, value] of Object.entries(item)) {
+                const mapper = mapperCache[key];
+                if (mapper && value !== null && value !== undefined) {
+                    transformedItem[key] = mapper.fromDriver(value);
+                }
+                else {
+                    transformedItem[key] = value;
+                }
+            }
+            return transformedItem;
+        });
+    }
     /**
      * Build aggregation query (MIN, MAX, SUM)
      */
@@ -2493,7 +2651,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);
+        const newBuilder = new CollectionQueryBuilder(this.relationName, this.targetTable, this.foreignKey, this.sourceTable, this.targetTableSchema, this.schemaRegistry // Pass schema registry for nested navigation resolution
+        );
         newBuilder.selector = selector;
         newBuilder.whereCond = this.whereCond;
         newBuilder.limitValue = this.limitValue;
@@ -2726,6 +2885,151 @@ class CollectionQueryBuilder {
     getFlattenResultType() {
         return this.flattenResultType;
     }
+    /**
+     * Detect navigation property references in the selected fields and add necessary JOINs
+     * This supports multi-level navigation like p.task.level.createdBy.username
+     */
+    detectNavigationJoins(selection, joins, currentSourceAlias, currentSchema) {
+        if (!selection || typeof selection !== 'object') {
+            return;
+        }
+        // Collect all table aliases referenced in the selection
+        const allTableAliases = new Set();
+        // Helper to collect from a single selection
+        const collectFromSelection = (sel) => {
+            if (!sel || typeof sel !== 'object') {
+                return;
+            }
+            // Handle single FieldRef
+            if ('__tableAlias' in sel && '__dbColumnName' in sel) {
+                this.addNavigationJoinForFieldRef(sel, joins, currentSourceAlias, currentSchema, allTableAliases);
+                return;
+            }
+            // Handle object with multiple fields
+            for (const [_key, value] of Object.entries(sel)) {
+                if (value && typeof value === 'object' && '__tableAlias' in value && '__dbColumnName' in value) {
+                    // This is a FieldRef with a table alias
+                    this.addNavigationJoinForFieldRef(value, joins, currentSourceAlias, currentSchema, allTableAliases);
+                }
+                else if (value instanceof conditions_1.SqlFragment) {
+                    // SqlFragment may contain navigation property references
+                    const fieldRefs = value.getFieldRefs();
+                    for (const fieldRef of fieldRefs) {
+                        this.addNavigationJoinForFieldRef(fieldRef, joins, currentSourceAlias, currentSchema, allTableAliases);
+                    }
+                }
+                else if (value && typeof value === 'object' && !Array.isArray(value) && !(value instanceof CollectionQueryBuilder)) {
+                    // Recursively check nested objects
+                    collectFromSelection(value);
+                }
+            }
+        };
+        // First pass: collect all table aliases
+        collectFromSelection(selection);
+        // Second pass: resolve all navigation joins by finding the correct path through schemas
+        if (allTableAliases.size > 0) {
+            this.resolveNavigationJoins(allTableAliases, joins, currentSchema);
+        }
+    }
+    /**
+     * Add a navigation JOIN for a FieldRef if it references a related table
+     * Handles multi-level navigation by recursively resolving the join chain
+     */
+    addNavigationJoinForFieldRef(fieldRef, joins, sourceAlias, sourceSchema, allTableAliases) {
+        if (!fieldRef || typeof fieldRef !== 'object' || !('__tableAlias' in fieldRef)) {
+            return;
+        }
+        const tableAlias = fieldRef.__tableAlias;
+        // If this references the target table directly, no join needed
+        if (!tableAlias || tableAlias === this.targetTable) {
+            return;
+        }
+        // Collect this table alias for later resolution
+        allTableAliases.add(tableAlias);
+        // Check if we already have this join
+        if (joins.some(j => j.alias === tableAlias)) {
+            return;
+        }
+        // Find the relation in the current schema
+        const relation = sourceSchema.relations?.[tableAlias];
+        if (relation && relation.type === 'one') {
+            this.addNavigationJoin(tableAlias, relation, joins, sourceAlias);
+        }
+    }
+    /**
+     * Add a navigation join and return the target schema
+     */
+    addNavigationJoin(alias, relation, joins, sourceAlias) {
+        // Check if already added
+        if (joins.some(j => j.alias === alias)) {
+            return undefined;
+        }
+        // Get the target table schema
+        let targetSchema;
+        let targetSchemaName;
+        if (this.schemaRegistry) {
+            targetSchema = this.schemaRegistry.get(relation.targetTable);
+            targetSchemaName = targetSchema?.schema;
+        }
+        if (!targetSchema && relation.targetTableBuilder) {
+            targetSchema = relation.targetTableBuilder.build();
+            targetSchemaName = targetSchema?.schema;
+        }
+        // Build the join info
+        const foreignKeys = relation.foreignKeys || [relation.foreignKey || ''];
+        const matches = relation.matches || ['id']; // Default to 'id' as the PK
+        joins.push({
+            alias,
+            targetTable: relation.targetTable,
+            targetSchema: targetSchemaName,
+            foreignKeys,
+            matches,
+            isMandatory: relation.isMandatory ?? false,
+            sourceAlias,
+        });
+        return targetSchema;
+    }
+    /**
+     * Resolve all navigation joins by finding the correct path through the schema graph
+     * This handles multi-level navigation like task.level.createdBy
+     */
+    resolveNavigationJoins(allTableAliases, joins, startSchema) {
+        // Keep resolving until we've resolved all aliases or can't make progress
+        let resolved = new Set();
+        let maxIterations = allTableAliases.size * 2; // Prevent infinite loops
+        while (resolved.size < allTableAliases.size && maxIterations-- > 0) {
+            // Build a map of already joined schemas for path resolution
+            const joinedSchemas = new Map();
+            joinedSchemas.set(this.targetTable, startSchema);
+            for (const join of joins) {
+                let schema;
+                if (this.schemaRegistry) {
+                    schema = this.schemaRegistry.get(join.targetTable);
+                }
+                if (schema) {
+                    joinedSchemas.set(join.alias, schema);
+                }
+            }
+            // Try to resolve each unresolved alias
+            for (const alias of allTableAliases) {
+                if (resolved.has(alias) || joins.some(j => j.alias === alias)) {
+                    resolved.add(alias);
+                    continue;
+                }
+                // Look for this alias in any of the already joined schemas
+                for (const [schemaAlias, schema] of joinedSchemas) {
+                    if (schema.relations && schema.relations[alias]) {
+                        const relation = schema.relations[alias];
+                        if (relation.type === 'one') {
+                            this.addNavigationJoin(alias, relation, joins, schemaAlias);
+                            resolved.add(alias);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+    }
     /**
      * Build CTE for this collection query
      * Now delegates to collection strategy pattern
@@ -2760,8 +3064,13 @@ class CollectionQueryBuilder {
                 return { alias, expression: fragmentSql };
             }
             else if (typeof field === 'object' && field !== null && '__dbColumnName' in field) {
-                // FieldRef object - use database column name
+                // FieldRef object - use database column name with optional table alias
                 const dbColumnName = field.__dbColumnName;
+                const tableAlias = field.__tableAlias;
+                // 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: `"${dbColumnName}"` };
             }
             else if (typeof field === 'string') {
@@ -2884,7 +3193,14 @@ class CollectionQueryBuilder {
             aggregationType = 'jsonb';
             defaultValue = "'[]'::jsonb";
         }
-        // Step 5: Build CollectionAggregationConfig object
+        // Step 5: Detect navigation joins from the selected fields
+        const navigationJoins = [];
+        if (this.selector && this.targetTableSchema) {
+            const mockItem = this.createMockItem();
+            const selectedFields = this.selector(mockItem);
+            this.detectNavigationJoins(selectedFields, navigationJoins, this.targetTable, this.targetTableSchema);
+        }
+        // Step 6: Build CollectionAggregationConfig object
         const config = {
             relationName: this.relationName,
             targetTable: this.targetTable,
@@ -2903,6 +3219,7 @@ class CollectionQueryBuilder {
             arrayField,
             defaultValue,
             counter: context.cteCounter++,
+            navigationJoins: navigationJoins.length > 0 ? navigationJoins : undefined,
         };
         // Step 6: Call the strategy
         const result = strategy.buildAggregation(config, context, client);