@trieb.work/nextjs-turbo-redis-cache 1.15.0 → 1.16.0

package/test/vitest/integration/cache-components/scripts/redis-subscriber-outage.ts

@@ -0,0 +1,379 @@
+/**
+ * Reproduces issue #86: Memory grows unbounded and process never recovers
+ * after a short Redis outage — subscriber reconnect loop.
+ *
+ * This script creates two RedisStringsHandler instances (A and B) sharing
+ * the same keyPrefix so their SyncedMaps communicate via Redis PubSub.
+ * It also creates a CacheComponentsHandler singleton (C).
+ *
+ * Test sequence:
+ *   1. Verify PubSub sync works before outage (A.set → B.sharedTagsMap.get)
+ *   2. Verify subscriber clients have error listeners before outage
+ *   3. Kill Redis, call get() 50× during outage (heap-growth probe)
+ *   4. Wait 3 s for error handlers to fire and fail
+ *   5. Count duplicate() calls during outage (client-leak probe)
+ *   6. Restart Redis, wait for main clients to reconnect
+ *   7. Verify PubSub sync works after outage (EXPECTED TO FAIL — the bug)
+ *   8. Verify subscriber clients still have error listeners (EXPECTED TO FAIL)
+ *   9. Verify get() works after Redis restart
+ *
+ * Output: lines of `RESULT|<name>|PASS|<detail>` or `RESULT|<name>|FAIL|<detail>`
+ * followed by `RESULTS_JSON|<json>` on the last line.
+ */
+
+import {
+  detectContainerRuntime,
+  getFreePort,
+  sh,
+  sleep,
+  startRedis,
+  waitUntil,
+  type TestResult,
+} from './redis-test-helpers';
+
+// ---------------------------------------------------------------------------
+// Result tracking
+// ---------------------------------------------------------------------------
+
+const results: TestResult[] = [];
+
+function record(name: string, pass: boolean, detail: string) {
+  results.push({ name, pass, detail });
+  process.stdout.write(`RESULT|${name}|${pass ? 'PASS' : 'FAIL'}|${detail}\n`);
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+async function main() {
+  const runtime = detectContainerRuntime();
+  const name = `redis-e2e-${Math.random().toString(36).slice(2, 8)}`;
+  const port = await getFreePort();
+
+  // cleanup any stale container
+  sh(runtime, ['rm', '-f', name]);
+
+  // 1. Start Redis
+  startRedis(runtime, name, port);
+
+  // Set env vars BEFORE importing so the CacheComponentsHandler singleton
+  // picks up the correct Redis URL.
+  process.env.REDIS_URL = `redis://127.0.0.1:${port}`;
+  process.env.VERCEL_URL = `e2e-${name}-`;
+
+  // Import handlers (dynamic import ensures env vars are set first)
+  const { getRedisCacheComponentsHandler } = await import(
+    '../../../../../src/CacheComponentsHandler'
+  );
+  const { default: RedisStringsHandler } = await import(
+    '../../../../../src/RedisStringsHandler'
+  );
+
+  const socketOpts = {
+    connectTimeout: 2_000,
+    reconnectStrategy: (retries: number) => Math.min(50 + retries * 50, 500),
+  };
+
+  // 2. Create handler A (writer) and B (reader) with same keyPrefix
+  const handlerA = new RedisStringsHandler({
+    redisUrl: `redis://127.0.0.1:${port}`,
+    socketOptions: socketOpts,
+    keyPrefix: `e2e-${name}-`,
+    killContainerOnErrorThreshold: 0, // disabled — same as issue #86 config
+  } as any);
+
+  const handlerB = new RedisStringsHandler({
+    redisUrl: `redis://127.0.0.1:${port}`,
+    socketOptions: socketOpts,
+    keyPrefix: `e2e-${name}-`,
+    killContainerOnErrorThreshold: 0,
+  } as any);
+
+  // CacheComponentsHandler singleton (created on import via redisCacheHandler)
+  const handlerC = getRedisCacheComponentsHandler();
+
+  // 3. Monkey-patch A's client.duplicate to count calls (client-leak probe)
+  const clientA = (handlerA as any).client;
+  const originalDuplicate = clientA.duplicate.bind(clientA);
+  let duplicateCount = 0;
+  (clientA as any).duplicate = function (...args: any[]) {
+    duplicateCount++;
+    return originalDuplicate(...args);
+  };
+
+  // 4. Wait for all main clients to be ready
+  await waitUntil(async () => (handlerA as any).client.isReady, 20_000);
+  await waitUntil(async () => (handlerB as any).client.isReady, 20_000);
+  await waitUntil(async () => (handlerC as any).client.isReady, 20_000);
+
+  // Record initial duplicate count (3 SyncedMaps × 1 duplicate each = 3)
+  const initialDuplicateCount = duplicateCount;
+
+  // 5. Test: PubSub sync works before outage
+  await handlerA.set(
+    'key1',
+    {
+      kind: 'FETCH',
+      data: {
+        headers: {},
+        body: Buffer.from('hello').toString('base64'),
+        status: 200,
+        url: 'https://example.com/e2e',
+      },
+      revalidate: 10,
+    },
+    { isRoutePPREnabled: false, isFallback: false, tags: ['tag1'] },
+  );
+
+  const pubsubInitial = await waitUntil(async () => {
+    const tags = (handlerB as any).sharedTagsMap.get('key1');
+    return !!tags && tags.length === 1 && tags[0] === 'tag1';
+  }, 5_000);
+
+  record(
+    'pubsub-initial-strings',
+    pubsubInitial,
+    pubsubInitial
+      ? 'sync received — B.sharedTagsMap has key1'
+      : 'B.sharedTagsMap never received sync for key1',
+  );
+
+  // 6. Test: Error listeners present before outage
+  const subB = (handlerB as any).sharedTagsMap.subscriberClient;
+  const subC = (handlerC as any).revalidatedTagsMap.subscriberClient;
+  const initListenerB = subB?.listenerCount?.('error') ?? -1;
+  const initListenerC = subC?.listenerCount?.('error') ?? -1;
+
+  record(
+    'error-listener-initial',
+    initListenerB >= 1 && initListenerC >= 1,
+    `B.sharedTagsMap.subscriber listenerCount(error)=${initListenerB}, C.revalidatedTagsMap.subscriber listenerCount(error)=${initListenerC}`,
+  );
+
+  // 7. Kill Redis
+  sh(runtime, ['stop', '-t', '0', name], { timeoutMs: 30_000 });
+
+  // 8. Test: get() returns null during outage (symptom verification)
+  // Use a key that was NOT just set() — the dedup cache seeds the return
+  // value on set(), so get('key1') would return the cached value without
+  // hitting Redis. Using a different key forces a real Redis GET which fails.
+  let getDuringOutage = false;
+  let getDuringOutageDetail = '';
+  try {
+    const result = await handlerA.get('nonexistent-during-outage', {
+      kind: 'FETCH',
+      revalidate: 10,
+      fetchUrl: 'https://example.com/e2e',
+      fetchIdx: 0,
+      tags: ['tag1'],
+      softTags: [],
+      isFallback: false,
+    });
+    getDuringOutage = result === null;
+    getDuringOutageDetail = getDuringOutage
+      ? 'returned null (expected during outage)'
+      : `returned ${typeof result}`;
+  } catch (err: any) {
+    getDuringOutageDetail = `threw: ${err?.message ?? err}`;
+  }
+  record('get-during-outage', getDuringOutage, getDuringOutageDetail);
+
+  // 9. Test: Heap growth during outage
+  const heapBefore = process.memoryUsage().heapUsed;
+  for (let i = 0; i < 50; i++) {
+    try {
+      await handlerA.get(`nonexistent-${i}`, {
+        kind: 'FETCH',
+        revalidate: 10,
+        fetchUrl: 'https://example.com/e2e',
+        fetchIdx: 0,
+        tags: ['tag1'],
+        softTags: [],
+        isFallback: false,
+      });
+    } catch {
+      // ignore
+    }
+  }
+  // Force a GC pass if --expose-gc is available so we measure retained memory
+  if (typeof (globalThis as any).gc === 'function') {
+    (globalThis as any).gc();
+  }
+  const heapAfter = process.memoryUsage().heapUsed;
+  const heapGrowthMB = (heapAfter - heapBefore) / 1024 / 1024;
+  record(
+    'heap-growth-during-outage',
+    heapGrowthMB < 50,
+    `heap grew ${heapGrowthMB.toFixed(2)} MB during 50 get() calls`,
+  );
+
+  // 10. Wait for subscriber error handlers to fire and fail
+  await sleep(3_000);
+
+  // 11. Test: Duplicate count during outage (client-leak probe)
+  // This is informational: in some scenarios quit() throws before
+  // duplicate() is reached (no leak), in others duplicate() runs but
+  // setupPubSub() throws (leaked client). Either way the subscriber
+  // is dead — the PubSub test below is the definitive check.
+  const outageDuplicates = duplicateCount - initialDuplicateCount;
+  record(
+    'duplicate-count-during-outage',
+    true, // informational — always passes, detail has the count
+    `${outageDuplicates} duplicate() calls during outage (initial=${initialDuplicateCount}, total=${duplicateCount})`,
+  );
+
+  // 12. Restart Redis
+  startRedis(runtime, name, port);
+
+  // 13. Wait for main clients to reconnect
+  const reconnectedA = await waitUntil(async () => {
+    try {
+      return (await (handlerA as any).client.ping()) === 'PONG';
+    } catch {
+      return false;
+    }
+  }, 30_000);
+
+  const reconnectedB = await waitUntil(async () => {
+    try {
+      return (await (handlerB as any).client.ping()) === 'PONG';
+    } catch {
+      return false;
+    }
+  }, 30_000);
+
+  record(
+    'main-client-reconnects',
+    reconnectedA && reconnectedB,
+    `A reconnected=${reconnectedA}, B reconnected=${reconnectedB}`,
+  );
+
+  // Wait a bit for subscriber reconnection to complete
+  await sleep(2_000);
+
+  // 14. Test: PubSub sync after outage (was the bug — should now PASS)
+  if (reconnectedA) {
+    await handlerA.set(
+      'key2',
+      {
+        kind: 'FETCH',
+        data: {
+          headers: {},
+          body: Buffer.from('world').toString('base64'),
+          status: 200,
+          url: 'https://example.com/e2e2',
+        },
+        revalidate: 10,
+      },
+      { isRoutePPREnabled: false, isFallback: false, tags: ['tag2'] },
+    );
+
+    // Give the subscriber reconnect loop time to succeed after Redis
+    // restarts. The backoff delays are 500ms, 1s, 2s, 4s, 8s, capped at 10s.
+    // After a 3s outage + restart, the subscriber may need up to ~10s to
+    // reconnect depending on which backoff slot it's in.
+    const pubsubAfter = await waitUntil(async () => {
+      const tags = (handlerB as any).sharedTagsMap.get('key2');
+      return !!tags && tags.length === 1 && tags[0] === 'tag2';
+    }, 20_000);
+
+    record(
+      'pubsub-after-outage-strings',
+      pubsubAfter,
+      pubsubAfter
+        ? 'sync received — B.sharedTagsMap has key2'
+        : 'B.sharedTagsMap never received sync for key2 (subscriber is dead)',
+    );
+  } else {
+    record(
+      'pubsub-after-outage-strings',
+      false,
+      'skipped — main client A did not reconnect',
+    );
+  }
+
+  // 15. Test: Error listener on subscriber after outage
+  // Informational: the listener may still be present on the old dead client
+  // (if quit() threw before duplicate()), or may be missing (if duplicate()
+  // ran but setupPubSub() threw). Either way, the subscriber is non-functional.
+  // The definitive test is pubsub-after-outage-strings below.
+  const subBAfter = (handlerB as any).sharedTagsMap.subscriberClient;
+  const subCAfter = (handlerC as any).revalidatedTagsMap.subscriberClient;
+  const afterListenerB = subBAfter?.listenerCount?.('error') ?? -1;
+  const afterListenerC = subCAfter?.listenerCount?.('error') ?? -1;
+  const sameClientB = subBAfter === subB;
+  const sameClientC = subCAfter === subC;
+
+  record(
+    'error-listener-after-outage',
+    true, // informational — always passes, detail has the counts
+    `B: listenerCount(error)=${afterListenerB} (was ${initListenerB}), sameClient=${sameClientB}; C: listenerCount(error)=${afterListenerC} (was ${initListenerC}), sameClient=${sameClientC}`,
+  );
+
+  // 16. Test: get() works after Redis restart (main client path)
+  // Redis was restarted with --rm (data lost), so re-seed key1 first
+  // to verify the main client can write and read after restart.
+  let getAfter = false;
+  let getAfterDetail = '';
+  try {
+    await handlerA.set(
+      'key1',
+      {
+        kind: 'FETCH',
+        data: {
+          headers: {},
+          body: Buffer.from('hello').toString('base64'),
+          status: 200,
+          url: 'https://example.com/e2e',
+        },
+        revalidate: 10,
+      },
+      { isRoutePPREnabled: false, isFallback: false, tags: ['tag1'] },
+    );
+    const result = await handlerA.get('key1', {
+      kind: 'FETCH',
+      revalidate: 10,
+      fetchUrl: 'https://example.com/e2e',
+      fetchIdx: 0,
+      tags: ['tag1'],
+      softTags: [],
+      isFallback: false,
+    });
+    getAfter = result !== null;
+    getAfterDetail = getAfter
+      ? 'returned cached value'
+      : 'returned null (cache miss or stale)';
+  } catch (err: any) {
+    getAfterDetail = `threw: ${err?.message ?? err}`;
+  }
+  record('get-after-outage', getAfter, getAfterDetail);
+
+  // 17. Test: Total duplicate count (informational)
+  record(
+    'duplicate-count-total',
+    true, // informational — always passes, detail has the count
+    `total duplicate() calls=${duplicateCount} (initial=${initialDuplicateCount}, extra=${duplicateCount - initialDuplicateCount})`,
+  );
+
+  // 18. Cleanup
+  try {
+    await (handlerA as any).client?.quit?.();
+  } catch {}
+  try {
+    await (handlerB as any).client?.quit?.();
+  } catch {}
+  try {
+    await (handlerC as any).client?.quit?.();
+  } catch {}
+  sh(runtime, ['rm', '-f', name]);
+
+  // Output JSON summary for the vitest wrapper to parse
+  process.stdout.write(`RESULTS_JSON|${JSON.stringify(results)}\n`);
+  process.exit(0);
+}
+
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

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

@@ -0,0 +1,155 @@
+import { spawn, spawnSync } from 'child_process';
+
+export type ContainerRuntime = 'podman' | 'docker';
+
+export function canRun(cmd: string): boolean {
+  const res = spawnSync(cmd, ['--version'], {
+    encoding: 'utf8',
+    timeout: 3_000,
+  });
+  return !res.error && (res.status ?? 1) === 0;
+}
+
+export function hasContainerRuntime(): boolean {
+  return canRun('podman') || canRun('docker');
+}
+
+export function detectContainerRuntime(): ContainerRuntime {
+  if (process.env.CONTAINER_RUNTIME === 'podman') return 'podman';
+  if (process.env.CONTAINER_RUNTIME === 'docker') return 'docker';
+  if (canRun('podman')) return 'podman';
+  if (canRun('docker')) return 'docker';
+  throw new Error(
+    'Neither podman nor docker is available. Install one of them or set CONTAINER_RUNTIME.',
+  );
+}
+
+export interface ShResult {
+  code: number;
+  stdout: string;
+  stderr: string;
+}
+
+export function sh(
+  cmd: string,
+  args: string[],
+  opts: { timeoutMs?: number } = {},
+): ShResult {
+  const res = spawnSync(cmd, args, {
+    encoding: 'utf8',
+    timeout: opts.timeoutMs ?? 30_000,
+  });
+  if (res.error) throw res.error;
+  return {
+    code: res.status ?? -1,
+    stdout: res.stdout ?? '',
+    stderr: res.stderr ?? '',
+  };
+}
+
+export async function sleep(ms: number): Promise<void> {
+  await new Promise((r) => setTimeout(r, ms));
+}
+
+export async function waitUntil(
+  fn: () => Promise<boolean>,
+  timeoutMs = 20_000,
+  intervalMs = 200,
+): Promise<boolean> {
+  const start = Date.now();
+  // eslint-disable-next-line no-constant-condition
+  while (true) {
+    if (await fn()) return true;
+    if (Date.now() - start > timeoutMs) return false;
+    await sleep(intervalMs);
+  }
+}
+
+export async function getFreePort(): Promise<number> {
+  const net = await import('net');
+  return new Promise((resolve, reject) => {
+    const srv = net.createServer();
+    srv.on('error', reject);
+    srv.listen(0, '127.0.0.1', () => {
+      const addr = srv.address();
+      if (!addr || typeof addr === 'string')
+        return reject(new Error('bad addr'));
+      const p = addr.port;
+      srv.close(() => resolve(p));
+    });
+  });
+}
+
+export function startRedis(
+  runtime: ContainerRuntime,
+  name: string,
+  port: number,
+): void {
+  const r = sh(
+    runtime,
+    [
+      'run',
+      '-d',
+      '--rm',
+      '--name',
+      name,
+      '-p',
+      `${port}:6379`,
+      'docker.io/redis:7-alpine',
+      'redis-server',
+      '--notify-keyspace-events',
+      'Exe',
+    ],
+    { timeoutMs: 60_000 },
+  );
+  if (r.code !== 0) throw new Error(`${runtime} run failed: ${r.stderr}`);
+}
+
+export interface TestResult {
+  name: string;
+  pass: boolean;
+  detail: string;
+}
+
+export function record(name: string, pass: boolean, detail: string): void {
+  process.stdout.write(`RESULT|${name}|${pass ? 'PASS' : 'FAIL'}|${detail}\n`);
+}
+
+export function parseResults(stdout: string): Map<string, TestResult> {
+  const map = new Map<string, TestResult>();
+  for (const line of stdout.split('\n')) {
+    const m = line.match(/^RESULT\|([^|]+)\|(PASS|FAIL)\|(.*)$/);
+    if (m) {
+      map.set(m[1], {
+        name: m[1],
+        pass: m[2] === 'PASS',
+        detail: m[3],
+      });
+    }
+  }
+  return map;
+}
+
+export function runNode(
+  script: string,
+  timeoutMs = 300_000,
+): Promise<{ code: number; stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    const p = spawn('pnpm', ['-s', 'tsx', script], {
+      stdio: ['ignore', 'pipe', 'pipe'],
+      env: { ...process.env },
+    });
+    let stdout = '';
+    let stderr = '';
+    p.stdout.on('data', (d) => (stdout += d.toString()));
+    p.stderr.on('data', (d) => (stderr += d.toString()));
+    const t = setTimeout(() => {
+      p.kill('SIGKILL');
+      reject(new Error('timeout'));
+    }, timeoutMs);
+    p.on('close', (code) => {
+      clearTimeout(t);
+      resolve({ code: code ?? -1, stdout, stderr });
+    });
+  });
+}

package/test/{integration → vitest/integration}/nextjs-cache-handler.integration.test.ts

@@ -3,13 +3,19 @@ import { ChildProcessWithoutNullStreams, spawn } from 'child_process';
 import fetch from 'node-fetch';
 import { createClient, RedisClientType } from 'redis';
 import { join } from 'path';
-import { CacheEntry } from '../../src/RedisStringsHandler';
-import { revalidate as next1503_revalidatedFetch_route } from './next-app-15-0-3/src/app/api/revalidated-fetch/route';
+import { CacheEntry } from '../../../src/RedisStringsHandler';
+import { revalidate as revalidatedFetchRouteRevalidate } from '../../nextjs-test-projects/next-app-15-4-11/src/app/api/revalidated-fetch/route';
 
 // Select which Next.js test app to use. Can be overridden via NEXT_TEST_APP env var
-// Examples: next-app-15-0-3, next-app-15-3-2, next-app-15-4-7
-const NEXT_TEST_APP = process.env.NEXT_TEST_APP || 'next-app-15-4-7';
-const NEXT_APP_DIR = join(__dirname, NEXT_TEST_APP);
+// Examples: next-app-15-4-11, next-app-16-0-11, next-app-16-2-6
+const NEXT_TEST_APP = process.env.NEXT_TEST_APP || 'next-app-15-4-11';
+const NEXT_APP_DIR = join(
+  __dirname,
+  '..',
+  '..',
+  'nextjs-test-projects',
+  NEXT_TEST_APP,
+);
 console.log('NEXT_APP_DIR', NEXT_APP_DIR);
 const NEXT_START_PORT = 3055;
 const NEXT_START_URL = `http://localhost:${NEXT_START_PORT}`;
@@ -291,9 +297,9 @@ describe('Next.js Turbo Redis Cache Integration', () => {
           const ttl = await redisClient.ttl(
             process.env.VERCEL_URL + '/api/revalidated-fetch',
           );
-          expect(ttl).toBeLessThan(2 * next1503_revalidatedFetch_route);
+          expect(ttl).toBeLessThan(2 * revalidatedFetchRouteRevalidate);
           expect(ttl).toBeGreaterThan(
-            2 * next1503_revalidatedFetch_route -
+            2 * revalidatedFetchRouteRevalidate -
               FIRST_DELAY -
               SECOND_DELAY -
               REDIS_BACKGROUND_SYNC_DELAY,
@@ -743,7 +749,7 @@ describe('Next.js Turbo Redis Cache Integration', () => {
     });
 
     // describe('With a cached static fetch request inside a page', () => {
-    //   // TODO: implement test for `test/integration/next-app/src/app/pages/cached-static-fetch`
+    //   // TODO: implement test for `test/nextjs-test-projects/next-app/src/app/pages/cached-static-fetch`
     // });
 
     describe('With a cached revalidation fetch request inside a page', () => {
@@ -905,7 +911,7 @@ describe('Next.js Turbo Redis Cache Integration', () => {
     });
 
     // describe('With a uncached fetch request inside a page', () => {
-    //   // TODO: implement test for `test/integration/next-app/src/app/pages/uncached-fetch`
+    //   // TODO: implement test for `test/nextjs-test-projects/next-app/src/app/pages/uncached-fetch`
     //
     // });