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

package/test/vitest/unit/tag-revalidation.test.ts

@@ -1,178 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  applyTagUpdate,
-  areTagsExpired,
-  areTagsStale,
-  maxExpiredTimestamp,
-  normalizeTagManifest,
-  persistableTagManifest,
-  type TagManifestEntry,
-} from '../../../src/utils/tagRevalidation';
-
-// Expire seconds from next/dist/server/config-shared.js cacheLife presets
-// (identical in Next.js 16.0.11, 16.2.6, 16.3.0).
-const CACHE_LIFE_EXPIRE_SECONDS = {
-  default: 0xfffffffe, // INFINITE_CACHE in next/dist/lib/constants.js
-  seconds: 60,
-  minutes: 60 * 60,
-  hours: 60 * 60 * 24,
-  days: 60 * 60 * 24 * 7,
-  weeks: 60 * 60 * 24 * 30,
-  max: 60 * 60 * 24 * 365,
-};
-
-describe('applyTagUpdate (Next.js DefaultCacheHandler.updateTags)', () => {
-  const now = 1_000_000;
-
-  it('with no durations sets expired=now and does not set stale', () => {
-    expect(applyTagUpdate({ stale: 9 }, undefined, now)).toEqual({
-      stale: 9,
-      expired: now,
-    });
-  });
-
-  it('with { expire: 0 } sets stale=now and expired=now (blocking miss)', () => {
-    expect(applyTagUpdate({}, { expire: 0 }, now)).toEqual({
-      stale: now,
-      expired: now,
-    });
-  });
-
-  it('with { expire: N } sets stale=now and expired=now+N*1000 (SWR window)', () => {
-    expect(applyTagUpdate({}, { expire: 2 }, now)).toEqual({
-      stale: now,
-      expired: now + 2_000,
-    });
-  });
-
-  it('uses each built-in cacheLife expire for revalidateTag(tag, profile)', () => {
-    for (const [profile, expire] of Object.entries(CACHE_LIFE_EXPIRE_SECONDS)) {
-      const result = applyTagUpdate({}, { expire }, now);
-      expect(result.stale, profile).toBe(now);
-      expect(result.expired, profile).toBe(now + expire * 1000);
-    }
-  });
-
-  it('with durations but expire undefined only marks stale (keeps prior expired)', () => {
-    expect(applyTagUpdate({ expired: 50 }, { expire: undefined }, now)).toEqual(
-      { stale: now, expired: 50 },
-    );
-  });
-});
-
-describe('areTagsExpired / areTagsStale (Next.js tags-manifest.external)', () => {
-  const lookup = (entry: { stale?: number; expired?: number }) => () => entry;
-
-  it('hard-expires when expired has elapsed and is newer than the entry', () => {
-    expect(areTagsExpired(['t'], 100, 1_000, lookup({ expired: 500 }))).toBe(
-      true,
-    );
-  });
-
-  it('does not hard-expire while expired is still in the future', () => {
-    expect(areTagsExpired(['t'], 100, 1_000, lookup({ expired: 2_000 }))).toBe(
-      false,
-    );
-  });
-
-  it('does not hard-expire when expiredAt equals the entry timestamp', () => {
-    expect(areTagsExpired(['t'], 500, 1_000, lookup({ expired: 500 }))).toBe(
-      false,
-    );
-  });
-
-  it('does not hard-expire entries created after the expired timestamp', () => {
-    expect(
-      areTagsExpired(['t'], 2_000, 3_000, lookup({ expired: 1_000 })),
-    ).toBe(false);
-  });
-
-  it('is stale when stale is newer than the entry timestamp', () => {
-    expect(areTagsStale(['t'], 100, lookup({ stale: 500 }))).toBe(true);
-  });
-
-  it('is not stale when stale is older than the entry', () => {
-    expect(areTagsStale(['t'], 1_000, lookup({ stale: 500 }))).toBe(false);
-  });
-});
-
-describe('maxExpiredTimestamp (Next.js getExpiration)', () => {
-  it('returns 0 when no tag was expired', () => {
-    expect(maxExpiredTimestamp(['a'], () => ({}))).toBe(0);
-  });
-
-  it('returns a future expired timestamp (SWR window has not elapsed)', () => {
-    expect(
-      maxExpiredTimestamp(['a'], () => ({ stale: 1, expired: 9_000 })),
-    ).toBe(9_000);
-  });
-});
-
-describe('normalizeTagManifest', () => {
-  it('reads Next.js { stale, expired } records', () => {
-    expect(normalizeTagManifest({ stale: 1, expired: 2 })).toEqual({
-      stale: 1,
-      expired: 2,
-    });
-  });
-
-  it('maps a legacy numeric timestamp to expired', () => {
-    expect(normalizeTagManifest(1_234)).toEqual({ expired: 1_234 });
-  });
-});
-
-describe('legacy plain numbers (rolling upgrade, not Next.js)', () => {
-  const lookup = (entry: TagManifestEntry | undefined) => (tag: string) =>
-    tag === 't' ? entry : undefined;
-
-  it('past plain number hard-expires entries older than the revalidation', () => {
-    const revalidatedAt = 500;
-    const manifest = normalizeTagManifest(revalidatedAt);
-
-    expect(areTagsExpired(['t'], 100, 1_000, lookup(manifest))).toBe(true);
-    expect(areTagsStale(['t'], 100, lookup(manifest))).toBe(false);
-  });
-
-  it('clamps future plain numbers to now (cross-instance clock skew)', () => {
-    // Instance A (clock ahead) wrote Date.now() = 1_005_000 into Redis.
-    // This reader's clock is still at 1_000_000 — clamp treats it as now.
-    const manifest = normalizeTagManifest(1_005_000, 1_000_000);
-
-    expect(manifest).toEqual({ expired: 1_000_000 });
-    expect(areTagsExpired(['t'], 900_000, 1_000_000, lookup(manifest))).toBe(
-      true,
-    );
-  });
-
-  it('intentional SWR uses stale + future expired, not a plain number', () => {
-    const now = 1_000_000;
-    const swr = applyTagUpdate({}, { expire: 2 }, now);
-
-    expect(swr).toEqual({ stale: now, expired: now + 2_000 });
-    expect(areTagsStale(['t'], 900_000, lookup(swr))).toBe(true);
-    expect(areTagsExpired(['t'], 900_000, now + 500, lookup(swr))).toBe(false);
-  });
-});
-
-describe('persistableTagManifest', () => {
-  const now = 1_000_000;
-
-  it('writes a plain number for immediate hard-expires (rolling-upgrade readers)', () => {
-    expect(persistableTagManifest({ expired: now }, now)).toBe(now);
-    expect(persistableTagManifest({ stale: now, expired: now }, now)).toBe(now);
-  });
-
-  it('keeps { stale, expired } objects for SWR windows', () => {
-    const swr = { stale: now, expired: now + 2_000 };
-    expect(persistableTagManifest(swr, now)).toEqual(swr);
-  });
-
-  it('keeps the object when a newer stale-only update outruns a past expired', () => {
-    const expired = now - 5_000;
-    const stale = now;
-    expect(persistableTagManifest({ stale, expired }, now)).toEqual({
-      stale,
-      expired,
-    });
-  });
-});

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',
-    ],
-  },
-});