npm - @trieb.work/nextjs-turbo-redis-cache - Versions diffs - 1.18.0 → 1.18.1 - Mend

@trieb.work/nextjs-turbo-redis-cache 1.18.0 → 1.18.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 (318) hide show

package/test/vitest/unit/pages-router-kinds.test.ts DELETED Viewed

@@ -1,303 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import RedisStringsHandler, {
-  CacheEntry,
-} from '../../../src/RedisStringsHandler';
-// In-memory Redis string store shared between the mocked client and the tests
-const hoisted = vi.hoisted(() => {
-  const store = new Map<string, { value: string; ex?: number }>();
-  return { store };
-});
-vi.mock('redis', () => {
-  const createClient = () => {
-    return {
-      isReady: true,
-      on: vi.fn(),
-      connect: vi.fn(async () => undefined),
-      disconnect: vi.fn(),
-      quit: vi.fn(),
-      duplicate: vi.fn(() => ({
-        connect: vi.fn(async () => undefined),
-        subscribe: vi.fn(async () => undefined),
-        on: vi.fn(),
-        quit: vi.fn(async () => undefined),
-        configGet: vi.fn(async () => ({ 'notify-keyspace-events': 'Exe' })),
-      })),
-      get: vi.fn(
-        async (_opts: unknown, key: string) =>
-          hoisted.store.get(key)?.value ?? null,
-      ),
-      hScan: vi.fn(async () => ({ cursor: 0, tuples: [] })),
-      scan: vi.fn(async () => ({ cursor: 0, keys: [] })),
-      hSet: vi.fn(async () => 1),
-      hDel: vi.fn(async () => 1),
-      publish: vi.fn(async () => 1),
-      unlink: vi.fn(async () => 1),
-      set: vi.fn(async (key: string, value: string, opts?: { EX?: number }) => {
-        hoisted.store.set(key, { value, ex: opts?.EX });
-        return 'OK';
-      }),
-    };
-  };
-  return {
-    createClient,
-    commandOptions: vi.fn((opts) => opts),
-  };
-});
-const KEY_PREFIX = 'test:';
-const DEFAULT_STALE_AGE = 60 * 60 * 24 * 14;
-// Default estimateExpireAge outside production is staleAge * 1.2
-const expireAge = (staleAge: number) => staleAge * 1.2;
-function createHandler() {
-  return new RedisStringsHandler({
-    redisUrl: 'redis://localhost:6379',
-    keyPrefix: KEY_PREFIX,
-    database: 0,
-    getTimeoutMs: 100,
-    redisGetDeduplication: false,
-    inMemoryCachingTime: 0,
-  });
-}
-function storedEntry(key: string): { entry: CacheEntry; ex?: number } {
-  const raw = hoisted.store.get(KEY_PREFIX + key);
-  expect(raw).toBeDefined();
-  return { entry: JSON.parse(raw!.value), ex: raw!.ex };
-}
-const baseCtx = { isRoutePPREnabled: false, isFallback: false };
-describe('RedisStringsHandler Pages Router kinds', () => {
-  let warnSpy: ReturnType<typeof vi.spyOn>;
-  let errorSpy: ReturnType<typeof vi.spyOn>;
-  beforeEach(() => {
-    hoisted.store.clear();
-    warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => undefined);
-    errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
-  });
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-  describe('PAGES entries', () => {
-    const pagesData = {
-      kind: 'PAGES' as const,
-      html: '<html><body>hello</body></html>',
-      pageData: { pageProps: { title: 'hello' }, __N_SSG: true },
-      headers: undefined,
-      status: 200,
-    };
-    it('set() stores a PAGES entry without warnings and with the implicit path tag', async () => {
-      const handler = createHandler();
-      await handler.set('/blog/post-1', pagesData, {
-        ...baseCtx,
-        cacheControl: { revalidate: 60, expire: undefined },
-      });
-      const { entry, ex } = storedEntry('/blog/post-1');
-      expect(entry).toEqual({
-        value: pagesData,
-        lastModified: expect.any(Number),
-        tags: ['_N_T_/blog/post-1'],
-      });
-      // TTL is derived from cacheControl.revalidate (getStaticProps revalidate)
-      expect(ex).toBe(expireAge(60));
-      expect(warnSpy).not.toHaveBeenCalled();
-      expect(errorSpy).not.toHaveBeenCalled();
-    });
-    it('get() returns a PAGES entry without warnings', async () => {
-      const handler = createHandler();
-      await handler.set('/blog/post-1', pagesData, {
-        ...baseCtx,
-        cacheControl: { revalidate: 60, expire: undefined },
-      });
-      const result = await handler.get('/blog/post-1', {
-        kind: 'PAGES',
-        isFallback: false,
-      });
-      expect(result).toEqual({
-        value: pagesData,
-        lastModified: expect.any(Number),
-        tags: ['_N_T_/blog/post-1'],
-      });
-      expect(warnSpy).not.toHaveBeenCalled();
-      expect(errorSpy).not.toHaveBeenCalled();
-    });
-    it('set() with revalidate: false falls back to defaultStaleAge for the TTL', async () => {
-      const handler = createHandler();
-      await handler.set('/static-forever', pagesData, {
-        ...baseCtx,
-        cacheControl: { revalidate: false, expire: undefined },
-      });
-      const { ex } = storedEntry('/static-forever');
-      expect(ex).toBe(expireAge(DEFAULT_STALE_AGE));
-    });
-    it('set() prefers cacheControl.expire over revalidate for the Redis TTL', async () => {
-      const handler = createHandler();
-      await handler.set('/blog/post-swr', pagesData, {
-        ...baseCtx,
-        cacheControl: { revalidate: 60, expire: 3600 },
-      });
-      const { ex } = storedEntry('/blog/post-swr');
-      expect(ex).toBe(3600);
-    });
-    it('set() derives the TTL from the legacy ctx.revalidate argument (Next.js 15.0.3)', async () => {
-      const handler = createHandler();
-      await handler.set('/blog/post-legacy', pagesData, {
-        ...baseCtx,
-        revalidate: 60,
-      });
-      const { ex } = storedEntry('/blog/post-legacy');
-      expect(ex).toBe(expireAge(60));
-    });
-  });
-  describe('REDIRECT entries (getStaticProps redirect)', () => {
-    const redirectData = {
-      kind: 'REDIRECT' as const,
-      // Next.js nests the redirect directives under `pageProps`, matching the
-      // real getStaticProps redirect payload asserted in the integration test.
-      props: {
-        pageProps: { __N_REDIRECT: '/target', __N_REDIRECT_STATUS: 307 },
-      },
-    };
-    it('set() and get() round-trip a REDIRECT entry without warnings', async () => {
-      const handler = createHandler();
-      await handler.set('/old-location', redirectData, {
-        ...baseCtx,
-        cacheControl: { revalidate: 30, expire: undefined },
-      });
-      const { entry, ex } = storedEntry('/old-location');
-      expect(entry).toEqual({
-        value: redirectData,
-        lastModified: expect.any(Number),
-        tags: ['_N_T_/old-location'],
-      });
-      expect(ex).toBe(expireAge(30));
-      const result = await handler.get('/old-location', {
-        kind: 'PAGES',
-        isFallback: false,
-      });
-      expect(result?.value).toEqual(redirectData);
-      expect(warnSpy).not.toHaveBeenCalled();
-      expect(errorSpy).not.toHaveBeenCalled();
-    });
-  });
-  describe('notFound entries (data === null)', () => {
-    it('set() stores a null-value entry without throwing or warning', async () => {
-      const handler = createHandler();
-      await handler.set('/missing-page', null, {
-        ...baseCtx,
-        cacheControl: { revalidate: 15, expire: undefined },
-      });
-      const { entry, ex } = storedEntry('/missing-page');
-      expect(entry).toEqual({
-        value: null,
-        lastModified: expect.any(Number),
-        tags: ['_N_T_/missing-page'],
-      });
-      expect(ex).toBe(expireAge(15));
-      expect(warnSpy).not.toHaveBeenCalled();
-      expect(errorSpy).not.toHaveBeenCalled();
-    });
-    it('get() returns the null-value entry without malformed warnings or errors', async () => {
-      const handler = createHandler();
-      await handler.set('/missing-page', null, {
-        ...baseCtx,
-        cacheControl: { revalidate: 15, expire: undefined },
-      });
-      const result = await handler.get('/missing-page', {
-        kind: 'PAGES',
-        isFallback: false,
-      });
-      expect(result).toEqual({
-        value: null,
-        lastModified: expect.any(Number),
-        tags: ['_N_T_/missing-page'],
-      });
-      expect(warnSpy).not.toHaveBeenCalled();
-      expect(errorSpy).not.toHaveBeenCalled();
-    });
-    it('get() still warns for a malformed entry with a missing (undefined) value', async () => {
-      const handler = createHandler();
-      hoisted.store.set(KEY_PREFIX + '/malformed', {
-        value: JSON.stringify({ lastModified: Date.now(), tags: [] }),
-      });
-      await handler.get('/malformed', {
-        kind: 'PAGES',
-        isFallback: false,
-      });
-      expect(warnSpy).toHaveBeenCalledWith(
-        'RedisStringsHandler.get() called with',
-        '/malformed',
-        expect.anything(),
-        'cacheEntry is mall formed (missing value)',
-      );
-    });
-  });
-  describe('App Router entries are unaffected', () => {
-    it('set() still extracts tags from the x-next-cache-tags header and adds no implicit tag', async () => {
-      const handler = createHandler();
-      await handler.set(
-        '/app-page',
-        {
-          kind: 'APP_PAGE',
-          html: '<html></html>',
-          rscData: Buffer.from('rsc'),
-          headers: {
-            'x-nextjs-stale-time': '1000',
-            'x-next-cache-tags': '_N_T_/layout,_N_T_/app-page',
-          },
-          segmentData: undefined,
-          postboned: undefined,
-        },
-        { ...baseCtx, cacheControl: { revalidate: 60, expire: undefined } },
-      );
-      const { entry } = storedEntry('/app-page');
-      expect(entry.tags).toEqual(['_N_T_/layout', '_N_T_/app-page']);
-      expect(warnSpy).not.toHaveBeenCalled();
-    });
-    it('set() still warns for unsupported kinds (e.g. IMAGE)', async () => {
-      const handler = createHandler();
-      await handler.set(
-        '/some-image',
-        { kind: 'IMAGE' } as unknown as Parameters<
-          RedisStringsHandler['set']
-        >[1],
-        baseCtx,
-      );
-      expect(warnSpy).toHaveBeenCalled();
-    });
-  });
-});

package/test/vitest/unit/reconnect-socket-already-opened.test.ts DELETED Viewed

@@ -1,117 +0,0 @@
-import { describe, it, expect, vi, afterEach } from 'vitest';
-vi.mock('redis', () => ({
-  createClient: vi.fn(() => {
-    const listeners = new Map<string, Function[]>();
-    const client = {
-      isOpen: false,
-      isReady: false,
-      on: vi.fn((event: string, cb: Function) => {
-        if (!listeners.has(event)) listeners.set(event, []);
-        listeners.get(event)!.push(cb);
-      }),
-      emit: vi.fn((event: string, ...args: unknown[]) => {
-        (listeners.get(event) ?? []).forEach((cb) => cb(...args));
-      }),
-      connect: vi.fn(async () => undefined),
-      disconnect: vi.fn(),
-      quit: vi.fn(async () => undefined),
-      duplicate: vi.fn(() => ({
-        connect: vi.fn(async () => undefined),
-        subscribe: vi.fn(async () => undefined),
-        on: vi.fn(),
-        quit: vi.fn(async () => undefined),
-        configGet: vi.fn(async () => ({ 'notify-keyspace-events': 'Exe' })),
-      })),
-      get: vi.fn(async () => null),
-      hScan: vi.fn(async () => ({ cursor: 0, tuples: [] })),
-      scan: vi.fn(async () => ({ cursor: 0, keys: [] })),
-      hSet: vi.fn(async () => 1),
-      hDel: vi.fn(async () => 1),
-      publish: vi.fn(async () => 1),
-      unlink: vi.fn(async () => 1),
-      set: vi.fn(async () => 'OK'),
-    };
-    return client;
-  }),
-  commandOptions: vi.fn((opts) => opts),
-}));
-vi.mock('../../../src/SyncedMap', () => {
-  class SyncedMap {
-    waitUntilReady = vi.fn(async () => undefined);
-    get = vi.fn(() => undefined);
-    set = vi.fn(async () => undefined);
-    delete = vi.fn(async () => undefined);
-    entries = vi.fn(function* () {
-      return;
-    });
-    constructor() {}
-  }
-  return { SyncedMap };
-});
-/**
- * Deterministic regression test for:
- *   "Failed to reconnect RedisCacheComponentsHandler client after connection loss: Error: Socket already opened"
- *
- * We simulate the node-redis client emitting an error while its socket is still considered open,
- * and we stub connect() to reject with "Socket already opened".
- */
-describe('RedisCacheComponentsHandler reconnect logic', () => {
-  afterEach(() => {
-    vi.useRealTimers();
-    vi.restoreAllMocks();
-  });
-  it('does not call connect() when an error occurs but the socket is already open (prevents "Socket already opened")', async () => {
-    vi.useFakeTimers();
-    vi.resetModules();
-    const consoleError = vi
-      .spyOn(console, 'error')
-      .mockImplementation(() => {});
-    const { getRedisCacheComponentsHandler } = await import('../../../src');
-    const handler = getRedisCacheComponentsHandler({
-      redisUrl: 'redis://127.0.0.1:6399',
-      clientOptions: {
-        // Avoid queueing commands in tests.
-        disableOfflineQueue: true,
-      } as any,
-    });
-    const client = (handler as any).client;
-    // Clear the initial connect() call from the constructor.
-    vi.mocked(client.connect).mockClear();
-    // Simulate a connection-loss situation where the socket is still open.
-    Object.defineProperty(client, 'isOpen', { value: true });
-    Object.defineProperty(client, 'isReady', { value: false });
-    // Stub connect() so we can assert it is NOT called.
-    const connectSpy = vi.spyOn(client, 'connect');
-    // Trigger the handler's on('error') callback.
-    client.emit('error', new Error('ECONNREFUSED 127.0.0.1:6379'));
-    // Reconnect is scheduled after 1000ms.
-    await vi.advanceTimersByTimeAsync(1100);
-    expect(connectSpy).not.toHaveBeenCalled();
-    const msgs = consoleError.mock.calls
-      .map((c) => c.map(String).join(' '))
-      .join('\n');
-    expect(msgs).not.toContain(
-      'Failed to reconnect RedisCacheComponentsHandler client after connection loss:',
-    );
-    expect(msgs).not.toContain('Socket already opened');
-  });
-});

package/test/vitest/unit/redis-connection.test.ts DELETED Viewed

@@ -1,39 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import {
-  PHASE_PRODUCTION_BUILD,
-  shouldDeferRedisConnection,
-} from '../../../src/utils/redisConnection';
-describe('shouldDeferRedisConnection', () => {
-  const originalPhase = process.env.NEXT_PHASE;
-  beforeEach(() => {
-    delete process.env.NEXT_PHASE;
-  });
-  afterEach(() => {
-    if (originalPhase === undefined) {
-      delete process.env.NEXT_PHASE;
-    } else {
-      process.env.NEXT_PHASE = originalPhase;
-    }
-  });
-  it('returns false when NEXT_PHASE is not set', () => {
-    expect(shouldDeferRedisConnection()).toBe(false);
-  });
-  it('returns true when NEXT_PHASE is phase-production-build', () => {
-    process.env.NEXT_PHASE = 'phase-production-build';
-    expect(shouldDeferRedisConnection()).toBe(true);
-  });
-  it('returns false for other Next.js phases', () => {
-    process.env.NEXT_PHASE = 'phase-production-server';
-    expect(shouldDeferRedisConnection()).toBe(false);
-  });
-  it('uses the Next.js PHASE_PRODUCTION_BUILD string', () => {
-    expect(PHASE_PRODUCTION_BUILD).toBe('phase-production-build');
-  });
-});

package/test/vitest/unit/serializer.test.ts DELETED Viewed

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