linkgress-orm 0.4.13 → 0.4.14

package/dist/query/query-builder.js

@@ -479,6 +479,7 @@ class SelectQueryBuilder {
         this.manualJoins = [];
         this.joinCounter = 0;
         this.isDistinct = false;
+        this._includeCountOver = false;
         this.ctes = []; // Track CTEs attached to this query
         this.schema = schema;
         this.client = client;
@@ -1053,6 +1054,57 @@ class SelectQueryBuilder {
             : await this.client.query(sql, params);
         return parseInt(result.rows[0]?.count ?? '0', 10);
     }
+    /**
+     * Execute query and return results with total count using COUNT(*) OVER().
+     * Useful for pagination - gets data and total count in a single query.
+     */
+    async countOver() {
+        this._includeCountOver = true;
+        try {
+            const options = this.executor?.getOptions();
+            const tracer = new db_context_1.TimeTracer(options?.traceTime ?? false, options?.logger);
+            tracer.startPhase('queryBuild');
+            const context = tracer.trace('createContext', () => ({
+                ctes: new Map(),
+                cteCounter: 0,
+                paramCounter: 1,
+                allParams: [],
+                collectionStrategy: this.collectionStrategy,
+                executor: this.executor,
+            }));
+            const mockRow = tracer.trace('createMockRow', () => this._createMockRow());
+            const selectionResult = tracer.trace('evaluateSelector', () => this.selector(mockRow));
+            const { sql, params, nestedPaths } = tracer.trace('buildQuery', () => this.buildQuery(selectionResult, context));
+            tracer.endPhase();
+            tracer.startPhase('queryExecution');
+            const result = await tracer.traceAsync('executeQuery', async () => this.executor
+                ? await this.executor.query(sql, params)
+                : await this.client.query(sql, params), { rowCount: 'pending' });
+            tracer.endPhase();
+            // Extract totalCount from first raw row before transformation
+            // PostgreSQL COUNT() OVER() returns bigint (string in pg driver)
+            const totalCount = result.rows.length > 0 ? parseInt(result.rows[0].__countOver ?? '0', 10) : 0;
+            // Strip __countOver from raw rows before processing
+            for (const row of result.rows) {
+                delete row.__countOver;
+            }
+            if (this.executor?.getOptions().rawResult) {
+                return { data: result.rows, totalCount };
+            }
+            tracer.startPhase('resultProcessing');
+            let rows = result.rows;
+            if (nestedPaths.size > 0) {
+                rows = tracer.trace('reconstructNestedObjects', () => rows.map(row => this.reconstructNestedObjects(row, nestedPaths)), { rowCount: rows.length });
+            }
+            const data = tracer.trace('transformResults', () => this.transformResults(rows, selectionResult), { rowCount: rows.length });
+            tracer.endPhase();
+            tracer.logSummary(data.length);
+            return { data: data, totalCount };
+        }
+        finally {
+            this._includeCountOver = false;
+        }
+    }
     /**
      * Check if any rows match the query
      * More efficient than count() > 0 as it can stop after finding one row
@@ -3620,6 +3672,10 @@ ${joinClauses.join('\n')}`;
                 fromClause += `\n${joinClause}`;
             }
         }
+        // Add COUNT(*) OVER() for countOver() support
+        if (this._includeCountOver) {
+            selectParts.push('COUNT(*) OVER() as "__countOver"');
+        }
         // Add DISTINCT if needed
         const distinctClause = this.isDistinct ? 'DISTINCT ' : '';
         finalQuery += `SELECT ${distinctClause}${selectParts.join(', ')}\n${fromClause}\n${whereClause}\n${orderByClause}\n${limitClause}`.trim();