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

package/test/nextjs-test-projects/next-pages-16-3-0/src/pages/api/revalidate.ts

@@ -0,0 +1,24 @@
+import type { NextApiRequest, NextApiResponse } from 'next';
+
+// On-demand revalidation endpoint: res.revalidate(path) re-renders the page
+// and writes the fresh entry through the cache handler, so all instances
+// sharing the same Redis pick it up.
+export default async function handler(
+  req: NextApiRequest,
+  res: NextApiResponse,
+) {
+  const path = req.query.path;
+  if (typeof path !== 'string') {
+    return res
+      .status(400)
+      .json({ revalidated: false, error: 'Missing ?path= query parameter' });
+  }
+  try {
+    await res.revalidate(path);
+    return res.json({ revalidated: true, path });
+  } catch (err) {
+    return res
+      .status(500)
+      .json({ revalidated: false, path, error: String(err) });
+  }
+}

package/test/nextjs-test-projects/next-pages-16-3-0/src/pages/index.tsx

@@ -0,0 +1,11 @@
+export default function Home() {
+  return (
+    <main>
+      <h1>Pages Router test app</h1>
+      <p>
+        Fixture for testing the Redis cache handler with the Next.js Pages
+        Router (PAGES, REDIRECT and notFound cache entries).
+      </p>
+    </main>
+  );
+}

package/test/nextjs-test-projects/next-pages-16-3-0/src/pages/isr/[slug].tsx

@@ -0,0 +1,49 @@
+import type { GetStaticPaths, GetStaticProps } from 'next';
+
+type Props = { slug: string; timestamp: number; counter: number };
+
+// Per-process regeneration counter. Two server instances of the same build
+// have independent counters, while the timestamp proves cross-instance
+// freshness after on-demand revalidation.
+let regenerationCounter = 0;
+
+export default function IsrPage({ slug, timestamp, counter }: Props) {
+  return (
+    <main>
+      <h1>ISR page</h1>
+      <p>Slug: {slug}</p>
+      <p>Timestamp: {timestamp}</p>
+      <p>Counter: {counter}</p>
+    </main>
+  );
+}
+
+export const getStaticPaths: GetStaticPaths = async () => {
+  return {
+    paths: [{ params: { slug: 'prebuilt' } }],
+    fallback: 'blocking',
+  };
+};
+
+// revalidate is set high (300s) so that natural ISR regeneration does not
+// interfere with the on-demand revalidation (res.revalidate) tests.
+export const getStaticProps: GetStaticProps<Props> = async (context) => {
+  const slug = context.params?.slug as string;
+
+  if (slug === 'not-found') {
+    return { notFound: true, revalidate: 300 };
+  }
+
+  if (slug === 'redirect') {
+    return {
+      redirect: { destination: '/static-forever', permanent: false },
+      revalidate: 300,
+    };
+  }
+
+  regenerationCounter += 1;
+  return {
+    props: { slug, timestamp: Date.now(), counter: regenerationCounter },
+    revalidate: 300,
+  };
+};

package/test/nextjs-test-projects/next-pages-16-3-0/src/pages/static-forever.tsx

@@ -0,0 +1,20 @@
+import type { GetStaticProps } from 'next';
+
+type Props = { timestamp: number };
+
+export default function StaticForever({ timestamp }: Props) {
+  return (
+    <main>
+      <h1>Static forever</h1>
+      <p>Timestamp: {timestamp}</p>
+    </main>
+  );
+}
+
+// revalidate is intentionally omitted (revalidate: false): the cache entry
+// must fall through to the defaultStaleAge based TTL in the cache handler.
+export const getStaticProps: GetStaticProps<Props> = async () => {
+  return {
+    props: { timestamp: Date.now() },
+  };
+};

package/test/nextjs-test-projects/next-pages-16-3-0/tsconfig.json

@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+  "exclude": ["node_modules"]
+}

package/test/vitest/integration/nextjs-cache-handler.integration.test.ts

@@ -7,7 +7,7 @@ import { CacheEntry } from '../../../src/RedisStringsHandler';
 import { revalidate as revalidatedFetchRouteRevalidate } from '../../nextjs-test-projects/next-app-15-4-11/src/app/api/revalidated-fetch/route';
 
 // Select which Next.js test app to use. Can be overridden via NEXT_TEST_APP env var
-// Examples: next-app-15-4-11, next-app-16-0-11, next-app-16-2-6
+// Examples: next-app-15-4-11, next-app-16-0-11, next-app-16-2-6, next-app-16-3-0
 const NEXT_TEST_APP = process.env.NEXT_TEST_APP || 'next-app-15-4-11';
 const NEXT_APP_DIR = join(
   __dirname,
@@ -17,6 +17,8 @@ const NEXT_APP_DIR = join(
   NEXT_TEST_APP,
 );
 console.log('NEXT_APP_DIR', NEXT_APP_DIR);
+
+const SHARED_TAGS_KEY = '__sharedTags__';
 const NEXT_START_PORT = 3055;
 const NEXT_START_URL = `http://localhost:${NEXT_START_PORT}`;
 
@@ -29,6 +31,20 @@ async function delay(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+async function findFetchCacheEntryKey(tag: string): Promise<string> {
+  const sharedTags = await redisClient.hGetAll(
+    process.env.VERCEL_URL + SHARED_TAGS_KEY,
+  );
+  const matches = Object.entries(sharedTags).filter(
+    ([key, serializedTags]) =>
+      !key.startsWith('/') &&
+      (JSON.parse(serializedTags) as string[]).includes(tag),
+  );
+
+  expect(matches).toHaveLength(1);
+  return matches[0]![0];
+}
+
 async function runCommand(cmd: string, args: string[], cwd: string) {
   return new Promise((resolve, reject) => {
     let stderr = '';
@@ -64,7 +80,7 @@ async function runCommand(cmd: string, args: string[], cwd: string) {
   });
 }
 
-async function waitForServer(url, timeout = 20000) {
+async function waitForServer(url: string, timeout = 20000) {
   const start = Date.now();
   while (Date.now() - start < timeout) {
     try {
@@ -226,7 +242,7 @@ describe('Next.js Turbo Redis Cache Integration', () => {
         expect(keys.length).toBe(0);
 
         const hashmap = await redisClient.hGet(
-          process.env.VERCEL_URL + '__sharedTags__',
+          process.env.VERCEL_URL + SHARED_TAGS_KEY,
           '/api/cached-static-fetch',
         );
         expect(hashmap).toBeNull();
@@ -247,7 +263,7 @@ describe('Next.js Turbo Redis Cache Integration', () => {
         expect(keys.length).toBe(1);
 
         const hashmap = (await redisClient.hGet(
-          process.env.VERCEL_URL + '__sharedTags__',
+          process.env.VERCEL_URL + SHARED_TAGS_KEY,
           '/api/cached-static-fetch',
         )) as string;
         expect(JSON.parse(hashmap)).toEqual([
@@ -317,7 +333,7 @@ describe('Next.js Turbo Redis Cache Integration', () => {
 
           // The key should also be removed from the hashmap
           const hashmap = await redisClient.hGet(
-            process.env.VERCEL_URL + '__sharedTags__',
+            process.env.VERCEL_URL + SHARED_TAGS_KEY,
             '/api/revalidated-fetch',
           );
           expect(hashmap).toBeNull();
@@ -339,7 +355,7 @@ describe('Next.js Turbo Redis Cache Integration', () => {
           expect(keys.length).toBe(0);
 
           const hashmap = await redisClient.hGet(
-            process.env.VERCEL_URL + '__sharedTags__',
+            process.env.VERCEL_URL + SHARED_TAGS_KEY,
             cachedStaticPath,
           );
           expect(hashmap).toBeNull();
@@ -495,7 +511,7 @@ describe('Next.js Turbo Redis Cache Integration', () => {
             expect(keys.length).toBe(0);
 
             const hashmap = await redisClient.hGet(
-              process.env.VERCEL_URL + '__sharedTags__',
+              process.env.VERCEL_URL + SHARED_TAGS_KEY,
               '/api/nested-fetch-in-api-route/revalidated-fetch',
             );
             expect(hashmap).toBeNull();
@@ -514,10 +530,9 @@ describe('Next.js Turbo Redis Cache Integration', () => {
           it('After the new request was made the redis key and hashmap should be set again', async () => {
             await delay(REDIS_BACKGROUND_SYNC_DELAY);
 
-            // This cache entry key is the key of the sub-fetch-request, it will be generated by nextjs based on the headers/payload etc.
-            // So it should stay the same unless nextjs will change something in there implementation
-            const cacheEntryKey =
-              '094a786b7ad391852168d3a7bcf75736777697d24a856a0089837f4b7de921df';
+            const cacheEntryKey = await findFetchCacheEntryKey(
+              'revalidated-fetch-revalidate3-nested-fetch-in-api-route',
+            );
 
             // check Redis keys
             const keys = await redisClient.keys(
@@ -526,7 +541,7 @@ describe('Next.js Turbo Redis Cache Integration', () => {
             expect(keys.length).toBe(1);
 
             const hashmap = (await redisClient.hGet(
-              process.env.VERCEL_URL + '__sharedTags__',
+              process.env.VERCEL_URL + SHARED_TAGS_KEY,
               cacheEntryKey,
             )) as string;
             expect(JSON.parse(hashmap)).toEqual([
@@ -551,7 +566,7 @@ describe('Next.js Turbo Redis Cache Integration', () => {
             expect(keys.length).toBe(0);
 
             const hashmap = await redisClient.hGet(
-              process.env.VERCEL_URL + '__sharedTags__',
+              process.env.VERCEL_URL + SHARED_TAGS_KEY,
               '/api/nested-fetch-in-api-route/revalidated-fetch',
             );
             expect(hashmap).toBeNull();
@@ -569,10 +584,9 @@ describe('Next.js Turbo Redis Cache Integration', () => {
 
           it('After the new request was made the redis key and hashmap should be set again', async () => {
             await delay(REDIS_BACKGROUND_SYNC_DELAY);
-            // This cache entry key is the key of the sub-fetch-request, it will be generated by nextjs based on the headers/payload etc.
-            // So it should stay the same unless nextjs will change something in there implementation
-            const cacheEntryKey =
-              '094a786b7ad391852168d3a7bcf75736777697d24a856a0089837f4b7de921df';
+            const cacheEntryKey = await findFetchCacheEntryKey(
+              'revalidated-fetch-revalidate3-nested-fetch-in-api-route',
+            );
 
             // check Redis keys
             const keys = await redisClient.keys(
@@ -581,7 +595,7 @@ describe('Next.js Turbo Redis Cache Integration', () => {
             expect(keys.length).toBe(1);
 
             const hashmap = (await redisClient.hGet(
-              process.env.VERCEL_URL + '__sharedTags__',
+              process.env.VERCEL_URL + SHARED_TAGS_KEY,
               cacheEntryKey,
             )) as string;
             expect(JSON.parse(hashmap)).toEqual([
@@ -708,7 +722,7 @@ describe('Next.js Turbo Redis Cache Integration', () => {
           expect(keys.length).toBe(0);
 
           const hashmap = await redisClient.hGet(
-            process.env.VERCEL_URL + '__sharedTags__',
+            process.env.VERCEL_URL + SHARED_TAGS_KEY,
             '/pages/no-fetch/default-page',
           );
           expect(hashmap).toBeNull();
@@ -733,7 +747,7 @@ describe('Next.js Turbo Redis Cache Integration', () => {
           expect(keys.length).toBe(1);
 
           const hashmap = (await redisClient.hGet(
-            process.env.VERCEL_URL + '__sharedTags__',
+            process.env.VERCEL_URL + SHARED_TAGS_KEY,
             '/pages/no-fetch/default-page',
           )) as string;
           expect(JSON.parse(hashmap)).toEqual([
@@ -771,6 +785,10 @@ describe('Next.js Turbo Redis Cache Integration', () => {
 
         await delay(REDIS_BACKGROUND_SYNC_DELAY);
 
+        const nestedFetchCacheEntryKey = await findFetchCacheEntryKey(
+          'revalidated-fetch-revalidate15-default-page',
+        );
+
         // test cache entry for 3 keys are set
         const keys1 = await redisClient.keys(
           process.env.VERCEL_URL +
@@ -778,8 +796,7 @@ describe('Next.js Turbo Redis Cache Integration', () => {
         );
         expect(keys1.length).toBe(1);
         const keys2 = await redisClient.keys(
-          process.env.VERCEL_URL +
-            'e978cf5ddb8bf799209e828635cfe9ae6862f6735cea97f01ab752ff6fa489b4',
+          process.env.VERCEL_URL + nestedFetchCacheEntryKey,
         );
         expect(keys2.length).toBe(1);
         const keys3 = await redisClient.keys(
@@ -789,7 +806,7 @@ describe('Next.js Turbo Redis Cache Integration', () => {
 
         // test shared tag hashmap to be set for all keys
         const hashmap1 = (await redisClient.hGet(
-          process.env.VERCEL_URL + '__sharedTags__',
+          process.env.VERCEL_URL + SHARED_TAGS_KEY,
           '/pages/revalidated-fetch/revalidate15--default-page',
         )) as string;
         expect(JSON.parse(hashmap1)).toEqual([
@@ -802,14 +819,14 @@ describe('Next.js Turbo Redis Cache Integration', () => {
           'revalidated-fetch-revalidate15-default-page',
         ]);
         const hashmap2 = (await redisClient.hGet(
-          process.env.VERCEL_URL + '__sharedTags__',
-          'e978cf5ddb8bf799209e828635cfe9ae6862f6735cea97f01ab752ff6fa489b4',
+          process.env.VERCEL_URL + SHARED_TAGS_KEY,
+          nestedFetchCacheEntryKey,
         )) as string;
         expect(JSON.parse(hashmap2)).toEqual([
           'revalidated-fetch-revalidate15-default-page',
         ]);
         const hashmap3 = (await redisClient.hGet(
-          process.env.VERCEL_URL + '__sharedTags__',
+          process.env.VERCEL_URL + SHARED_TAGS_KEY,
           '/api/revalidated-fetch',
         )) as string;
         expect(JSON.parse(hashmap3)).toEqual([
@@ -849,20 +866,22 @@ describe('Next.js Turbo Redis Cache Integration', () => {
         expect(keys1.length).toBe(0);
 
         const hashmap1 = await redisClient.hGet(
-          process.env.VERCEL_URL + '__sharedTags__',
+          process.env.VERCEL_URL + SHARED_TAGS_KEY,
           '/pages/revalidated-fetch/revalidate15--default-page',
         );
         expect(hashmap1).toBeNull();
 
         // sub-fetch-request is not removed directly but will be removed on next get request
+        const nestedFetchCacheEntryKey = await findFetchCacheEntryKey(
+          'revalidated-fetch-revalidate15-default-page',
+        );
         const keys2 = await redisClient.keys(
-          process.env.VERCEL_URL +
-            'e978cf5ddb8bf799209e828635cfe9ae6862f6735cea97f01ab752ff6fa489b4',
+          process.env.VERCEL_URL + nestedFetchCacheEntryKey,
         );
         expect(keys2.length).toBe(1);
         const hashmap2 = await redisClient.hGet(
-          process.env.VERCEL_URL + '__sharedTags__',
-          'e978cf5ddb8bf799209e828635cfe9ae6862f6735cea97f01ab752ff6fa489b4',
+          process.env.VERCEL_URL + SHARED_TAGS_KEY,
+          nestedFetchCacheEntryKey,
         );
         expect(hashmap2).toBeDefined();
 
@@ -881,7 +900,7 @@ describe('Next.js Turbo Redis Cache Integration', () => {
         );
         expect(keys3.length).toBe(1);
         const hashmap3 = (await redisClient.hGet(
-          process.env.VERCEL_URL + '__sharedTags__',
+          process.env.VERCEL_URL + SHARED_TAGS_KEY,
           '/api/revalidated-fetch',
         )) as string;
         expect(JSON.parse(hashmap3)).toEqual([

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

@@ -85,6 +85,34 @@ describe('RedisStringsHandler', () => {
     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();
+    }
+  });
 });
 
 describe('Public exports', () => {