@trieb.work/nextjs-turbo-redis-cache 1.16.1 → 1.16.2

package/src/RedisStringsHandler.ts

@@ -444,21 +444,32 @@ export default class RedisStringsHandler {
         'assertClientIsReady called more than 10 times without being ready.',
       );
     }
-    await Promise.race([
-      Promise.all([
-        this.sharedTagsMap.waitUntilReady(),
-        this.revalidatedTagsMap.waitUntilReady(),
-      ]),
-      new Promise((_, reject) =>
-        setTimeout(() => {
-          reject(
-            new Error(
-              'assertClientIsReady: Timeout waiting for Redis maps to be ready',
-            ),
-          );
-        }, 30_000),
-      ),
-    ]);
+    let readyTimeout: ReturnType<typeof setTimeout> | undefined;
+    try {
+      await Promise.race([
+        Promise.all([
+          this.sharedTagsMap.waitUntilReady(),
+          this.revalidatedTagsMap.waitUntilReady(),
+        ]),
+        new Promise((_, reject) => {
+          readyTimeout = setTimeout(() => {
+            reject(
+              new Error(
+                'assertClientIsReady: Timeout waiting for Redis maps to be ready',
+              ),
+            );
+          }, 30_000);
+        }),
+      ]);
+    } finally {
+      // Always clear the timeout: once the race is won (the common case after
+      // the initial sync), the timer would otherwise stay pending for the full
+      // 30s. Timers capture the ambient async context (AsyncLocalStorage),
+      // so in a Next.js server every leaked timer pins the request's store —
+      // and with it the whole response object graph — for at least 30s on
+      // every single cache operation.
+      clearTimeout(readyTimeout);
+    }
     this.clientReadyCalls = 0;
     if (!this.client.isReady) {
       throw new Error(

package/test/vitest/unit/index.test.ts

@@ -85,6 +85,34 @@ describe('RedisStringsHandler', () => {
     expect(res).toBeNull();
     expect(consoleErrorSpy).not.toHaveBeenCalled();
   });
+
+  it('does not leave the readiness timeout timer pending after an operation', async () => {
+    vi.useFakeTimers();
+    try {
+      const handler = new RedisStringsHandler({
+        redisUrl: 'redis://localhost:6379',
+        keyPrefix: 'test:',
+        database: 0,
+        getTimeoutMs: 1,
+        redisGetDeduplication: false,
+      });
+
+      const timersBefore = vi.getTimerCount();
+      await handler.get('missing-key', {
+        kind: 'APP_PAGE',
+        isRoutePPREnabled: false,
+        isFallback: false,
+      });
+
+      // assertClientIsReady() races waitUntilReady() against a 30s timeout;
+      // the timer must not stay pending once the race is settled, because
+      // pending timers retain the ambient async context (and with it, in a
+      // Next.js server, the whole per-request object graph).
+      expect(vi.getTimerCount()).toBe(timersBefore);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
 });
 
 describe('Public exports', () => {