linkgress-orm 0.4.15 → 0.4.20

package/dist/query/query-builder.js

@@ -4272,6 +4272,13 @@ ${joinClauses.join('\n')}`;
      * Applies custom mappers to fields within the nested collection result.
      */
     transformNestedCollectionValue(value, nestedInfo, schemaRegistry) {
+        // Flattened lists (toNumberList/toStringList) return a primitive array directly
+        // from the driver — no per-element object transformation applies. Iterating with
+        // `for (const key in item)` on a number/string would yield an empty object, so
+        // short-circuit here before touching any elements.
+        if (nestedInfo.flattenResultType) {
+            return value;
+        }
         const nestedSchema = schemaRegistry.get(nestedInfo.targetTable);
         if (!nestedSchema?.columnMetadataCache) {
             return value; // No schema info, return as-is
@@ -5158,6 +5165,16 @@ class CollectionQueryBuilder {
     getSchemaRegistry() {
         return this.schemaRegistry;
     }
+    /**
+     * Get the navigation path leading to this collection.
+     * Non-empty when this collection was reached through a reference chain
+     * (e.g. `cdc.discountCode!.discount!.discountProducts`). The outer collection
+     * builder needs these joins emitted in its own FROM so the nested aggregation's
+     * correlation key (e.g. `discount.id`) resolves.
+     */
+    getNavigationPath() {
+        return this.navigationPath;
+    }
     /**
      * Check if this collection uses array aggregation (for flattened results)
      */
@@ -5280,7 +5297,20 @@ class CollectionQueryBuilder {
                         this.addNavigationJoinForFieldRef(fieldRef, joins, currentSourceAlias, currentSchema, allTableAliases);
                     }
                 }
-                else if (value && typeof value === 'object' && !Array.isArray(value) && !(value instanceof CollectionQueryBuilder)) {
+                else if (value instanceof CollectionQueryBuilder) {
+                    // A nested collection that was reached via a reference chain (e.g.
+                    // `cdc.discountCode!.discount!.discountProducts`) carries the chain as its
+                    // navigationPath. The nested aggregation will correlate on the last alias's
+                    // PK (e.g. `discount.id`), so the outer collection must emit those joins
+                    // in its own FROM for the correlation to resolve.
+                    const nestedPath = value.getNavigationPath();
+                    for (const step of nestedPath) {
+                        if (!joins.some(j => j.alias === step.alias)) {
+                            joins.push(step);
+                        }
+                    }
+                }
+                else if (value && typeof value === 'object' && !Array.isArray(value)) {
                     // Recursively check nested objects
                     collectFromSelection(value);
                 }
@@ -5533,9 +5563,22 @@ class CollectionQueryBuilder {
                 if (nestedResult.tableName && (nestedResult.isCTE || nestedResult.joinClause)) {
                     let nestedJoinClause;
                     if (nestedResult.isCTE) {
-                        // CTE strategy: join by parent_id
-                        // The join should be: this.targetTable.id = nestedCte.parent_id
-                        nestedJoinClause = `LEFT JOIN "${nestedResult.tableName}" ON "${this.targetTable}"."id" = "${nestedResult.tableName}".parent_id`;
+                        // CTE strategy: join by parent_id. When the nested collection was reached
+                        // through a reference chain (e.g. `cdc.discountCode!.discount!.discountProducts`),
+                        // the CTE aggregates on the chain's terminal PK (here `discount.id`), not on
+                        // the outer collection's own PK — and the outer's target table may not even
+                        // have an `id` column (junction tables like `cart_discount_codes`). The
+                        // intermediate joins are emitted into the outer's FROM via detectNavigationJoins
+                        // picking up the nested path.
+                        const nestedPath = field.getNavigationPath();
+                        if (nestedPath.length > 0) {
+                            const lastStep = nestedPath[nestedPath.length - 1];
+                            const pk = lastStep.matches?.[0] || 'id';
+                            nestedJoinClause = `LEFT JOIN "${nestedResult.tableName}" ON "${lastStep.alias}"."${pk}" = "${nestedResult.tableName}".parent_id`;
+                        }
+                        else {
+                            nestedJoinClause = `LEFT JOIN "${nestedResult.tableName}" ON "${this.targetTable}"."id" = "${nestedResult.tableName}".parent_id`;
+                        }
                     }
                     else {
                         // LATERAL strategy: use the provided join clause (contains full LATERAL subquery)
@@ -5553,6 +5596,7 @@ class CollectionQueryBuilder {
                             targetTable: field.getTargetTable(),
                             selectedFieldConfigs: field.getSelectedFieldConfigs(),
                             isSingleResult: field.isSingleResult(),
+                            flattenResultType: field.getFlattenResultType(),
                         },
                     };
                 }
@@ -5576,6 +5620,7 @@ class CollectionQueryBuilder {
                         targetTable: field.getTargetTable(),
                         selectedFieldConfigs: field.getSelectedFieldConfigs(),
                         isSingleResult: field.isSingleResult(),
+                        flattenResultType: field.getFlattenResultType(),
                     },
                 };
             }
@@ -5613,10 +5658,14 @@ class CollectionQueryBuilder {
                 return { alias, expression };
             }
         };
+        // Evaluate the user's selector exactly once per buildCTE call. Downstream steps
+        // (field collection, aggregate-expression discovery, navigation-join detection) all
+        // need to walk the same selection, and re-invoking the selector is expensive
+        // (rebuilds proxy mocks and any nested CollectionQueryBuilder instances).
+        const selectorResult = this.selector ? this.selector(this.createMockItem()) : undefined;
         // Step 1: Build field selection configuration
         if (this.selector) {
-            const mockItem = this.createMockItem();
-            const selectedFields = this.selector(mockItem);
+            const selectedFields = selectorResult;
             // Check if the selector returns a FieldRef directly (single field selection like p => p.title)
             if (typeof selectedFields === 'object' && selectedFields !== null && '__dbColumnName' in selectedFields) {
                 // Single field selection - use the field name as both alias and expression
@@ -5629,6 +5678,10 @@ class CollectionQueryBuilder {
                     propertyName: fieldName,
                 });
             }
+            else if (selectedFields instanceof CollectionQueryBuilder || selectedFields instanceof conditions_1.SqlFragment) {
+                // Selector returns a scalar subquery (e.g. .sum(row => other.count())) or a raw fragment.
+                // No per-column fields to collect — the aggregate argument lives on aggregateExpression.
+            }
             else {
                 // Object selection - extract each field (with support for nested objects)
                 for (const [alias, field] of Object.entries(selectedFields)) {
@@ -5706,6 +5759,7 @@ class CollectionQueryBuilder {
         // Step 4: Determine aggregation type and field
         let aggregationType;
         let aggregateField;
+        let aggregateExpression;
         let arrayField;
         let defaultValue;
         if (this.aggregationType) {
@@ -5713,11 +5767,23 @@ class CollectionQueryBuilder {
             aggregationType = this.aggregationType.toLowerCase();
             // For aggregations other than COUNT and EXISTS, determine which field to aggregate
             if (this.aggregationType !== 'COUNT' && this.aggregationType !== 'EXISTS' && this.selector) {
-                const mockItem = this.createMockItem();
-                const selectedField = this.selector(mockItem);
+                const selectedField = selectorResult;
                 if (typeof selectedField === 'object' && selectedField !== null && '__dbColumnName' in selectedField) {
                     aggregateField = selectedField.__dbColumnName;
                 }
+                else if (selectedField instanceof CollectionQueryBuilder) {
+                    // Selector returns a nested collection (e.g., sum(row => other.where(...).count())).
+                    // We need a *scalar* SQL expression to feed into the aggregate — so force the nested
+                    // build to emit a correlated subquery (lateral's scalar form) rather than a CTE/temp
+                    // table that can't be composed inside SUM(...). Outer strategies (CTE, temp table,
+                    // lateral) then wrap this expression with the aggregate function via
+                    // config.aggregateExpression.
+                    const nestedCtx = { ...context, collectionStrategy: 'lateral' };
+                    const nestedResult = selectedField.buildCTE(nestedCtx, client);
+                    context.cteCounter = nestedCtx.cteCounter;
+                    context.paramCounter = nestedCtx.paramCounter;
+                    aggregateExpression = nestedResult.selectExpression || nestedResult.sql;
+                }
             }
             // Set default value based on aggregation type
             if (aggregationType === 'count') {
@@ -5748,10 +5814,13 @@ class CollectionQueryBuilder {
         }
         // 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);
+        if (this.selector && this.targetTableSchema && selectorResult !== undefined) {
+            // A CollectionQueryBuilder summand already had its navigation joins built via the
+            // recursive buildCTE above; detectNavigationJoins would iterate its own properties
+            // as if they were fields and produce nothing useful. Skip the walk in that case.
+            if (!(selectorResult instanceof CollectionQueryBuilder)) {
+                this.detectNavigationJoins(selectorResult, 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:
@@ -5782,6 +5851,7 @@ class CollectionQueryBuilder {
             isSingleResult: this.isSingleResult(), // For firstOrDefault() - returns single object instead of array
             aggregationType,
             aggregateField,
+            aggregateExpression,
             arrayField,
             defaultValue,
             // Use the reserved counter for LATERAL strategy, otherwise increment as before