@trieb.work/nextjs-turbo-redis-cache 1.18.0 → 1.18.1

package/test/vitest/unit/cache-components-update-tags.test.ts

@@ -1,350 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-const hoisted = vi.hoisted(() => {
-  const store = new Map<string, string>();
-  const unlinkedKeys: string[] = [];
-  return { store, unlinkedKeys };
-});
-
-vi.mock('redis', () => {
-  const createClient = () => {
-    const client = {
-      isReady: true,
-      isOpen: 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' })),
-        isOpen: true,
-        isReady: true,
-      })),
-      get: vi.fn(
-        async (_opts: unknown, key: string) => hoisted.store.get(key) ?? 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 (keys: string | string[]) => {
-        const list = Array.isArray(keys) ? keys : [keys];
-        for (const key of list) {
-          hoisted.unlinkedKeys.push(key);
-          hoisted.store.delete(key);
-        }
-        return list.length;
-      }),
-      eval: vi.fn(
-        async (
-          _script: string,
-          options: { keys: string[]; arguments: string[] },
-        ) => {
-          const key = options.keys[0];
-          const expected = options.arguments[0];
-          if (hoisted.store.get(key) === expected) {
-            hoisted.unlinkedKeys.push(key);
-            hoisted.store.delete(key);
-            return 1;
-          }
-          return 0;
-        },
-      ),
-      set: vi.fn(async (key: string, value: string) => {
-        hoisted.store.set(key, value);
-        return 'OK';
-      }),
-    };
-    return client;
-  };
-
-  return {
-    createClient,
-    commandOptions: vi.fn((opts) => opts),
-  };
-});
-
-function cachedEntry(tags: string[], timestamp: number) {
-  return {
-    value: new ReadableStream<Uint8Array>({
-      start(controller) {
-        controller.enqueue(new TextEncoder().encode('cached'));
-        controller.close();
-      },
-    }),
-    tags,
-    stale: 1,
-    timestamp,
-    expire: 3600,
-    revalidate: 60,
-  };
-}
-
-describe('RedisCacheComponentsHandler.updateTags vs Next.js default handler', () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-    hoisted.store.clear();
-    hoisted.unlinkedKeys.length = 0;
-    vi.resetModules();
-  });
-
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  async function createHandler(keyPrefix: string) {
-    const { getRedisCacheComponentsHandler } = await import(
-      '../../../src/CacheComponentsHandler'
-    );
-
-    return getRedisCacheComponentsHandler({
-      keyPrefix,
-      redisGetDeduplication: false,
-    });
-  }
-
-  it('SWR expire keeps the entry and sets revalidate=-1 until the window elapses', async () => {
-    const handler = await createHandler('swr:');
-    const createdAt = Date.now();
-
-    await handler.set(
-      'page',
-      Promise.resolve(cachedEntry(['posts'], createdAt)),
-    );
-    // Next.js areTagsStale/areTagsExpired require stale/expired > entry.timestamp.
-    await vi.advanceTimersByTimeAsync(1);
-    const revalidatedAt = Date.now();
-    await handler.updateTags(['posts'], { expire: 2 });
-
-    expect(await handler.getExpiration(['posts'])).toBe(revalidatedAt + 2_000);
-
-    const served = await handler.get('page', []);
-    expect(served).toBeDefined();
-    expect(served?.revalidate).toBe(-1);
-    expect(hoisted.unlinkedKeys).toEqual([]);
-
-    await vi.advanceTimersByTimeAsync(2_000);
-    expect(await handler.get('page', [])).toBeUndefined();
-  });
-
-  it('cacheLife max expire (~1y) is SWR, not a delay before staleness', async () => {
-    const handler = await createHandler('max:');
-    const createdAt = Date.now();
-    const oneYear = 60 * 60 * 24 * 365;
-
-    await handler.set(
-      'page',
-      Promise.resolve(cachedEntry(['posts'], createdAt)),
-    );
-    await vi.advanceTimersByTimeAsync(1);
-    const revalidatedAt = Date.now();
-    await handler.updateTags(['posts'], { expire: oneYear });
-
-    expect(await handler.getExpiration(['posts'])).toBe(
-      revalidatedAt + oneYear * 1000,
-    );
-    const served = await handler.get('page', []);
-    expect(served?.revalidate).toBe(-1);
-    expect(await handler.get('page', [])).toBeDefined();
-  });
-
-  it('omitted durations is a blocking miss (updateTag / deprecated revalidateTag)', async () => {
-    const handler = await createHandler('hard:');
-    const createdAt = Date.now();
-
-    await handler.set(
-      'page',
-      Promise.resolve(cachedEntry(['posts'], createdAt)),
-    );
-    await vi.advanceTimersByTimeAsync(1);
-    const revalidatedAt = Date.now();
-    await handler.updateTags(['posts']);
-
-    expect(await handler.getExpiration(['posts'])).toBe(revalidatedAt);
-    expect((handler as any).revalidatedTagsMap.get('posts')).toBe(
-      revalidatedAt,
-    );
-    expect(await handler.get('page', [])).toBeUndefined();
-  });
-
-  it('{ expire: 0 } is a blocking miss', async () => {
-    const handler = await createHandler('zero:');
-    const createdAt = Date.now();
-
-    await handler.set(
-      'page',
-      Promise.resolve(cachedEntry(['posts'], createdAt)),
-    );
-    await vi.advanceTimersByTimeAsync(1);
-    const revalidatedAt = Date.now();
-    await handler.updateTags(['posts'], { expire: 0 });
-
-    expect(await handler.getExpiration(['posts'])).toBe(revalidatedAt);
-    expect((handler as any).revalidatedTagsMap.get('posts')).toBe(
-      revalidatedAt,
-    );
-    expect(await handler.get('page', [])).toBeUndefined();
-  });
-
-  it('persists stale+expired so a later getExpiration still sees the window', async () => {
-    const handler = await createHandler('persist:');
-    const startedAt = Date.now();
-
-    await handler.updateTags(['posts'], { expire: 2 });
-    const stored = (handler as any).revalidatedTagsMap.get('posts');
-
-    expect(stored).toEqual({
-      stale: startedAt,
-      expired: startedAt + 2_000,
-    });
-  });
-
-  it('legacy plain number in Redis hard-expires once the timestamp is in the past', async () => {
-    const handler = await createHandler('legacy-past:');
-    const createdAt = Date.now() - 10_000;
-
-    await handler.set(
-      'page',
-      Promise.resolve(cachedEntry(['posts'], createdAt)),
-    );
-
-    // Older package versions stored Date.now() directly (not Next.js).
-    (handler as any).revalidatedTagsMap.set('posts', Date.now() - 5_000);
-
-    expect(await handler.get('page', [])).toBeUndefined();
-  });
-
-  it('legacy plain number ahead of local clock is clamped and hard-expires immediately', async () => {
-    vi.setSystemTime(new Date(1_000_000));
-    const handler = await createHandler('legacy-skew:');
-    const createdAt = 900_000;
-
-    await handler.set(
-      'page',
-      Promise.resolve(cachedEntry(['posts'], createdAt)),
-    );
-
-    // Another instance with a faster clock wrote this value to Redis.
-    (handler as any).revalidatedTagsMap.set('posts', 1_005_000);
-
-    expect(await handler.get('page', [])).toBeUndefined();
-  });
-
-  it.each([
-    ['seconds', 60],
-    ['minutes', 60 * 60],
-    ['hours', 60 * 60 * 24],
-    ['days', 60 * 60 * 24 * 7],
-    ['weeks', 60 * 60 * 24 * 30],
-    ['max', 60 * 60 * 24 * 365],
-    ['default', 0xfffffffe],
-  ] as const)(
-    'cacheLife %s expire writes getExpiration=now+expire*1000 and SWR',
-    async (_profile, expireSeconds) => {
-      const handler = await createHandler(`preset-${_profile}:`);
-      const createdAt = Date.now();
-
-      await handler.set(
-        'page',
-        Promise.resolve(cachedEntry(['posts'], createdAt)),
-      );
-      await vi.advanceTimersByTimeAsync(1);
-      const revalidatedAt = Date.now();
-      await handler.updateTags(['posts'], { expire: expireSeconds });
-
-      expect(await handler.getExpiration(['posts'])).toBe(
-        revalidatedAt + expireSeconds * 1000,
-      );
-      const served = await handler.get('page', []);
-      expect(served?.revalidate).toBe(-1);
-      expect(await handler.get('page', [])).toBeDefined();
-    },
-  );
-
-  it('does not UNLINK a Redis replacement after a stale deduped read', async () => {
-    const { getRedisCacheComponentsHandler } = await import(
-      '../../../src/CacheComponentsHandler'
-    );
-    const handler = getRedisCacheComponentsHandler({
-      keyPrefix: 'dedup-unlink:',
-      redisGetDeduplication: true,
-      inMemoryCachingTime: 10_000,
-    });
-
-    const createdAt = Date.now();
-    await handler.set(
-      'page',
-      Promise.resolve(cachedEntry(['posts'], createdAt)),
-    );
-    const redisKey = 'dedup-unlink:page';
-    const oldSerialized = hoisted.store.get(redisKey)!;
-
-    await vi.advanceTimersByTimeAsync(1);
-    await handler.updateTags(['posts']);
-
-    const freshAt = Date.now();
-    hoisted.store.set(
-      redisKey,
-      JSON.stringify({
-        value: Buffer.from('fresh').toString('base64'),
-        tags: ['posts'],
-        stale: 1,
-        timestamp: freshAt,
-        expire: 3600,
-        revalidate: 60,
-      }),
-    );
-    (handler as any).redisDeduplicationHandler.seedRequestReturn(
-      'page',
-      oldSerialized,
-    );
-
-    hoisted.unlinkedKeys.length = 0;
-    const served = await handler.get('page', []);
-
-    expect(hoisted.unlinkedKeys).toEqual([]);
-    expect(served).toBeDefined();
-    expect(hoisted.store.get(redisKey)).toBeTruthy();
-  });
-
-  it('keeps a later stale-only update after a hard expire and replacement', async () => {
-    const handler = await createHandler('stale-after-hard:');
-    const createdAt = Date.now();
-
-    await handler.set(
-      'page',
-      Promise.resolve(cachedEntry(['posts'], createdAt)),
-    );
-    await vi.advanceTimersByTimeAsync(1);
-    const hardExpiredAt = Date.now();
-    await handler.updateTags(['posts']);
-    expect((handler as any).revalidatedTagsMap.get('posts')).toBe(
-      hardExpiredAt,
-    );
-
-    await vi.advanceTimersByTimeAsync(1);
-    const replacementAt = Date.now();
-    await handler.set(
-      'page',
-      Promise.resolve(cachedEntry(['posts'], replacementAt)),
-    );
-
-    await vi.advanceTimersByTimeAsync(1);
-    const staleAt = Date.now();
-    await handler.updateTags(['posts'], {});
-
-    expect((handler as any).revalidatedTagsMap.get('posts')).toEqual({
-      stale: staleAt,
-      expired: hardExpiredAt,
-    });
-
-    const served = await handler.get('page', []);
-    expect(served).toBeDefined();
-    expect(served?.revalidate).toBe(-1);
-  });
-});

package/test/vitest/unit/cache-ttl.test.ts

@@ -1,67 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { resolveCacheEntryTtlSeconds } from '../../../src/utils/cacheTtl';
-
-const estimateExpireAge = (staleAge: number) => staleAge * 1.2;
-const defaultStaleAge = 60 * 60 * 24 * 14;
-
-describe('resolveCacheEntryTtlSeconds', () => {
-  it('prefers cacheControl.expire over revalidate (SWR-safe TTL)', () => {
-    const ttl = resolveCacheEntryTtlSeconds(
-      { cacheControl: { revalidate: 60, expire: 3600 } },
-      { kind: 'APP_PAGE' },
-      { estimateExpireAge, defaultStaleAge },
-    );
-
-    expect(ttl).toBe(3600);
-  });
-
-  it('falls back to estimateExpireAge(revalidate) when expire is omitted', () => {
-    const ttl = resolveCacheEntryTtlSeconds(
-      { cacheControl: { revalidate: 60, expire: undefined } },
-      { kind: 'PAGES' },
-      { estimateExpireAge, defaultStaleAge },
-    );
-
-    expect(ttl).toBe(72);
-  });
-
-  it('uses FETCH data.revalidate when cacheControl is absent', () => {
-    const ttl = resolveCacheEntryTtlSeconds(
-      {},
-      { kind: 'FETCH', revalidate: 30 },
-      { estimateExpireAge, defaultStaleAge },
-    );
-
-    expect(ttl).toBe(36);
-  });
-
-  it('uses defaultStaleAge when revalidate is false', () => {
-    const ttl = resolveCacheEntryTtlSeconds(
-      { cacheControl: { revalidate: false, expire: undefined } },
-      { kind: 'PAGES' },
-      { estimateExpireAge, defaultStaleAge },
-    );
-
-    expect(ttl).toBe(estimateExpireAge(defaultStaleAge));
-  });
-
-  it('returns undefined when no expire or revalidate is provided', () => {
-    const ttl = resolveCacheEntryTtlSeconds(
-      { cacheControl: { revalidate: undefined, expire: undefined } },
-      { kind: 'APP_ROUTE' },
-      { estimateExpireAge, defaultStaleAge },
-    );
-
-    expect(ttl).toBeUndefined();
-  });
-
-  it('supports legacy ctx.revalidate (Next.js 15.0.3)', () => {
-    const ttl = resolveCacheEntryTtlSeconds(
-      { revalidate: 60 },
-      { kind: 'PAGES' },
-      { estimateExpireAge, defaultStaleAge },
-    );
-
-    expect(ttl).toBe(72);
-  });
-});

package/test/vitest/unit/compare-and-unlink.test.ts

@@ -1,22 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-import { compareAndUnlink } from '../../../src/utils/compareAndUnlink';
-
-describe('compareAndUnlink', () => {
-  it('evals GET+UNLINK and reports whether the key was removed', async () => {
-    const evalFn = vi.fn(async () => 1);
-    await expect(compareAndUnlink({ eval: evalFn }, 'k', 'old')).resolves.toBe(
-      true,
-    );
-    expect(evalFn).toHaveBeenCalledWith(
-      expect.stringContaining("redis.call('UNLINK'"),
-      { keys: ['k'], arguments: ['old'] },
-    );
-  });
-
-  it('returns false when the value no longer matches', async () => {
-    const evalFn = vi.fn(async () => 0);
-    await expect(compareAndUnlink({ eval: evalFn }, 'k', 'old')).resolves.toBe(
-      false,
-    );
-  });
-});

package/test/vitest/unit/index.test.ts

@@ -1,190 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-
-import type { CreateRedisStringsHandlerOptions } from '../../../src/index';
-import RedisStringsHandler from '../../../src/RedisStringsHandler';
-
-vi.mock('redis', () => {
-  const createClient = vi.fn(() => {
-    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 () => {
-        const err = new Error('timeout') as Error & { name: string };
-        err.name = 'AbortError';
-        throw err;
-      }),
-      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 {
-    createClient,
-    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 };
-});
-
-describe('RedisStringsHandler', () => {
-  beforeEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  afterEach(() => {
-    vi.unstubAllEnvs();
-  });
-
-  it('treats aborted GET (timeout) as cache miss without console.error', async () => {
-    const consoleErrorSpy = vi
-      .spyOn(console, 'error')
-      .mockImplementation(() => undefined);
-
-    const handler = new RedisStringsHandler({
-      redisUrl: 'redis://localhost:6379',
-      keyPrefix: 'test:',
-      database: 0,
-      getTimeoutMs: 1,
-      redisGetDeduplication: false,
-    });
-
-    const res = await handler.get('missing-key', {
-      kind: 'APP_PAGE',
-      isRoutePPREnabled: false,
-      isFallback: false,
-    });
-
-    expect(res).toBeNull();
-    expect(consoleErrorSpy).not.toHaveBeenCalled();
-  });
-
-  it('does not leave the readiness timeout timer pending after an operation', async () => {
-    vi.useFakeTimers();
-    try {
-      const handler = new RedisStringsHandler({
-        redisUrl: 'redis://localhost:6379',
-        keyPrefix: 'test:',
-        database: 0,
-        getTimeoutMs: 1,
-        redisGetDeduplication: false,
-      });
-
-      const timersBefore = vi.getTimerCount();
-      await handler.get('missing-key', {
-        kind: 'APP_PAGE',
-        isRoutePPREnabled: false,
-        isFallback: false,
-      });
-
-      // assertClientIsReady() races waitUntilReady() against a 30s timeout;
-      // the timer must not stay pending once the race is settled, because
-      // pending timers retain the ambient async context (and with it, in a
-      // Next.js server, the whole per-request object graph).
-      expect(vi.getTimerCount()).toBe(timersBefore);
-    } finally {
-      vi.useRealTimers();
-    }
-  });
-
-  it('skips Redis work in revalidateTag during next build', async () => {
-    vi.stubEnv('NEXT_PHASE', 'phase-production-build');
-    const { default: Handler } = await import(
-      '../../../src/RedisStringsHandler'
-    );
-    const handler = new Handler({
-      redisUrl: 'redis://localhost:6379',
-      keyPrefix: 'build:',
-      database: 0,
-      redisGetDeduplication: false,
-    });
-    const unlink = (handler as any).client.unlink as ReturnType<typeof vi.fn>;
-
-    await expect(handler.revalidateTag('posts')).resolves.toBeUndefined();
-    expect(unlink).not.toHaveBeenCalled();
-  });
-});
-
-describe('Public exports', () => {
-  it('exports CreateRedisStringsHandlerOptions type', () => {
-    const _typeCheck: CreateRedisStringsHandlerOptions = {
-      keyPrefix: 'test',
-    };
-
-    expect(_typeCheck.keyPrefix).toBe('test');
-  });
-});
-
-describe('redisCacheHandler lazy proxy', () => {
-  it('does not construct a Redis connection on import', async () => {
-    vi.resetModules();
-    const { createClient } = await import('redis');
-    vi.mocked(createClient).mockClear();
-
-    // Importing the module should NOT trigger a Redis connection
-    await import('../../../src');
-
-    expect(vi.mocked(createClient)).not.toHaveBeenCalled();
-  });
-
-  it('has trap returns true for known methods without constructing the handler', async () => {
-    vi.resetModules();
-    const { createClient } = await import('redis');
-    vi.mocked(createClient).mockClear();
-
-    const { redisCacheHandler } = await import('../../../src');
-
-    expect('getExpiration' in redisCacheHandler).toBe(true);
-    expect('get' in redisCacheHandler).toBe(true);
-    expect('set' in redisCacheHandler).toBe(true);
-    expect('refreshTags' in redisCacheHandler).toBe(true);
-    expect('updateTags' in redisCacheHandler).toBe(true);
-
-    expect(vi.mocked(createClient)).not.toHaveBeenCalled();
-  });
-
-  it('method call delegates to the singleton and binds correctly', async () => {
-    vi.resetModules();
-    const { createClient } = await import('redis');
-    vi.mocked(createClient).mockClear();
-
-    const { redisCacheHandler } = await import('../../../src');
-
-    // Accessing a method triggers construction and delegates to the real handler
-    const getFn = redisCacheHandler.get;
-    expect(typeof getFn).toBe('function');
-    expect(vi.mocked(createClient)).toHaveBeenCalledTimes(1);
-
-    // Subsequent accesses reuse the same singleton (no extra construction)
-    const getFn2 = redisCacheHandler.get;
-    expect(vi.mocked(createClient)).toHaveBeenCalledTimes(1);
-    expect(typeof getFn2).toBe('function');
-  });
-});