@trieb.work/nextjs-turbo-redis-cache 1.11.0 → 1.11.1

package/test/cache-components/redis-kill-reconnect.spec.ts

@@ -0,0 +1,38 @@
+import { describe, it, expect } from 'vitest';
+import { spawn } from 'child_process';
+import path from 'path';
+
+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)', () => {
+  it('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);
+
+    expect(res.code).toBe(0);
+    expect(res.stdout).toContain('OK');
+    expect(res.stderr).not.toContain('Socket already opened');
+  }, 180_000);
+});

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

@@ -0,0 +1,222 @@
+import { spawnSync } from 'child_process';
+
+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 ?? '',
+  };
+}
+
+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 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('podman', ['rm', '-f', name]);
+
+  // Start redis with keyspace notifications enabled (required by SyncedMap)
+  {
+    const r = sh(
+      'podman',
+      [
+        '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}`);
+  }
+
+  // IMPORTANT: importing from "src" will eagerly instantiate the singleton via `redisCacheHandler`.
+  // So we must set env BEFORE importing.
+  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),
+    },
+    clientOptions: {
+      disableOfflineQueue: true,
+    } as any,
+  });
+
+  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('podman', ['stop', '-t', '0', name], { timeoutMs: 30_000 });
+
+  // Wait a bit, then start again
+  await sleep(500);
+
+  {
+    const r = sh(
+      'podman',
+      [
+        '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 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('podman', ['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);
+});