npm - @trieb.work/nextjs-turbo-redis-cache - Versions diffs - 1.15.0 → 1.15.1 - Mend

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

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (246) hide show

package/test/nextjs-test-projects/next-app-16-2-6-cache-components/src/app/cache-lab/use-cache-nondeterministic/page.tsx ADDED Viewed

@@ -0,0 +1,110 @@
+import Link from 'next/link';
+import { cacheTag, updateTag } from 'next/cache';
+async function getCachedNonDeterministicValues() {
+  'use cache';
+  cacheTag('cache-lab:nondet');
+  const random1 = Math.random();
+  const random2 = Math.random();
+  const now = Date.now();
+  const uuid = crypto.randomUUID();
+  const bytes = crypto.getRandomValues(new Uint8Array(8));
+  return {
+    random1,
+    random2,
+    now,
+    uuid,
+    bytes: Array.from(bytes),
+  };
+}
+async function refresh() {
+  'use server';
+  updateTag('cache-lab:nondet');
+}
+export default async function UseCacheNonDeterministicPage() {
+  const data = await getCachedNonDeterministicValues();
+  return (
+    <main className="mx-auto max-w-3xl p-10">
+      <div className="mb-6">
+        <Link
+          className="text-sm text-blue-600 hover:underline"
+          href="/cache-lab"
+        >
+          ← Back to Cache Lab
+        </Link>
+      </div>
+      <header className="mb-6">
+        <h1 className="text-2xl font-semibold">use cache: non-deterministic</h1>
+        <p className="mt-2 text-sm text-slate-600">
+          Per docs, non-deterministic operations inside a <code>use cache</code>{' '}
+          scope run once and then stay stable for all requests until you
+          invalidate.
+        </p>
+      </header>
+      <form action={refresh} className="mb-6">
+        <button
+          className="rounded-md bg-blue-600 px-4 py-2 text-sm font-medium text-white hover:bg-blue-700"
+          type="submit"
+        >
+          updateTag('cache-lab:nondet')
+        </button>
+      </form>
+      <div className="rounded-lg border p-5">
+        <dl className="grid grid-cols-1 gap-3 text-sm">
+          <div>
+            <dt className="font-medium">random1</dt>
+            <dd data-testid="random1" className="font-mono text-slate-700">
+              {data.random1}
+            </dd>
+          </div>
+          <div>
+            <dt className="font-medium">random2</dt>
+            <dd data-testid="random2" className="font-mono text-slate-700">
+              {data.random2}
+            </dd>
+          </div>
+          <div>
+            <dt className="font-medium">now (Date.now)</dt>
+            <dd data-testid="now" className="font-mono text-slate-700">
+              {data.now}
+            </dd>
+          </div>
+          <div>
+            <dt className="font-medium">uuid</dt>
+            <dd data-testid="uuid" className="font-mono text-slate-700">
+              {data.uuid}
+            </dd>
+          </div>
+          <div>
+            <dt className="font-medium">bytes</dt>
+            <dd data-testid="bytes" className="font-mono text-slate-700">
+              {JSON.stringify(data.bytes)}
+            </dd>
+          </div>
+        </dl>
+      </div>
+      <div className="mt-6 rounded-lg border bg-slate-50 p-5 text-sm text-slate-700">
+        <div className="space-y-2">
+          <p>
+            Expected: Reloading the page should keep values identical across
+            requests.
+          </p>
+          <p>
+            Click the button (Server Action) to run <code>updateTag</code> and
+            refresh the cached entry.
+          </p>
+        </div>
+      </div>
+    </main>
+  );
+}

package/test/{integration/next-app-16-0-3 → nextjs-test-projects/next-app-16-2-6-cache-components}/src/app/layout.tsx RENAMED Viewed

@@ -50,8 +50,6 @@ export default async function RootLayout({
       <body
         className={`${geistSans.variable} ${geistMono.variable} antialiased`}
       >
-        Layout TS: {Date.now()}
-        {/* Layout counter: {data.origin} */}
         {children}
       </body>
     </html>

package/test/nextjs-test-projects/next-app-16-2-6-cache-components/src/app/update-tag-test/page.tsx ADDED Viewed

@@ -0,0 +1,22 @@
+import { updateTag } from 'next/cache';
+let clicks = 0;
+async function increment() {
+  'use server';
+  clicks++;
+  updateTag('update-tag-test');
+}
+export default function UpdateTagTestPage() {
+  return (
+    <main style={{ padding: 40, fontFamily: 'system-ui, sans-serif' }}>
+      <h1>UpdateTag Test</h1>
+      <form action={increment}>
+        <p data-testid="clicks">Clicks: {clicks}</p>
+        <button type="submit">Increment</button>
+      </form>
+    </main>
+  );
+}

package/{tests → test/playwright}/update-tag.spec.ts RENAMED Viewed

@@ -1,7 +1,7 @@
 import { test, expect } from '@playwright/test';
 // This test assumes the Next 16 app is already running, e.g.:
-//   cd test/integration/next-app-16-0-3 && pnpm dev
+//   cd test/nextjs-test-projects/next-app-16-0-11 && pnpm dev
 // on the same origin as baseURL.
 test('button click triggers Server Action using updateTag', async ({

package/test/{integration → vitest/integration}/build-id-prefix.integration.test.ts RENAMED Viewed

@@ -5,7 +5,7 @@ import path from 'path';
 import fs from 'fs';
 import fetch from 'node-fetch';
-const NEXT_APP = 'next-app-15-4-7';
+const NEXT_APP = 'next-app-15-4-11';
 const PORT = 3075;
 const BASE_URL = `http://localhost:${PORT}`;
@@ -28,7 +28,7 @@ describe('BUILD_ID-based key prefix (Next handlers)', () => {
   let buildId: string;
   beforeAll(async () => {
-    appDir = path.join(__dirname, NEXT_APP);
+    appDir = path.join(__dirname, '..', '..', 'nextjs-test-projects', NEXT_APP);
     // Ensure clean env so BUILD_ID precedence kicks in
     delete (process.env as Record<string, string | undefined>).KEY_PREFIX;

package/test/{cache-components/cache-components.integration.spec.ts → vitest/integration/cache-components/cache-components.integration.test.ts} RENAMED Viewed

@@ -27,12 +27,16 @@ describe('Next.js 16 Cache Components Integration', () => {
     keyPrefix = `cache-components-test-${Math.random().toString(36).substring(7)}`;
     process.env.VERCEL_URL = keyPrefix;
-    // Build and start Next.js app
+    const cacheComponentsApp =
+      process.env.CACHE_COMPONENTS_APP || 'next-app-16-2-6-cache-components';
     const appDir = path.join(
       __dirname,
       '..',
-      'integration',
-      'next-app-16-2-3-cache-components',
+      '..',
+      '..',
+      'nextjs-test-projects',
+      cacheComponentsApp,
     );
     console.log('Installing Next.js app dependencies...');

package/test/{cache-components/redis-kill-reconnect.spec.ts → vitest/integration/cache-components/redis-kill-reconnect.test.ts} RENAMED Viewed

@@ -1,6 +1,21 @@
 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 }>(
@@ -26,13 +41,19 @@ function runNode(script: string, timeoutMs = 120_000) {
 }
 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 runOrSkip = hasContainerRuntime() ? it : it.skip;
-    const res = await runNode(script, 180_000);
+  runOrSkip(
+    'survives redis restart without Socket already opened',
+    async () => {
+      const script = path.join(__dirname, 'scripts', 'redis-kill-reconnect.ts');
-    expect(res.code).toBe(0);
-    expect(res.stdout).toContain('OK');
-    expect(res.stderr).not.toContain('Socket already opened');
-  }, 180_000);
+      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/vitest/integration/cache-components/redis-quit-vs-disconnect.test.ts ADDED Viewed

@@ -0,0 +1,59 @@
+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 ADDED Viewed

@@ -0,0 +1,100 @@
+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/{cache-components → vitest/integration/cache-components}/scripts/redis-kill-reconnect.ts RENAMED Viewed

@@ -1,5 +1,7 @@
 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',
@@ -13,6 +15,26 @@ function sh(cmd: string, args: string[], opts: { timeoutMs?: number } = {}) {
   };
 }
+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));
 }
@@ -28,6 +50,7 @@ async function waitUntil(fn: () => Promise<boolean>, timeoutMs = 20_000) {
 }
 async function main() {
+  const runtime = detectContainerRuntime();
   const name = `redis-e2e-${Math.random().toString(36).slice(2, 8)}`;
   // Pick a free localhost port
@@ -45,12 +68,12 @@ async function main() {
   });
   // cleanup
-  sh('podman', ['rm', '-f', name]);
+  sh(runtime, ['rm', '-f', name]);
   // Start redis with keyspace notifications enabled (required by SyncedMap)
   {
     const r = sh(
-      'podman',
+      runtime,
       [
         'run',
         '-d',
@@ -75,10 +98,10 @@ async function main() {
   process.env.VERCEL_URL = `e2e-${name}-`;
   const { getRedisCacheComponentsHandler } = await import(
-    '../../../src/CacheComponentsHandler'
+    '../../../../../src/CacheComponentsHandler'
   );
   const { default: RedisStringsHandler } = await import(
-    '../../../src/RedisStringsHandler'
+    '../../../../../src/RedisStringsHandler'
   );
   // Cache Components handler
@@ -153,14 +176,14 @@ async function main() {
   if (!got) throw new Error('expected cache hit (regular handler)');
   // Kill redis
-  sh('podman', ['stop', '-t', '0', name], { timeoutMs: 30_000 });
+  sh(runtime, ['stop', '-t', '0', name], { timeoutMs: 30_000 });
   // Wait a bit, then start again
   await sleep(500);
   {
     const r = sh(
-      'podman',
+      runtime,
       [
         'run',
         '-d',
@@ -176,7 +199,7 @@ async function main() {
       ],
       { timeoutMs: 60_000 },
     );
-    if (r.code !== 0) throw new Error(`podman run2 failed: ${r.stderr}`);
+    if (r.code !== 0) throw new Error(`${runtime} run2 failed: ${r.stderr}`);
   }
   // Should recover (both)
@@ -205,7 +228,7 @@ async function main() {
   } catch {}
   // cleanup best effort
-  sh('podman', ['rm', '-f', name]);
+  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.)

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

@@ -0,0 +1,113 @@
+/**
+ * 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);
+});