linkgress-orm 0.4.2 → 0.4.3

package/dist/query/query-builder.js

@@ -1757,6 +1757,8 @@ class SelectQueryBuilder {
                 return "'{}'";
             case 'count':
                 return '0';
+            case 'exists':
+                return 'false';
             case 'min':
             case 'max':
             case 'sum':
@@ -1772,7 +1774,11 @@ class SelectQueryBuilder {
         const builderAny = builder;
         if (builderAny.aggregationType) {
             // Scalar aggregation
-            return builderAny.aggregationType === 'COUNT' ? 0 : null;
+            if (builderAny.aggregationType === 'COUNT')
+                return 0;
+            if (builderAny.aggregationType === 'EXISTS')
+                return false;
+            return null;
         }
         else if (builderAny.flattenResultType) {
             // Array aggregation
@@ -3450,6 +3456,9 @@ ${joinClauses.join('\n')}`;
                 if (aggregationType === 'COUNT') {
                     selectParts.push(`COALESCE("${cteName}".data, 0) as "${name}"`);
                 }
+                else if (aggregationType === 'EXISTS') {
+                    selectParts.push(`COALESCE("${cteName}".data, false) as "${name}"`);
+                }
                 else {
                     // For MAX/MIN/SUM, keep NULL as-is
                     selectParts.push(`"${cteName}".data as "${name}"`);
@@ -4735,6 +4744,8 @@ class CollectionQueryBuilder {
         this.orderByFields = [];
         this.isMarkedAsList = false;
         this.isDistinct = false;
+        // Navigation joins added by selectMany() - included in both CTE and LATERAL navigation joins
+        this.selectManyJoins = [];
         this.relationName = relationName;
         this.targetTable = targetTable;
         this.targetTableSchema = targetTableSchema;
@@ -4768,6 +4779,8 @@ class CollectionQueryBuilder {
         newBuilder.orderByFields = this.orderByFields;
         newBuilder.asName = this.asName;
         newBuilder.isDistinct = this.isDistinct;
+        newBuilder.selectManyJoins = this.selectManyJoins;
+        newBuilder.foreignKeyTableAlias = this.foreignKeyTableAlias;
         return newBuilder;
     }
     /**
@@ -4946,6 +4959,48 @@ class CollectionQueryBuilder {
         this.aggregationType = 'COUNT';
         return this;
     }
+    /**
+     * Check if any items exist in the collection
+     * Returns SqlFragment<boolean> for automatic type resolution in selectors
+     */
+    exists() {
+        this.aggregationType = 'EXISTS';
+        return this;
+    }
+    /**
+     * Flatten a nested collection through this collection.
+     * Similar to LINQ's SelectMany - projects each item to a collection and flattens.
+     *
+     * Example: product.productPrices!.selectMany(pp => pp.capacityGroups!).exists()
+     * SQL: SELECT EXISTS(SELECT 1 FROM capacity_groups JOIN product_prices ON ... WHERE ...)
+     */
+    selectMany(selector) {
+        const mockItem = this.createMockItem();
+        const innerCollection = selector(mockItem);
+        const innerAny = innerCollection;
+        // Build a navigation join from inner target table → this (intermediate) table
+        // e.g., product_price_capacity_groups.product_price_id → product_prices.id
+        const navJoin = {
+            alias: this.targetTable,
+            targetTable: this.targetTable,
+            foreignKeys: [innerAny.foreignKey], // FK on inner table pointing to intermediate
+            matches: ['id'], // PK on intermediate table
+            isMandatory: true, // INNER JOIN for flattening
+            sourceAlias: innerAny.targetTable, // Source is the inner (target) table
+        };
+        // Create new builder targeting the inner table but with outer's FK for parent correlation
+        const newBuilder = new CollectionQueryBuilder(this.relationName, // Keep outer relation name for CTE naming
+        innerAny.targetTable, // Target is the inner collection's table
+        this.foreignKey, // FK is the outer collection's FK (e.g., product_id)
+        this.sourceTable, // Source is the outer collection's source (e.g., products)
+        innerAny.targetTableSchema, this.schemaRegistry, this.navigationPath);
+        // The FK column lives on the intermediate table, not the target table
+        newBuilder.selectManyJoins = [navJoin];
+        newBuilder.foreignKeyTableAlias = this.targetTable;
+        // Carry over where condition from outer collection if any
+        newBuilder.whereCond = this.whereCond;
+        return newBuilder;
+    }
     /**
      * Flatten result to number array (for single-column selections)
      */
@@ -5360,7 +5415,7 @@ class CollectionQueryBuilder {
                 // For scalar aggregations (count, min, max, sum), don't include nestedCollectionInfo
                 // because the result is a scalar value, not a structured object that needs transformation
                 const aggregationType = field.getAggregationType();
-                const isScalarAggregation = aggregationType && ['COUNT', 'MIN', 'MAX', 'SUM'].includes(aggregationType);
+                const isScalarAggregation = aggregationType && ['COUNT', 'MIN', 'MAX', 'SUM', 'EXISTS'].includes(aggregationType);
                 if (isScalarAggregation) {
                     // Scalar aggregation - just return the expression, no nested transformation needed
                     return {
@@ -5509,10 +5564,10 @@ class CollectionQueryBuilder {
         let arrayField;
         let defaultValue;
         if (this.aggregationType) {
-            // Scalar aggregations: count, min, max, sum
+            // Scalar aggregations: count, min, max, sum, exists
             aggregationType = this.aggregationType.toLowerCase();
-            // For aggregations other than COUNT, determine which field to aggregate
-            if (this.aggregationType !== 'COUNT' && this.selector) {
+            // 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);
                 if (typeof selectedField === 'object' && selectedField !== null && '__dbColumnName' in selectedField) {
@@ -5520,7 +5575,15 @@ class CollectionQueryBuilder {
                 }
             }
             // Set default value based on aggregation type
-            defaultValue = aggregationType === 'count' ? '0' : 'null';
+            if (aggregationType === 'count') {
+                defaultValue = '0';
+            }
+            else if (aggregationType === 'exists') {
+                defaultValue = 'false';
+            }
+            else {
+                defaultValue = 'null';
+            }
         }
         else if (this.flattenResultType) {
             // Array aggregation for toNumberList/toStringList
@@ -5550,12 +5613,16 @@ class CollectionQueryBuilder {
         // 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];
+        // Include selectMany joins in both all and selector navigation joins
+        // selectMany joins are structural (from flattening) and needed by both CTE and LATERAL
+        const allNavigationJoins = [...this.navigationPath, ...this.selectManyJoins, ...navigationJoins];
+        const allSelectorJoins = [...this.selectManyJoins, ...navigationJoins];
         // Step 6: Build CollectionAggregationConfig object
         const config = {
             relationName: this.relationName,
             targetTable: this.targetTable,
             foreignKey: this.foreignKey,
+            foreignKeyTableAlias: this.foreignKeyTableAlias,
             sourceTable: this.sourceTable,
             parentIds, // Pass parent IDs for temp table strategy
             selectedFields: selectedFieldConfigs,
@@ -5575,7 +5642,7 @@ class CollectionQueryBuilder {
             // Use the reserved counter for LATERAL strategy, otherwise increment as before
             counter: reservedCounter !== undefined ? reservedCounter : context.cteCounter++,
             navigationJoins: allNavigationJoins.length > 0 ? allNavigationJoins : undefined,
-            selectorNavigationJoins: navigationJoins.length > 0 ? navigationJoins : undefined,
+            selectorNavigationJoins: allSelectorJoins.length > 0 ? allSelectorJoins : undefined,
         };
         // Step 6: Call the strategy
         const result = strategy.buildAggregation(config, context, client);