linkgress-orm 0.4.12 → 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
@@ -2712,14 +2764,22 @@ ${joinClauses.join('\n')}`;
                 // If the value is already a FieldRef
                 if (value && typeof value === 'object' && '__fieldName' in value && '__dbColumnName' in value) {
                     if (preserveOriginal) {
-                        // For WHERE: preserve original column name, table alias, and mapper
+                        // For WHERE: preserve original column name, table alias, mapper, and navigation aliases
                         // This ensures WHERE references the actual database column with proper type conversion
-                        return {
+                        // and can resolve intermediate JOINs for multi-level navigation
+                        const fieldRef = {
                             __fieldName: prop,
                             __dbColumnName: value.__dbColumnName,
                             __tableAlias: value.__tableAlias,
                             __mapper: value.__mapper, // Preserve mapper for toDriver in conditions
                         };
+                        if (value.__navigationAliases) {
+                            fieldRef.__navigationAliases = value.__navigationAliases;
+                        }
+                        if (value.__sourceTable) {
+                            fieldRef.__sourceTable = value.__sourceTable;
+                        }
+                        return fieldRef;
                     }
                     else {
                         // For ORDER BY: use the alias (property name) as the column name
@@ -3009,7 +3069,7 @@ ${joinClauses.join('\n')}`;
                 if (tableAlias && tableAlias !== this.schema.name) {
                     allTableAliases.add(tableAlias);
                 }
-                // Also collect intermediate navigation aliases for multi-level navigation
+                // Also collect intermediate navigation aliases for multi-level navigation (e.g., task.level.name)
                 if ('__navigationAliases' in value && Array.isArray(value.__navigationAliases)) {
                     for (const navAlias of value.__navigationAliases) {
                         if (navAlias && navAlias !== this.schema.name) {
@@ -3028,6 +3088,7 @@ ${joinClauses.join('\n')}`;
                             allTableAliases.add(tableAlias);
                         }
                     }
+                    // Also collect intermediate navigation aliases for multi-level navigation
                     if ('__navigationAliases' in fieldRef && Array.isArray(fieldRef.__navigationAliases)) {
                         for (const navAlias of fieldRef.__navigationAliases) {
                             if (navAlias && navAlias !== this.schema.name) {
@@ -3611,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();
@@ -3967,10 +4032,10 @@ ${joinClauses.join('\n')}`;
                         fieldConfigs.push({ key, type: 7 /* FieldType.FIELD_REF_NO_MAPPER */, value });
                     }
                     else {
-                        // Not in base table schema - check if FieldRef carries its own mapper (navigation property)
-                        const directMapper = value.__mapper;
-                        if (directMapper && typeof directMapper.fromDriver === 'function') {
-                            fieldConfigs.push({ key, type: 6 /* FieldType.FIELD_REF_MAPPER */, value, mapper: directMapper });
+                        // Not in root schema cache — check FieldRef's own mapper (from navigation properties)
+                        const fieldMapper = value.__mapper;
+                        if (fieldMapper && typeof fieldMapper.fromDriver === 'function') {
+                            fieldConfigs.push({ key, type: 6 /* FieldType.FIELD_REF_MAPPER */, value, mapper: fieldMapper });
                         }
                         else {
                             fieldConfigs.push({ key, type: 8 /* FieldType.SIMPLE */, value });