@trieb.work/nextjs-turbo-redis-cache 1.14.1 → 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/test/vitest/unit/serializer.test.ts

@@ -0,0 +1,182 @@
+import { describe, it, expect, vi } from 'vitest';
+
+import {
+  CacheValueSerializer,
+  jsonCacheValueSerializer,
+} from '../../../src/serializer';
+import type { CacheEntry } from '../../../src/RedisStringsHandler';
+
+function makeEntry(value: unknown): CacheEntry {
+  return {
+    value,
+    lastModified: 1700000000000,
+    tags: ['tag-a', 'tag-b'],
+  };
+}
+
+describe('jsonCacheValueSerializer (default)', () => {
+  it('round-trips a CacheEntry with a top-level Buffer value (Buffer + Map encoding preserved)', async () => {
+    const original = makeEntry(Buffer.from('hello world', 'utf8'));
+
+    const serialized = await jsonCacheValueSerializer.serialize(original);
+    expect(typeof serialized).toBe('string');
+
+    const restored = await jsonCacheValueSerializer.deserialize(serialized);
+    expect(restored).not.toBeNull();
+    expect(Buffer.isBuffer(restored!.value)).toBe(true);
+    expect((restored!.value as Buffer).toString('utf8')).toBe('hello world');
+    expect(restored!.lastModified).toBe(original.lastModified);
+    expect(restored!.tags).toEqual(original.tags);
+  });
+
+  it('round-trips a Buffer nested inside a CacheEntry value object', async () => {
+    const original = makeEntry({
+      kind: 'APP_ROUTE',
+      body: Buffer.from([0x01, 0x02, 0x03, 0x04]),
+    });
+
+    const serialized = await jsonCacheValueSerializer.serialize(original);
+    const restored = await jsonCacheValueSerializer.deserialize(serialized);
+
+    const nested = (restored!.value as { body: Buffer }).body;
+    expect(Buffer.isBuffer(nested)).toBe(true);
+    expect(Array.from(nested)).toEqual([0x01, 0x02, 0x03, 0x04]);
+  });
+
+  it('round-trips a Map value back to a native Map instance', async () => {
+    const map = new Map<string, string>([
+      ['k1', 'v1'],
+      ['k2', 'v2'],
+    ]);
+    const original = makeEntry(map);
+
+    const serialized = await jsonCacheValueSerializer.serialize(original);
+    const restored = await jsonCacheValueSerializer.deserialize(serialized);
+
+    expect(restored!.value).toBeInstanceOf(Map);
+    const restoredMap = restored!.value as Map<string, string>;
+    expect(restoredMap.size).toBe(2);
+    expect(restoredMap.get('k1')).toBe('v1');
+    expect(restoredMap.get('k2')).toBe('v2');
+  });
+
+  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('../../../src/serializer'))
+      .jsonCacheValueSerializer;
+    expect(reimport).toBe(jsonCacheValueSerializer);
+  });
+});
+
+describe('CacheValueSerializer custom implementations', () => {
+  it('invokes a synchronous custom serializer exactly once per call', async () => {
+    const serialize = vi.fn(
+      (value: CacheEntry) => `sync:${JSON.stringify(value)}`,
+    );
+    const deserialize = vi.fn(
+      (stored: string) =>
+        JSON.parse(stored.replace(/^sync:/, '')) as CacheEntry,
+    );
+    const custom: CacheValueSerializer = { serialize, deserialize };
+
+    const entry = makeEntry({ kind: 'FETCH', payload: 42 });
+
+    const out = await custom.serialize(entry);
+    expect(serialize).toHaveBeenCalledTimes(1);
+    expect(out.startsWith('sync:')).toBe(true);
+
+    const restored = await custom.deserialize(out);
+    expect(deserialize).toHaveBeenCalledTimes(1);
+    expect(restored).toEqual(entry);
+  });
+
+  it('awaits an asynchronous custom serializer (Promise-returning serialize/deserialize)', async () => {
+    const custom: CacheValueSerializer = {
+      async serialize(value) {
+        // Simulate async work (e.g. zlib.brotliCompress promisified).
+        await new Promise((r) => setTimeout(r, 0));
+        return `async:${JSON.stringify(value)}`;
+      },
+      async deserialize(stored) {
+        await new Promise((r) => setTimeout(r, 0));
+        return JSON.parse(stored.replace(/^async:/, '')) as CacheEntry;
+      },
+    };
+
+    const entry = makeEntry({ kind: 'FETCH', payload: 'async-value' });
+
+    const out = await custom.serialize(entry);
+    expect(typeof out).toBe('string');
+    expect(out.startsWith('async:')).toBe(true);
+
+    const restored = await custom.deserialize(out);
+    expect(restored).toEqual(entry);
+  });
+
+  it('treats a deserializer returning null as a cache miss (sync and async)', async () => {
+    const syncMiss: CacheValueSerializer = {
+      serialize: () => 'ignored',
+      deserialize: () => null,
+    };
+    const asyncMiss: CacheValueSerializer = {
+      serialize: async () => 'ignored',
+      deserialize: async () => null,
+    };
+
+    expect(await syncMiss.deserialize('whatever')).toBeNull();
+    expect(await asyncMiss.deserialize('whatever')).toBeNull();
+  });
+
+  it('propagates synchronous serializer throws and asynchronous rejections to the caller', async () => {
+    const syncThrowing: CacheValueSerializer = {
+      serialize() {
+        throw new Error('sync serialize boom');
+      },
+      deserialize() {
+        throw new Error('sync deserialize boom');
+      },
+    };
+    const asyncRejecting: CacheValueSerializer = {
+      async serialize() {
+        throw new Error('async serialize boom');
+      },
+      async deserialize() {
+        throw new Error('async deserialize boom');
+      },
+    };
+
+    const entry = makeEntry({ kind: 'FETCH', payload: 'x' });
+
+    expect(() => syncThrowing.serialize(entry)).toThrow('sync serialize boom');
+    expect(() => syncThrowing.deserialize('x')).toThrow(
+      'sync deserialize boom',
+    );
+    await expect(asyncRejecting.serialize(entry)).rejects.toThrow(
+      'async serialize boom',
+    );
+    await expect(asyncRejecting.deserialize('x')).rejects.toThrow(
+      'async deserialize boom',
+    );
+  });
+
+  it('passes the exact stored string to deserialize (no pre-parsing by the caller)', async () => {
+    const serialize = (value: CacheEntry) =>
+      `wrapped(${JSON.stringify(value)})`;
+    const deserialize = vi.fn((stored: string) => {
+      // If the caller mutated the wire format, this would explode.
+      const m = /^wrapped\((.+)\)$/.exec(stored);
+      if (!m) return null;
+      return JSON.parse(m[1]) as CacheEntry;
+    });
+    const custom: CacheValueSerializer = { serialize, deserialize };
+
+    const entry = makeEntry({ kind: 'APP_PAGE', html: '<p>hi</p>' });
+
+    const wire = await custom.serialize(entry);
+    const restored = await custom.deserialize(wire);
+
+    expect(deserialize).toHaveBeenCalledWith(wire);
+    expect(restored).toEqual(entry);
+  });
+});

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;