@trieb.work/nextjs-turbo-redis-cache 1.16.0 → 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/integration/cache-components/redis-kill-reconnect.test.ts

@@ -50,6 +50,12 @@ describe('redis kill/reconnect end-to-end (both handlers)', () => {
 
       const res = await runNode(script, 180_000);
 
+      if (res.code !== 0) {
+        console.error('Script exited with code', res.code);
+        console.error('stdout:', res.stdout);
+        console.error('stderr:', res.stderr);
+      }
+
       expect(res.code).toBe(0);
       expect(res.stdout).toContain('OK');
       expect(res.stderr).not.toContain('Socket already opened');

package/test/vitest/integration/cache-components/scripts/redis-kill-reconnect.ts

@@ -92,8 +92,9 @@ async function main() {
     if (r.code !== 0) throw new Error(`podman run failed: ${r.stderr}`);
   }
 
-  // IMPORTANT: importing from "src" will eagerly instantiate the singleton via `redisCacheHandler`.
-  // So we must set env BEFORE importing.
+  // Set env BEFORE importing in case any module-level code reads REDIS_URL.
+  // (With lazy init the singleton is no longer created at import time, but
+  //  setting env first is still good practice.)
   process.env.REDIS_URL = `redis://127.0.0.1:${port}`;
   process.env.VERCEL_URL = `e2e-${name}-`;
 
@@ -112,9 +113,6 @@ async function main() {
       // allow redis client to reconnect; this scenario is about stability under restart
       reconnectStrategy: (retries) => Math.min(50 + retries * 50, 500),
     },
-    clientOptions: {
-      disableOfflineQueue: true,
-    } as any,
   });
 
   const cacheComponentsClient = (cacheComponentsHandler as any).client as {

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

@@ -4,7 +4,7 @@ import type { CreateRedisStringsHandlerOptions } from '../../../src/index';
 import RedisStringsHandler from '../../../src/RedisStringsHandler';
 
 vi.mock('redis', () => {
-  const createClient = () => {
+  const createClient = vi.fn(() => {
     return {
       isReady: true,
       on: vi.fn(),
@@ -31,7 +31,7 @@ vi.mock('redis', () => {
       unlink: vi.fn(async () => 1),
       set: vi.fn(async () => 'OK'),
     };
-  };
+  });
   return {
     createClient,
     commandOptions: vi.fn((opts) => opts),
@@ -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', () => {
@@ -96,3 +124,50 @@ describe('Public exports', () => {
     expect(_typeCheck.keyPrefix).toBe('test');
   });
 });
+
+describe('redisCacheHandler lazy proxy', () => {
+  it('does not construct a Redis connection on import', async () => {
+    vi.resetModules();
+    const { createClient } = await import('redis');
+    vi.mocked(createClient).mockClear();
+
+    // Importing the module should NOT trigger a Redis connection
+    await import('../../../src');
+
+    expect(vi.mocked(createClient)).not.toHaveBeenCalled();
+  });
+
+  it('has trap returns true for known methods without constructing the handler', async () => {
+    vi.resetModules();
+    const { createClient } = await import('redis');
+    vi.mocked(createClient).mockClear();
+
+    const { redisCacheHandler } = await import('../../../src');
+
+    expect('getExpiration' in redisCacheHandler).toBe(true);
+    expect('get' in redisCacheHandler).toBe(true);
+    expect('set' in redisCacheHandler).toBe(true);
+    expect('refreshTags' in redisCacheHandler).toBe(true);
+    expect('updateTags' in redisCacheHandler).toBe(true);
+
+    expect(vi.mocked(createClient)).not.toHaveBeenCalled();
+  });
+
+  it('method call delegates to the singleton and binds correctly', async () => {
+    vi.resetModules();
+    const { createClient } = await import('redis');
+    vi.mocked(createClient).mockClear();
+
+    const { redisCacheHandler } = await import('../../../src');
+
+    // Accessing a method triggers construction and delegates to the real handler
+    const getFn = redisCacheHandler.get;
+    expect(typeof getFn).toBe('function');
+    expect(vi.mocked(createClient)).toHaveBeenCalledTimes(1);
+
+    // Subsequent accesses reuse the same singleton (no extra construction)
+    const getFn2 = redisCacheHandler.get;
+    expect(vi.mocked(createClient)).toHaveBeenCalledTimes(1);
+    expect(typeof getFn2).toBe('function');
+  });
+});

package/test/vitest/unit/reconnect-socket-already-opened.test.ts

@@ -1,5 +1,58 @@
 import { describe, it, expect, vi, afterEach } from 'vitest';
 
+vi.mock('redis', () => ({
+  createClient: vi.fn(() => {
+    const listeners = new Map<string, Function[]>();
+    const client = {
+      isOpen: false,
+      isReady: false,
+      on: vi.fn((event: string, cb: Function) => {
+        if (!listeners.has(event)) listeners.set(event, []);
+        listeners.get(event)!.push(cb);
+      }),
+      emit: vi.fn((event: string, ...args: unknown[]) => {
+        (listeners.get(event) ?? []).forEach((cb) => cb(...args));
+      }),
+      connect: vi.fn(async () => undefined),
+      disconnect: vi.fn(),
+      quit: vi.fn(async () => undefined),
+      duplicate: vi.fn(() => ({
+        connect: vi.fn(async () => undefined),
+        subscribe: vi.fn(async () => undefined),
+        on: vi.fn(),
+        quit: vi.fn(async () => undefined),
+        configGet: vi.fn(async () => ({ 'notify-keyspace-events': 'Exe' })),
+      })),
+      get: vi.fn(async () => null),
+      hScan: vi.fn(async () => ({ cursor: 0, tuples: [] })),
+      scan: vi.fn(async () => ({ cursor: 0, keys: [] })),
+      hSet: vi.fn(async () => 1),
+      hDel: vi.fn(async () => 1),
+      publish: vi.fn(async () => 1),
+      unlink: vi.fn(async () => 1),
+      set: vi.fn(async () => 'OK'),
+    };
+    return client;
+  }),
+  commandOptions: vi.fn((opts) => opts),
+}));
+
+vi.mock('../../../src/SyncedMap', () => {
+  class SyncedMap {
+    waitUntilReady = vi.fn(async () => undefined);
+    get = vi.fn(() => undefined);
+    set = vi.fn(async () => undefined);
+    delete = vi.fn(async () => undefined);
+    entries = vi.fn(function* () {
+      return;
+    });
+
+    constructor() {}
+  }
+
+  return { SyncedMap };
+});
+
 /**
  * Deterministic regression test for:
  *   "Failed to reconnect RedisCacheComponentsHandler client after connection loss: Error: Socket already opened"
@@ -34,6 +87,9 @@ describe('RedisCacheComponentsHandler reconnect logic', () => {
 
     const client = (handler as any).client;
 
+    // Clear the initial connect() call from the constructor.
+    vi.mocked(client.connect).mockClear();
+
     // Simulate a connection-loss situation where the socket is still open.
     Object.defineProperty(client, 'isOpen', { value: true });
     Object.defineProperty(client, 'isReady', { value: false });