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

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

@@ -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);
-  });
-});

package/test/vitest/unit/utils/prefix.test.ts

@@ -1,115 +0,0 @@
-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 '../../../../src/utils/prefix';
-
-function withEnv<T>(env: Partial<NodeJS.ProcessEnv>, fn: () => T): T {
-  const original: NodeJS.ProcessEnv = { ...process.env };
-  Object.entries(env).forEach(([k, v]) => {
-    const envRec = process.env as Record<string, string | undefined>;
-    if (v === undefined) delete envRec[k];
-    else envRec[k] = v as string;
-  });
-  try {
-    return fn();
-  } finally {
-    process.env = original;
-  }
-}
-
-function makeBuildIdTree(buildId: string) {
-  const tmp = fs.mkdtempSync(path.join(os.tmpdir(), 'prefix-test-'));
-  const nextDir = path.join(tmp, '.next');
-  const serverDir = path.join(nextDir, 'server');
-  fs.mkdirSync(serverDir, { recursive: true });
-  fs.writeFileSync(path.join(nextDir, 'BUILD_ID'), buildId, 'utf8');
-  return {
-    serverDistDir: serverDir,
-    cleanup: () => fs.rmSync(tmp, { recursive: true, force: true }),
-  };
-}
-
-describe('resolveKeyPrefix', () => {
-  beforeEach(() => {
-    const envRec = process.env as Record<string, string | undefined>;
-    delete envRec.KEY_PREFIX;
-    delete envRec.VERCEL_URL;
-  });
-
-  it('returns option keyPrefix when provided (including empty string)', () => {
-    const p1 = resolveKeyPrefix({ optionKeyPrefix: 'opt_', env: process.env });
-    expect(p1).toBe('opt_');
-
-    const p2 = resolveKeyPrefix({ optionKeyPrefix: '', env: process.env });
-    expect(p2).toBe('');
-  });
-
-  it('uses KEY_PREFIX when option is undefined', () => {
-    const res = withEnv({ KEY_PREFIX: 'envkp_' }, () =>
-      resolveKeyPrefix({ optionKeyPrefix: undefined, env: process.env }),
-    );
-    expect(res).toBe('envkp_');
-  });
-
-  it('uses BUILD_ID when KEY_PREFIX and VERCEL_URL are absent and BUILD_ID readable', () => {
-    const { serverDistDir, cleanup } = makeBuildIdTree('BID123');
-    try {
-      const res = resolveKeyPrefix({
-        optionKeyPrefix: undefined,
-        env: process.env,
-        serverDistDir,
-      });
-      expect(res).toBe('BID123');
-    } finally {
-      cleanup();
-    }
-  });
-
-  it('uses VERCEL_URL before BUILD_ID when both are available', () => {
-    const { serverDistDir, cleanup } = makeBuildIdTree('BIDXYZ');
-    try {
-      const res = withEnv({ VERCEL_URL: 'vercel.example' }, () =>
-        resolveKeyPrefix({
-          optionKeyPrefix: undefined,
-          env: process.env,
-          serverDistDir,
-        }),
-      );
-      expect(res).toBe('vercel.example');
-    } finally {
-      cleanup();
-    }
-  });
-
-  it('uses VERCEL_URL when KEY_PREFIX and BUILD_ID not available', () => {
-    const res = withEnv({ VERCEL_URL: 'vercel.example' }, () =>
-      resolveKeyPrefix({ optionKeyPrefix: undefined, env: process.env }),
-    );
-    expect(res).toBe('vercel.example');
-  });
-
-  it('falls back to UNDEFINED_URL_ when nothing else available', () => {
-    const res = resolveKeyPrefix({
-      optionKeyPrefix: undefined,
-      env: process.env,
-    });
-    expect(res).toBe('UNDEFINED_URL_');
-  });
-
-  it('treats empty env values as absent', () => {
-    const { serverDistDir, cleanup } = makeBuildIdTree('BIDX');
-    try {
-      const res = withEnv({ KEY_PREFIX: '', VERCEL_URL: '' }, () =>
-        resolveKeyPrefix({
-          optionKeyPrefix: undefined,
-          env: process.env,
-          serverDistDir,
-        }),
-      );
-      expect(res).toBe('BIDX');
-    } finally {
-      cleanup();
-    }
-  });
-});

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "CommonJS",
-    "moduleResolution": "Node",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "declaration": true,
-    "declarationDir": "dist",
-    "outDir": "dist",
-    "emitDeclarationOnly": false,
-    "resolveJsonModule": true
-  },
-  "include": ["src", "vitest.config.ts"],
-  "exclude": ["node_modules", "dist"],
-  "types": ["vitest"]
-}

package/tsup.config.ts

@@ -1,14 +0,0 @@
-import { defineConfig } from 'tsup';
-
-export default defineConfig({
-  entry: ['src/index.ts'],
-  outDir: 'dist',
-  format: ['esm', 'cjs'],
-  dts: true,
-  splitting: false,
-  sourcemap: true,
-  clean: true,
-  target: 'es2020',
-  shims: false,
-  minify: false,
-});

package/vite.config.ts

@@ -1,34 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    include: [
-      'test/vitest/unit/**/*.test.ts',
-      'test/vitest/unit/**/*.test.tsx',
-      'test/vitest/integration/**/*.test.ts',
-    ],
-    exclude: [
-      'node_modules',
-      'dist',
-      '.git',
-      '**/node_modules/**',
-      '**/node_modules',
-      'test/vitest/integration/cache-components/**',
-    ],
-    coverage: {
-      provider: 'v8',
-      reporter: ['text', 'lcov'],
-      include: process.env.VITEST_COVERAGE_INCLUDE?.split(',') || [
-        'src/**/*.ts',
-      ],
-      exclude: [
-        'node_modules',
-        'dist',
-        '**/node_modules/**',
-        '**/node_modules',
-      ],
-    },
-  },
-});

package/vitest.cache-components.config.ts

@@ -1,16 +0,0 @@
-import { defineConfig } from 'vitest/config';
-
-export default defineConfig({
-  test: {
-    globals: true,
-    environment: 'node',
-    include: ['test/vitest/integration/cache-components/**/*.test.ts'],
-    exclude: [
-      'node_modules',
-      'dist',
-      '.git',
-      '**/node_modules/**',
-      '**/node_modules',
-    ],
-  },
-});