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

package/test/vitest/unit/SyncedMap-reconnect-repro.test.ts

@@ -0,0 +1,154 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SyncedMap } from '../../../src/SyncedMap';
+
+// Module-level knobs for the subscribe() mock so that behaviour persists
+// across the duplicate() clients created inside SyncedMap.
+let globalSubscribeCalls = 0;
+let globalSubscribeFailUntil = 0;
+
+class MockClient {
+  static nextId = 1;
+  id = MockClient.nextId++;
+  private errorHandlers: Set<(err: Error) => void | Promise<void>> = new Set();
+  quitShouldThrow = true;
+
+  isOpen = true;
+  isReady = true;
+
+  on(event: string, handler: (err: Error) => void | Promise<void>) {
+    if (event === 'error') this.errorHandlers.add(handler);
+    return this as any;
+  }
+
+  emit(event: string, err: Error) {
+    if (event === 'error') {
+      for (const h of this.errorHandlers) {
+        void h(err);
+      }
+    }
+    return true;
+  }
+
+  removeAllListeners(event?: string) {
+    if (!event || event === 'error') this.errorHandlers.clear();
+    return this as any;
+  }
+
+  async connect() {
+    this.isOpen = true;
+    this.isReady = true;
+  }
+
+  async configGet() {
+    return { 'notify-keyspace-events': 'Exe' };
+  }
+
+  async subscribe() {
+    const attempt = globalSubscribeCalls++;
+    if (attempt < globalSubscribeFailUntil) {
+      throw new Error(`Mock subscribe failure ${attempt}`);
+    }
+  }
+
+  async quit() {
+    if (this.quitShouldThrow)
+      throw new Error('Mock quit failure (disconnected)');
+  }
+
+  async disconnect() {
+    this.isOpen = false;
+    this.isReady = false;
+    this.errorHandlers.clear();
+  }
+
+  duplicate() {
+    return new MockClient();
+  }
+
+  hScan() {
+    return { cursor: 0, tuples: [] };
+  }
+
+  scan() {
+    return { cursor: 0, keys: [] };
+  }
+}
+
+function createMap(rootClient = new MockClient()) {
+  return new SyncedMap<string>({
+    client: rootClient as any,
+    keyPrefix: 'repro:',
+    redisKey: '__sharedTags__',
+    database: 0,
+    querySize: 250,
+    filterKeys: () => true,
+    customizedSync: {
+      withoutRedisHashmap: true,
+      withoutSetSync: true,
+    },
+  });
+}
+
+describe('SyncedMap.reconnectSubscriber() repro tests', () => {
+  let originalSetTimeout: typeof global.setTimeout;
+
+  beforeEach(() => {
+    globalSubscribeCalls = 0;
+    globalSubscribeFailUntil = 0;
+    originalSetTimeout = global.setTimeout;
+  });
+
+  afterEach(() => {
+    global.setTimeout = originalSetTimeout;
+  });
+
+  it('Issue 2: first backoff delay should be 500ms, not 1000ms', async () => {
+    const root = new MockClient();
+    const map = createMap(root);
+    // wait for initial setup to succeed (attempt 0)
+    await (map as any).waitUntilReady().catch(() => undefined);
+
+    const capturedDelays: number[] = [];
+    global.setTimeout = ((callback: () => void, delay?: number) => {
+      capturedDelays.push(Number(delay ?? 0));
+      return originalSetTimeout(callback, 0) as any;
+    }) as any;
+
+    // initial subscribe consumed attempt 0; force the next 3 reconnection
+    // attempts to fail, then succeed on the 4th
+    globalSubscribeFailUntil = 4;
+
+    await (map as any).reconnectSubscriber();
+
+    expect(capturedDelays.length).toBeGreaterThanOrEqual(1);
+    // Bug: delay is computed with attempt already incremented, so the first
+    // retry waits 500 * 2^1 = 1000 ms. After the fix it should be 500 ms.
+    expect(capturedDelays[0]).toBe(500);
+  });
+
+  it('Issue 1: stale error on old subscriber must not kill the healthy new subscriber', async () => {
+    const root = new MockClient();
+    const map = createMap(root);
+    await (map as any).waitUntilReady().catch(() => undefined);
+
+    const oldSubscriber = (map as any).subscriberClient as MockClient;
+    expect(oldSubscriber).toBeDefined();
+
+    await (map as any).reconnectSubscriber();
+
+    const newSubscriber = (map as any).subscriberClient as MockClient;
+    expect(newSubscriber.id).not.toBe(oldSubscriber.id);
+
+    // Simulate a delayed error from the old (now replaced) subscriber.
+    // With the current code the old 'error' listener is still attached,
+    // so it triggers reconnectSubscriber() and tears down the healthy client.
+    oldSubscriber.emit('error', new Error('delayed zombie error'));
+
+    // Give the async error handler a chance to run.
+    await new Promise((r) => originalSetTimeout(r, 50));
+
+    const afterStaleError = (map as any).subscriberClient as MockClient;
+
+    expect(afterStaleError.id).toBe(newSubscriber.id);
+  });
+});

package/{src → test/vitest/unit}/index.test.ts

@@ -1,7 +1,7 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
-import type { CreateRedisStringsHandlerOptions } from './index';
-import RedisStringsHandler from './RedisStringsHandler';
+import type { CreateRedisStringsHandlerOptions } from '../../../src/index';
+import RedisStringsHandler from '../../../src/RedisStringsHandler';
 
 vi.mock('redis', () => {
   const createClient = () => {
@@ -38,7 +38,7 @@ vi.mock('redis', () => {
   };
 });
 
-vi.mock('./SyncedMap', () => {
+vi.mock('../../src/SyncedMap', () => {
   class SyncedMap {
     waitUntilReady = vi.fn(async () => undefined);
     get = vi.fn(() => undefined);

package/test/{cache-components/reconnect-socket-already-opened.spec.ts → vitest/unit/reconnect-socket-already-opened.test.ts}

@@ -22,7 +22,7 @@ describe('RedisCacheComponentsHandler reconnect logic', () => {
       .spyOn(console, 'error')
       .mockImplementation(() => {});
 
-    const { getRedisCacheComponentsHandler } = await import('../../src');
+    const { getRedisCacheComponentsHandler } = await import('../../../src');
 
     const handler = getRedisCacheComponentsHandler({
       redisUrl: 'redis://127.0.0.1:6399',

package/{src → test/vitest/unit}/serializer.test.ts

@@ -1,7 +1,10 @@
 import { describe, it, expect, vi } from 'vitest';
 
-import { CacheValueSerializer, jsonCacheValueSerializer } from './serializer';
-import type { CacheEntry } from './RedisStringsHandler';
+import {
+  CacheValueSerializer,
+  jsonCacheValueSerializer,
+} from '../../../src/serializer';
+import type { CacheEntry } from '../../../src/RedisStringsHandler';
 
 function makeEntry(value: unknown): CacheEntry {
   return {
@@ -60,7 +63,8 @@ describe('jsonCacheValueSerializer (default)', () => {
   it('is referentially stable so consumers can detect default usage', async () => {
     // Importing twice should yield the same singleton; this guards against
     // accidental "factory" refactors that would break reference equality.
-    const reimport = (await import('./serializer')).jsonCacheValueSerializer;
+    const reimport = (await import('../../../src/serializer'))
+      .jsonCacheValueSerializer;
     expect(reimport).toBe(jsonCacheValueSerializer);
   });
 });

package/{src → test/vitest/unit}/utils/prefix.test.ts

@@ -2,7 +2,7 @@ import { describe, it, expect, beforeEach } from 'vitest';
 import os from 'node:os';
 import fs from 'node:fs';
 import path from 'node:path';
-import { resolveKeyPrefix } from './prefix';
+import { resolveKeyPrefix } from '../../../../src/utils/prefix';
 
 function withEnv<T>(env: Partial<NodeJS.ProcessEnv>, fn: () => T): T {
   const original: NodeJS.ProcessEnv = { ...process.env };

package/vite.config.ts

@@ -5,9 +5,9 @@ export default defineConfig({
     globals: true,
     environment: 'node',
     include: [
-      'src/**/*.test.ts',
-      'src/**/*.test.tsx',
-      'test/integration/**/*.test.ts',
+      'test/vitest/unit/**/*.test.ts',
+      'test/vitest/unit/**/*.test.tsx',
+      'test/vitest/integration/**/*.test.ts',
     ],
     exclude: [
       'node_modules',
@@ -15,6 +15,7 @@ export default defineConfig({
       '.git',
       '**/node_modules/**',
       '**/node_modules',
+      'test/vitest/integration/cache-components/**',
     ],
     coverage: {
       provider: 'v8',

package/vitest.cache-components.config.ts

@@ -4,7 +4,7 @@ export default defineConfig({
   test: {
     globals: true,
     environment: 'node',
-    include: ['test/cache-components/**/*.spec.ts'],
+    include: ['test/vitest/integration/cache-components/**/*.test.ts'],
     exclude: [
       'node_modules',
       'dist',

package/test/browser/update-tag.browser.test.ts

@@ -1,41 +0,0 @@
-import { test, expect } from 'vitest';
-
-// Base URL of the running Next 16 app.
-// Start it separately, e.g.:
-//   cd test/integration/next-app-16-0-3 && pnpm dev
-// and ensure it listens on the same origin as below.
-const BASE_URL =
-  (globalThis as any).NEXT_BROWSER_BASE_URL || 'http://localhost:3000';
-
-// This test exercises a real Server Action that calls updateTag.
-// It does not assert Redis state, but it verifies that calling the
-// server action endpoint does not trigger the "Server Action only" error.
-
-test('Server Action calling updateTag responds without server-action-only error', async () => {
-  // 1) Fetch the SSR HTML for the page containing the Server Action form
-  const res = await fetch(`${BASE_URL}/update-tag-test`);
-  expect(res.status).toBeLessThan(500);
-  const html = await res.text();
-
-  // 2) Parse the HTML to find the form action URL that Next generated
-  const parser = new DOMParser();
-  const doc = parser.parseFromString(html, 'text/html');
-  const form = doc.querySelector('form');
-  expect(form).not.toBeNull();
-
-  const actionAttr = form!.getAttribute('action');
-  expect(actionAttr).toBeTruthy();
-
-  const actionUrl = new URL(actionAttr!, BASE_URL).toString();
-
-  // 3) Call the Server Action endpoint directly.
-  //    If updateTag were not allowed here, Next.js would respond with
-  //    an error page that contains the specific error message.
-  const actionRes = await fetch(actionUrl, { method: 'POST' });
-  const actionText = await actionRes.text();
-
-  expect(actionRes.status).toBeLessThan(500);
-  expect(actionText).not.toContain(
-    'updateTag can only be called from within a Server Action',
-  );
-});

package/test/integration/next-app-15-0-3/next.config.js

@@ -1,6 +0,0 @@
-/** @type {import('next').NextConfig} */
-const nextConfig = {
-  cacheHandler: require.resolve('@trieb.work/nextjs-turbo-redis-cache'),
-};
-
-module.exports = nextConfig;