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

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([
@@ -297,6 +313,15 @@ describe('Next.js Turbo Redis Cache Integration', () => {
           const ttl = await redisClient.ttl(
             process.env.VERCEL_URL + '/api/revalidated-fetch',
           );
+
+          // Next.js 16.3+ passes cacheControl.expire for ISR fetch routes (~1 year).
+          // TTL is keyed on expire (SWR-safe), not 2 × revalidate — skip the
+          // long-running expiry wait in that case.
+          if (NEXT_TEST_APP.includes('16-3')) {
+            expect(ttl).toBeGreaterThan(2 * revalidatedFetchRouteRevalidate);
+            return;
+          }
+
           expect(ttl).toBeLessThan(2 * revalidatedFetchRouteRevalidate);
           expect(ttl).toBeGreaterThan(
             2 * revalidatedFetchRouteRevalidate -
@@ -317,7 +342,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 +364,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 +520,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 +539,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 +550,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 +575,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 +593,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 +604,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 +731,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 +756,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 +794,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 +805,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 +815,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 +828,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 +875,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 +909,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([
@@ -904,9 +932,14 @@ describe('Next.js Turbo Redis Cache Integration', () => {
         expect(timestamp).toBeDefined();
         expect(Number(timestamp)).toBeGreaterThan(Number(firstTimestamp));
 
-        //but the new request should not have a higher counter than the first request (because the cache of the API route should not be invalidated)
+        // Next.js 16.3 revalidates nested fetch entries when the parent page path
+        // is revalidated; older versions keep the nested fetch cache intact.
         expect(secondCounter).toBeDefined();
-        expect(secondCounter).toBe(firstCounter);
+        if (NEXT_TEST_APP === 'next-app-16-3-0') {
+          expect(Number(secondCounter)).toBeGreaterThan(Number(firstCounter));
+        } else {
+          expect(secondCounter).toBe(firstCounter);
+        }
       });
     });
 

package/test/vitest/integration/pages-router.integration.test.ts

@@ -48,6 +48,18 @@ async function delay(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+function expectIsrRedisTtl(ttl: number) {
+  // Next.js 16.3+ passes cacheControl.expire (~1 year) for ISR pages.
+  // Redis TTL is keyed on expire, not 2 × revalidate.
+  if (NEXT_PAGES_TEST_APP.includes('16-3')) {
+    expect(ttl).toBeGreaterThan(2 * ISR_REVALIDATE_SECONDS);
+    return;
+  }
+  // VERCEL_ENV=production -> expire age is 2 * revalidate
+  expect(ttl).toBeGreaterThan(2 * ISR_REVALIDATE_SECONDS - 30);
+  expect(ttl).toBeLessThanOrEqual(2 * ISR_REVALIDATE_SECONDS);
+}
+
 async function runCommand(cmd: string, args: string[], cwd: string) {
   return new Promise((resolve, reject) => {
     let stderr = '';
@@ -233,9 +245,7 @@ describe('Pages Router Redis cache integration (two instances)', () => {
       const ttl = await redisClient.ttl(
         process.env.VERCEL_URL + '/isr/prebuilt',
       );
-      // VERCEL_ENV=production -> expire age is 2 * revalidate
-      expect(ttl).toBeGreaterThan(2 * ISR_REVALIDATE_SECONDS - 30);
-      expect(ttl).toBeLessThanOrEqual(2 * ISR_REVALIDATE_SECONDS);
+      expectIsrRedisTtl(ttl);
     });
 
     it('instance B serves the identical cached HTML from the shared Redis', async () => {
@@ -342,12 +352,12 @@ describe('Pages Router Redis cache integration (two instances)', () => {
         tags: ['_N_T_/isr/not-found'],
       });
 
-      // TTL is derived from the revalidate value returned with notFound
+      // TTL: Next.js 16.3+ keys on cacheControl.expire (SWR-safe); older
+      // versions use estimateExpireAge(revalidate).
       const ttl = await redisClient.ttl(
         process.env.VERCEL_URL + '/isr/not-found',
       );
-      expect(ttl).toBeGreaterThan(2 * ISR_REVALIDATE_SECONDS - 30);
-      expect(ttl).toBeLessThanOrEqual(2 * ISR_REVALIDATE_SECONDS);
+      expectIsrRedisTtl(ttl);
     });
 
     it('instance B serves the 404 from the shared cache', async () => {

package/test/vitest/unit/SyncedMap-orphan-cleanup.test.ts

@@ -0,0 +1,111 @@
+import { describe, it, expect } from 'vitest';
+import { SyncedMap } from '../../../src/SyncedMap';
+
+class HashMockClient {
+  hash = new Map<string, string>();
+  stringKeys: string[] = [];
+  hDelCalls: string[][] = [];
+  isOpen = true;
+  isReady = true;
+
+  on() {
+    return this;
+  }
+
+  async connect() {
+    this.isOpen = true;
+    this.isReady = true;
+  }
+
+  async configGet() {
+    return { 'notify-keyspace-events': 'Exe' };
+  }
+
+  async subscribe() {}
+
+  async quit() {}
+
+  async disconnect() {
+    this.isOpen = false;
+    this.isReady = false;
+  }
+
+  duplicate() {
+    return new HashMockClient();
+  }
+
+  async hScan() {
+    return {
+      cursor: 0,
+      tuples: [...this.hash.entries()].map(([field, value]) => ({
+        field,
+        value,
+      })),
+    };
+  }
+
+  async scan() {
+    return { cursor: 0, keys: this.stringKeys };
+  }
+
+  async hSet(_key: string, field: string, value: string) {
+    this.hash.set(field, value);
+    return 1;
+  }
+
+  async hDel(_key: string, fields: string | string[]) {
+    const list = Array.isArray(fields) ? fields : [fields];
+    this.hDelCalls.push(list);
+    for (const field of list) {
+      this.hash.delete(field);
+    }
+    return list.length;
+  }
+
+  async publish() {
+    return 1;
+  }
+}
+
+describe('SyncedMap orphan cleanup', () => {
+  it('deletes hash fields whose names are not Redis string keys', async () => {
+    const client = new HashMockClient();
+    const map = new SyncedMap<number>({
+      client: client as never,
+      keyPrefix: 'app:',
+      redisKey: '__revalidated_tags__',
+      database: 0,
+      querySize: 50,
+      filterKeys: () => true,
+    });
+    await map.waitUntilReady();
+    await map.set('posts', 1);
+
+    client.stringKeys = ['app:some-cache-entry'];
+    await (map as any).initialSync();
+
+    expect(client.hDelCalls.flat()).toContain('posts');
+    expect(map.get('posts')).toBeUndefined();
+  });
+
+  it('keeps tag-manifest fields when withoutOrphanCleanup is set', async () => {
+    const client = new HashMockClient();
+    const map = new SyncedMap<number>({
+      client: client as never,
+      keyPrefix: 'app:',
+      redisKey: '__cacheComponents_revalidated_tags__',
+      database: 0,
+      querySize: 50,
+      filterKeys: () => true,
+      customizedSync: { withoutOrphanCleanup: true },
+    });
+    await map.waitUntilReady();
+    await map.set('posts', 1);
+
+    client.stringKeys = ['app:some-cache-entry'];
+    await (map as any).initialSync();
+
+    expect(client.hDelCalls).toEqual([]);
+    expect(map.get('posts')).toBe(1);
+  });
+});