linkgress-orm 0.4.60 → 0.4.62

package/dist/query/query-builder.js

@@ -710,6 +710,16 @@ class SelectQueryBuilder {
         }
         return this;
     }
+    /**
+     * The CTEs attached to this query through `.with(...)` (or auto-attached by
+     * `joinFilter(cte, ...)`). Read by {@link UnionQueryBuilder.buildSql}, which
+     * hoists them to statement level so a CTE declared on one union leg is
+     * visible to all of them.
+     * @internal
+     */
+    _getAttachedCtes() {
+        return this.ctes;
+    }
     /**
      * Limit results
      */
@@ -1345,6 +1355,9 @@ class SelectQueryBuilder {
             allParams: context.params,
             collectionStrategy: this.collectionStrategy,
             executor: this.executor,
+            // CTEs the union already declared ahead of the whole statement — this leg
+            // must not re-declare them (nor re-push their params).
+            hoistedCteNames: context.hoistedCteNames,
         };
         const mockRow = this._createMockRow();
         const selectionResult = this.selector(mockRow);
@@ -4185,7 +4198,7 @@ ${joinClauses.join('\n')}`;
         let whereClause = '';
         if (this.whereCond) {
             const condBuilder = new conditions_1.ConditionBuilder();
-            const { sql, params, placeholders, paramCounter: newParamCounter } = condBuilder.build(this.whereCond, context.paramCounter, context.placeholders);
+            const { sql, params, placeholders, paramCounter: newParamCounter } = condBuilder.build(this.whereCond, context.paramCounter, context.placeholders, context.hoistedCteNames);
             whereClause = `WHERE ${sql}`;
             context.paramCounter = newParamCounter; // Use returned counter (handles both params and placeholders)
             context.allParams.push(...params);
@@ -4321,8 +4334,14 @@ ${joinClauses.join('\n')}`;
      * @internal
      */
     buildQueryCore(selection, context, includeOrderLimitOffset = true) {
-        // Handle user-defined CTEs first - their params need to come before main query params
+        // Handle user-defined CTEs first - their params need to come before main query params.
+        // A CTE the enclosing builder already hoisted to statement level (UNION) has had both
+        // its params and its WITH entry contributed there; pushing them again would duplicate
+        // the params and shift every placeholder in this leg.
         for (const cte of this.ctes) {
+            if (context.hoistedCteNames?.has(cte.name)) {
+                continue;
+            }
             context.allParams.push(...cte.params);
             context.paramCounter += cte.params.length;
         }
@@ -4532,7 +4551,7 @@ ${joinClauses.join('\n')}`;
         let whereClause = '';
         if (this.whereCond) {
             const condBuilder = new conditions_1.ConditionBuilder();
-            const { sql, params, placeholders, paramCounter: newParamCounter } = condBuilder.build(this.whereCond, context.paramCounter, context.placeholders);
+            const { sql, params, placeholders, paramCounter: newParamCounter } = condBuilder.build(this.whereCond, context.paramCounter, context.placeholders, context.hoistedCteNames);
             whereClause = `WHERE ${sql}`;
             context.paramCounter = newParamCounter;
             context.allParams.push(...params);
@@ -4569,6 +4588,10 @@ ${joinClauses.join('\n')}`;
         let finalQuery = '';
         const allCtes = [];
         for (const cte of this.ctes) {
+            // Hoisted to statement level by the enclosing UNION - declared there, not here.
+            if (context.hoistedCteNames?.has(cte.name)) {
+                continue;
+            }
             allCtes.push(`"${cte.name}" AS ${cte.materialized ? 'MATERIALIZED ' : ''}(${cte.query})`);
         }
         if (context.ctes.size > 0) {
@@ -5194,7 +5217,7 @@ ${joinClauses.join('\n')}`;
         let whereClause = '';
         if (this.whereCond) {
             const condBuilder = new conditions_1.ConditionBuilder();
-            const { sql, params, placeholders, paramCounter: newParamCounter } = condBuilder.build(this.whereCond, context.paramCounter, context.placeholders);
+            const { sql, params, placeholders, paramCounter: newParamCounter } = condBuilder.build(this.whereCond, context.paramCounter, context.placeholders, context.hoistedCteNames);
             whereClause = `WHERE ${sql}`;
             context.paramCounter = newParamCounter; // Use returned counter (handles both params and placeholders)
             context.allParams.push(...params);
@@ -5251,6 +5274,18 @@ ${joinClauses.join('\n')}`;
      * Build aggregate query (count or exists)
      */
     buildAggregateQuery(context, type) {
+        // User-defined CTEs first, exactly as buildQuery does: their params occupy the
+        // opening slots of the statement because DbCte bodies carry placeholders numbered
+        // from $1. Without this, `.with(cte).count()` / `.exists()` dropped the WITH clause
+        // entirely and PostgreSQL answered `relation "<cte>" does not exist` (42P01) for any
+        // query whose WHERE referenced the CTE.
+        for (const cte of this.ctes) {
+            if (context.hoistedCteNames?.has(cte.name)) {
+                continue;
+            }
+            context.allParams.push(...cte.params);
+            context.paramCounter += cte.params.length;
+        }
         // Detect navigation property joins from WHERE condition
         const joins = [];
         this.detectAndAddJoinsFromCondition(this.whereCond, joins);
@@ -5258,7 +5293,7 @@ ${joinClauses.join('\n')}`;
         let whereClause = '';
         if (this.whereCond) {
             const condBuilder = new conditions_1.ConditionBuilder();
-            const { sql, params, placeholders, paramCounter: newParamCounter } = condBuilder.build(this.whereCond, context.paramCounter, context.placeholders);
+            const { sql, params, placeholders, paramCounter: newParamCounter } = condBuilder.build(this.whereCond, context.paramCounter, context.placeholders, context.hoistedCteNames);
             whereClause = `WHERE ${sql}`;
             context.paramCounter = newParamCounter; // Use returned counter (handles both params and placeholders)
             context.allParams.push(...params);
@@ -5314,9 +5349,24 @@ ${joinClauses.join('\n')}`;
         const selectClause = type === 'count'
             ? 'SELECT COUNT(*) as count'
             : 'SELECT EXISTS(SELECT 1';
+        // WITH clause - same assembly as buildQuery, so an aggregate can reference the
+        // CTEs attached to the query it is aggregating.
+        const allCtes = [];
+        for (const cte of this.ctes) {
+            if (context.hoistedCteNames?.has(cte.name)) {
+                continue;
+            }
+            allCtes.push(`"${cte.name}" AS ${cte.materialized ? 'MATERIALIZED ' : ''}(${cte.query})`);
+        }
+        if (context.ctes.size > 0) {
+            for (const [cteName, { sql: cteSql }] of context.ctes.entries()) {
+                allCtes.push(`"${cteName}" AS (${cteSql})`);
+            }
+        }
+        const withClause = allCtes.length > 0 ? `WITH ${allCtes.join(', ')}\n` : '';
         const sql = type === 'count'
-            ? `${selectClause}\n${fromClause}\n${whereClause}`.trim()
-            : `${selectClause}\n${fromClause}\n${whereClause})`.trim();
+            ? `${withClause}${selectClause}\n${fromClause}\n${whereClause}`.trim()
+            : `${withClause}${selectClause}\n${fromClause}\n${whereClause})`.trim();
         return {
             sql,
             params: context.allParams,
@@ -5355,6 +5405,11 @@ ${joinClauses.join('\n')}`;
                 paramCounter: outerContext.paramCounter,
                 allParams: outerContext.params,
                 placeholders: outerContext.placeholders, // Pass placeholders through for prepared statements
+                // CTEs an enclosing builder already declared at statement level stay
+                // declared for anything NESTED in this subquery too. Without this the
+                // signal dies at the subquery boundary and a CTE-rooted subquery one
+                // level deeper re-declares (and re-materializes) a CTE it was handed.
+                hoistedCteNames: outerContext.hoistedCteNames,
                 executor: this.executor,
             };
             // Analyze the selector to extract nested queries
@@ -6089,7 +6144,7 @@ class CollectionQueryBuilder {
         }
         if (this.whereCond) {
             const condBuilder = new conditions_1.ConditionBuilder();
-            const { sql: condSql, params, placeholders, paramCounter } = condBuilder.build(this.whereCond, context.paramCounter, context.placeholders);
+            const { sql: condSql, params, placeholders, paramCounter } = condBuilder.build(this.whereCond, context.paramCounter, context.placeholders, context.hoistedCteNames);
             context.paramCounter = paramCounter;
             context.params.push(...params);
             if (placeholders) {
@@ -6610,7 +6665,7 @@ class CollectionQueryBuilder {
         let whereParams;
         if (this.whereCond) {
             const condBuilder = new conditions_1.ConditionBuilder();
-            const { sql, params, placeholders, paramCounter: newParamCounter } = condBuilder.build(this.whereCond, context.paramCounter, context.placeholders);
+            const { sql, params, placeholders, paramCounter: newParamCounter } = condBuilder.build(this.whereCond, context.paramCounter, context.placeholders, context.hoistedCteNames);
             whereClause = sql;
             whereParams = params;
             context.paramCounter = newParamCounter; // Use returned counter (handles both params and placeholders)