@trieb.work/nextjs-turbo-redis-cache 1.17.0 → 1.18.1

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

@@ -1,65 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { spawn } from 'child_process';
-import path from 'path';
-import { spawnSync } from 'child_process';
-
-function hasContainerRuntime() {
-  const podman = spawnSync('podman', ['--version'], {
-    encoding: 'utf8',
-    timeout: 3_000,
-  });
-  if (!podman.error && (podman.status ?? 1) === 0) return true;
-
-  const docker = spawnSync('docker', ['--version'], {
-    encoding: 'utf8',
-    timeout: 3_000,
-  });
-  return !docker.error && (docker.status ?? 1) === 0;
-}
-
-function runNode(script: string, timeoutMs = 120_000) {
-  return new Promise<{ code: number; stdout: string; stderr: string }>(
-    (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 });
-      });
-    },
-  );
-}
-
-describe('redis kill/reconnect end-to-end (both handlers)', () => {
-  const runOrSkip = hasContainerRuntime() ? it : it.skip;
-
-  runOrSkip(
-    'survives redis restart without Socket already opened',
-    async () => {
-      const script = path.join(__dirname, 'scripts', 'redis-kill-reconnect.ts');
-
-      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');
-    },
-    180_000,
-  );
-});

package/test/vitest/integration/cache-components/redis-quit-vs-disconnect.test.ts

@@ -1,59 +0,0 @@
-import { describe, it, expect, beforeAll } from 'vitest';
-import path from 'path';
-import {
-  hasContainerRuntime,
-  runNode,
-  parseResults,
-  type TestResult,
-} from './scripts/redis-test-helpers';
-
-const describeOrSkip = hasContainerRuntime() ? describe : describe.skip;
-
-describeOrSkip('subscriber teardown: quit() vs disconnect()', () => {
-  let results: Map<string, TestResult>;
-  let exitCode: number;
-  let stderr: string;
-
-  beforeAll(async () => {
-    const script = path.join(
-      __dirname,
-      'scripts',
-      'redis-quit-vs-disconnect.ts',
-    );
-    const res = await runNode(script, 60_000);
-    exitCode = res.code;
-    stderr = res.stderr;
-    results = parseResults(res.stdout);
-  }, 60_000);
-
-  it('script exits successfully', () => {
-    if (exitCode !== 0) {
-      process.stderr.write(stderr);
-    }
-    expect(exitCode).toBe(0);
-  });
-
-  it('subscriber clients are ready before outage', () => {
-    const r = results.get('subscribers-ready');
-    expect(r).toBeDefined();
-    expect(r!.pass, r!.detail).toBe(true);
-  });
-
-  it('quit() does not immediately close a subscriber during outage', () => {
-    const r = results.get('quit-does-not-immediately-close');
-    expect(r).toBeDefined();
-    expect(r!.pass, r!.detail).toBe(true);
-  });
-
-  it('disconnect() closes the subscriber immediately during outage', () => {
-    const r = results.get('disconnect-closes-immediately');
-    expect(r).toBeDefined();
-    expect(r!.pass, r!.detail).toBe(true);
-  });
-
-  it('disconnected subscriber stays dead after Redis restarts', () => {
-    const r = results.get('disconnected-client-stays-dead');
-    expect(r).toBeDefined();
-    expect(r!.pass, r!.detail).toBe(true);
-  });
-});

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

@@ -1,100 +0,0 @@
-import { describe, it, expect, beforeAll } from 'vitest';
-import path from 'path';
-import {
-  hasContainerRuntime,
-  runNode,
-  parseResults,
-  type TestResult,
-} from './scripts/redis-test-helpers';
-
-const describeOrSkip = hasContainerRuntime() ? describe : describe.skip;
-
-describeOrSkip('issue #86: subscriber outage recovery', () => {
-  let results: Map<string, TestResult>;
-
-  beforeAll(async () => {
-    const script = path.join(
-      __dirname,
-      'scripts',
-      'redis-subscriber-outage.ts',
-    );
-    const res = await runNode(script, 300_000);
-    // Script always exits 0 (it records pass/fail per sub-test)
-    if (res.code !== 0) {
-      throw new Error(
-        `Script exited with code ${res.code}\nstdout:\n${res.stdout}\nstderr:\n${res.stderr}`,
-      );
-    }
-    results = parseResults(res.stdout);
-  }, 300_000);
-
-  // --- Tests that should PASS (verify correct behavior before outage) ---
-
-  it('PubSub sync works before outage', () => {
-    const r = results.get('pubsub-initial-strings');
-    expect(r).toBeDefined();
-    expect(r!.pass, r!.detail).toBe(true);
-  });
-
-  it('subscriber clients have error listeners before outage', () => {
-    const r = results.get('error-listener-initial');
-    expect(r).toBeDefined();
-    expect(r!.pass, r!.detail).toBe(true);
-  });
-
-  // --- Tests that verify symptoms during outage ---
-
-  it('get() returns null during outage', () => {
-    const r = results.get('get-during-outage');
-    expect(r).toBeDefined();
-    expect(r!.pass, r!.detail).toBe(true);
-  });
-
-  it('heap does not grow excessively during 50 get() calls in outage', () => {
-    const r = results.get('heap-growth-during-outage');
-    expect(r).toBeDefined();
-    expect(r!.pass, r!.detail).toBe(true);
-  });
-
-  it('main client reconnects after Redis restart', () => {
-    const r = results.get('main-client-reconnects');
-    expect(r).toBeDefined();
-    expect(r!.pass, r!.detail).toBe(true);
-  });
-
-  it('get() works after Redis restart (main client path)', () => {
-    const r = results.get('get-after-outage');
-    expect(r).toBeDefined();
-    expect(r!.pass, r!.detail).toBe(true);
-  });
-
-  // --- Tests that reproduce the bug (EXPECTED TO FAIL with current code) ---
-
-  it('PubSub sync works after outage (issue #86 — subscriber never recovers)', () => {
-    const r = results.get('pubsub-after-outage-strings');
-    expect(r).toBeDefined();
-    expect(r!.pass, r!.detail).toBe(true);
-  });
-
-  it('subscriber error listener state after outage (informational)', () => {
-    const r = results.get('error-listener-after-outage');
-    expect(r).toBeDefined();
-    // Informational — always passes. Detail shows whether the listener
-    // survived and whether the subscriber client object was replaced.
-    expect(r!.pass, r!.detail).toBe(true);
-  });
-
-  it('duplicate() call count during outage (informational)', () => {
-    const r = results.get('duplicate-count-during-outage');
-    expect(r).toBeDefined();
-    // Informational — always passes. Detail has the actual count.
-    expect(r!.pass, r!.detail).toBe(true);
-  });
-
-  it('total duplicate() call count (informational)', () => {
-    const r = results.get('duplicate-count-total');
-    expect(r).toBeDefined();
-    // Informational — always passes. Detail has the actual count.
-    expect(r!.pass, r!.detail).toBe(true);
-  });
-});

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

@@ -1,243 +0,0 @@
-import { spawnSync } from 'child_process';
-
-type ContainerRuntime = 'podman' | 'docker';
-
-function sh(cmd: string, args: string[], opts: { timeoutMs?: number } = {}) {
-  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 ?? '',
-  };
-}
-
-function canRun(cmd: string) {
-  const res = spawnSync(cmd, ['--version'], {
-    encoding: 'utf8',
-    timeout: 3_000,
-  });
-  return !res.error && (res.status ?? 1) === 0;
-}
-
-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.',
-  );
-}
-
-async function sleep(ms: number) {
-  await new Promise((r) => setTimeout(r, ms));
-}
-
-async function waitUntil(fn: () => Promise<boolean>, timeoutMs = 20_000) {
-  const start = Date.now();
-  // eslint-disable-next-line no-constant-condition
-  while (true) {
-    if (await fn()) return;
-    if (Date.now() - start > timeoutMs) throw new Error('waitUntil timeout');
-    await sleep(200);
-  }
-}
-
-async function main() {
-  const runtime = detectContainerRuntime();
-  const name = `redis-e2e-${Math.random().toString(36).slice(2, 8)}`;
-
-  // Pick a free localhost port
-  const net = await import('net');
-  const port: number = await 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));
-    });
-  });
-
-  // cleanup
-  sh(runtime, ['rm', '-f', name]);
-
-  // Start redis with keyspace notifications enabled (required by SyncedMap)
-  {
-    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(`podman run failed: ${r.stderr}`);
-  }
-
-  // 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}-`;
-
-  const { getRedisCacheComponentsHandler } = await import(
-    '../../../../../src/CacheComponentsHandler'
-  );
-  const { default: RedisStringsHandler } = await import(
-    '../../../../../src/RedisStringsHandler'
-  );
-
-  // Cache Components handler
-  const cacheComponentsHandler = getRedisCacheComponentsHandler({
-    redisUrl: `redis://127.0.0.1:${port}`,
-    socketOptions: {
-      connectTimeout: 2_000,
-      // allow redis client to reconnect; this scenario is about stability under restart
-      reconnectStrategy: (retries) => Math.min(50 + retries * 50, 500),
-    },
-  });
-
-  const cacheComponentsClient = (cacheComponentsHandler as any).client as {
-    ping: () => Promise<string>;
-    isReady: boolean;
-  };
-
-  await waitUntil(async () => cacheComponentsClient.isReady, 20_000);
-  if ((await cacheComponentsClient.ping()) !== 'PONG') {
-    throw new Error('expected PONG (cache components)');
-  }
-
-  // Regular handler
-  const regularHandler = new RedisStringsHandler({
-    redisUrl: `redis://127.0.0.1:${port}`,
-    socketOptions: {
-      connectTimeout: 2_000,
-      reconnectStrategy: (retries: number) => Math.min(50 + retries * 50, 500),
-    },
-    // Keep default offline queue behavior here; SyncedMap does initial sync during construction.
-    keyPrefix: `e2e-${name}-regular-`,
-  } as any);
-
-  const regularClient = (regularHandler as any).client as {
-    ping: () => Promise<string>;
-    isReady: boolean;
-  };
-
-  await waitUntil(async () => regularClient.isReady, 20_000);
-  if ((await regularClient.ping()) !== 'PONG') {
-    throw new Error('expected PONG (regular handler)');
-  }
-
-  // Seed a small entry so we know regular handler does real ops
-  await regularHandler.set(
-    'e2e-key',
-    {
-      kind: 'FETCH',
-      data: {
-        headers: {},
-        body: Buffer.from('hello').toString('base64'),
-        status: 200,
-        url: 'https://example.com/e2e',
-      },
-      revalidate: 10,
-    },
-    { isRoutePPREnabled: false, isFallback: false, tags: ['e2e'] },
-  );
-
-  const got = await regularHandler.get('e2e-key', {
-    kind: 'FETCH',
-    revalidate: 10,
-    fetchUrl: 'https://example.com/e2e',
-    fetchIdx: 0,
-    tags: ['e2e'],
-    softTags: [],
-    isFallback: false,
-  });
-  if (!got) throw new Error('expected cache hit (regular handler)');
-
-  // Kill redis
-  sh(runtime, ['stop', '-t', '0', name], { timeoutMs: 30_000 });
-
-  // Wait a bit, then start again
-  await sleep(500);
-
-  {
-    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} run2 failed: ${r.stderr}`);
-  }
-
-  // Should recover (both)
-  await waitUntil(async () => {
-    try {
-      return (await cacheComponentsClient.ping()) === 'PONG';
-    } catch {
-      return false;
-    }
-  }, 30_000);
-
-  await waitUntil(async () => {
-    try {
-      return (await regularClient.ping()) === 'PONG';
-    } catch {
-      return false;
-    }
-  }, 30_000);
-
-  // Shut down clients before cleaning up Redis, otherwise reconnect loops keep the process alive.
-  try {
-    await (cacheComponentsHandler as any).client?.quit?.();
-  } catch {}
-  try {
-    await (regularHandler as any).client?.quit?.();
-  } catch {}
-
-  // cleanup best effort
-  sh(runtime, ['rm', '-f', name]);
-
-  // If we reach here without crashing due to Socket already opened, we're good.
-  // (Vitest will check stdout for this line.)
-  process.stdout.write('OK\n');
-
-  // Ensure we exit even if background reconnect timers exist.
-  process.exit(0);
-}
-
-main().catch((err) => {
-  // Ensure we don't hide the key error string
-  console.error(err);
-  process.exit(1);
-});

package/test/vitest/integration/cache-components/scripts/redis-quit-vs-disconnect.ts

@@ -1,113 +0,0 @@
-/**
- * Demonstrates the difference between quit() and disconnect() on a
- * node-redis subscriber client while Redis is down.
- *
- * Scenario:
- * 1. Start Redis.
- * 2. Connect two subscriber clients and subscribe them.
- * 3. Kill Redis and wait for the reconnect loop to start.
- * 4. Subscriber A: call quit(). It should NOT resolve quickly while Redis is down.
- * 5. Subscriber B: call disconnect(). It must close the socket immediately.
- * 6. Restart Redis and verify that the disconnected subscriber stays dead.
- *
- * This shows why disconnect() is the correct teardown method during an outage.
- */
-
-import { createClient } from 'redis';
-import {
-  detectContainerRuntime,
-  getFreePort,
-  record,
-  sh,
-  sleep,
-  startRedis,
-} from './redis-test-helpers';
-
-async function createSubscriber(url: string) {
-  const client = createClient({
-    url,
-    socket: {
-      connectTimeout: 2_000,
-      reconnectStrategy: (retries: number) => Math.min(50 + retries * 50, 500),
-    },
-  });
-  client.on('error', () => {});
-  await client.connect();
-  await client.subscribe('test-channel', () => {});
-  return client;
-}
-
-async function main() {
-  const runtime = detectContainerRuntime();
-  const name = `redis-quit-disc-${Math.random().toString(36).slice(2, 8)}`;
-  const port = await getFreePort();
-
-  sh(runtime, ['rm', '-f', name]);
-  startRedis(runtime, name, port);
-
-  const url = `redis://127.0.0.1:${port}`;
-
-  const quitSubscriber = await createSubscriber(url);
-  const disconnectSubscriber = await createSubscriber(url);
-
-  record(
-    'subscribers-ready',
-    quitSubscriber.isReady && disconnectSubscriber.isReady,
-    `quitSub isReady=${quitSubscriber.isReady}, disconnectSub isReady=${disconnectSubscriber.isReady}`,
-  );
-
-  // Kill Redis and let both clients enter their reconnect loops
-  sh(runtime, ['stop', '-t', '0', name], { timeoutMs: 30_000 });
-  await sleep(1_500);
-
-  // Test quit(): it should not resolve while Redis is unreachable.
-  const quitResult = await Promise.race([
-    quitSubscriber
-      .quit()
-      .then(() => 'resolved')
-      .catch((e) => `error:${e.message ?? e}`),
-    sleep(3_000).then(() => 'timeout'),
-  ]);
-
-  record(
-    'quit-does-not-immediately-close',
-    quitResult !== 'resolved',
-    `quit() result during outage: ${quitResult}`,
-  );
-
-  // Test disconnect(): it must close the client immediately, even during outage.
-  const disconnectStart = Date.now();
-  try {
-    await disconnectSubscriber.disconnect();
-  } catch (e: any) {
-    // If the client is already closed, that's still a successful teardown.
-  }
-  const disconnectDuration = Date.now() - disconnectStart;
-
-  record(
-    'disconnect-closes-immediately',
-    !disconnectSubscriber.isOpen && !disconnectSubscriber.isReady,
-    `disconnect() took ${disconnectDuration}ms, isOpen=${disconnectSubscriber.isOpen}, isReady=${disconnectSubscriber.isReady}`,
-  );
-
-  // Restart Redis and make sure the disconnected client does not come back.
-  startRedis(runtime, name, port);
-  await sleep(1_500);
-
-  record(
-    'disconnected-client-stays-dead',
-    !disconnectSubscriber.isOpen && !disconnectSubscriber.isReady,
-    `after restart: isOpen=${disconnectSubscriber.isOpen}, isReady=${disconnectSubscriber.isReady}`,
-  );
-
-  // Also clean up the quit subscriber so we don't leak the process.
-  try {
-    await quitSubscriber.disconnect();
-  } catch {}
-  sh(runtime, ['rm', '-f', name]);
-}
-
-main().catch((err) => {
-  process.stderr.write(String(err) + '\n');
-  process.exit(1);
-});