fix(query-orchestrator): Return result when refreshKey changes during…

packages/cubejs-query-orchestrator/src/orchestrator/PreAggregationLoader.ts

@@ -332,14 +332,33 @@ export class PreAggregationLoader {
         return mostRecentResult();
       } else if (versionEntry.content_version !== newVersionEntry.content_version) {
         if (this.waitForRenew) {
-          this.logger('Waiting for pre-aggregation renew', {
-            preAggregation: this.preAggregation,
-            requestId: this.requestId,
-            queryKey: this.preAggregationQueryKey(invalidationKeys),
-            newVersionEntry
-          });
-          await this.executeInQueue(invalidationKeys, this.priority(0), newVersionEntry);
-          return mostRecentResult();
+          const refreshKeyRenewalThreshold = (this.queryCache.options.refreshKeyRenewalThreshold || 120) * 1000;
+          const buildAge = nowTimestamp(client) - versionEntry.last_updated_at;
+
+          if (
+            versionEntry.structure_version === newVersionEntry.structure_version &&
+            buildAge < refreshKeyRenewalThreshold
+          ) {
+            this.logger('Pre-aggregation recently built, refreshing in background', {
+              preAggregation: this.preAggregation,
+              requestId: this.requestId,
+              queryKey: this.preAggregationQueryKey(invalidationKeys),
+              newVersionEntry,
+              buildAge,
+              refreshKeyRenewalThreshold,
+            });
+            this.scheduleRefresh(invalidationKeys, newVersionEntry);
+            // Falls through to return existing versionEntry
+          } else {
+            this.logger('Waiting for pre-aggregation renew', {
+              preAggregation: this.preAggregation,
+              requestId: this.requestId,
+              queryKey: this.preAggregationQueryKey(invalidationKeys),
+              newVersionEntry,
+            });
+            await this.executeInQueue(invalidationKeys, this.priority(0), newVersionEntry);
+            return mostRecentResult();
+          }
         } else {
           this.scheduleRefresh(invalidationKeys, newVersionEntry);
         }

packages/cubejs-query-orchestrator/src/orchestrator/QueryCache.ts

@@ -301,6 +301,7 @@ export class QueryCache {
           requestId: queryBody.requestId,
           dataSource: queryBody.dataSource,
           persistent: queryBody.persistent,
+          skipRefreshKeyWaitForRenew: true,
         }
       );
     }
@@ -1003,14 +1004,11 @@ export class QueryCache {
         primaryQuery,
         renewCycle
       });
-      if (
-        renewalKey && (
-          !renewalThreshold ||
-          !parsedResult.time ||
-          renewedAgo > renewalThreshold * 1000 ||
-          parsedResult.renewalKey !== renewalKey
-        )
-      ) {
+      const isExpired = !renewalThreshold || !parsedResult.time || renewedAgo > renewalThreshold * 1000;
+      const isKeyMismatch = renewalKey && parsedResult.renewalKey !== renewalKey;
+
+      if (renewalKey && isExpired) {
+        // Cache is expired — must fetch new data
         if (options.waitForRenew) {
           this.logger('Waiting for renew', { cacheKey, renewalThreshold, requestId: options.requestId, spanId, primaryQuery, renewCycle });
           return fetchNew();
@@ -1022,6 +1020,21 @@ export class QueryCache {
             }
           });
         }
+      } else if (isKeyMismatch) {
+        // Key mismatch but cache is NOT expired
+        if (options.waitForRenew && renewCycle) {
+          // Background renew cycle: block on fetch
+          this.logger('Waiting for renew (key mismatch, renew cycle)', { cacheKey, renewalThreshold, requestId: options.requestId, spanId, primaryQuery, renewCycle });
+          return fetchNew();
+        } else {
+          // User request OR non-blocking: return cached, refresh in background
+          this.logger('Renewing key in background (key mismatch, not expired)', { cacheKey, renewalThreshold, requestId: options.requestId, spanId, primaryQuery, renewCycle });
+          fetchNew().catch(e => {
+            if (!(e instanceof ContinueWaitError)) {
+              this.logger('Error renewing', { cacheKey, error: e.stack || e, requestId: options.requestId, spanId, primaryQuery, renewCycle });
+            }
+          });
+        }
       }
       this.logger('Using cache for', { cacheKey, requestId: options.requestId, spanId, primaryQuery, renewCycle });
       if (options.useInMemory && renewedAgo + inMemoryCacheDisablePeriod <= renewalThreshold * 1000) {