@trieb.work/nextjs-turbo-redis-cache 1.9.1 → 1.10.0-beta.14

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

@@ -1,7 +1,7 @@
 import { describe, it, expect, beforeAll, afterAll } from 'vitest';
-import { spawn } from 'child_process';
+import { ChildProcessWithoutNullStreams, spawn } from 'child_process';
 import fetch from 'node-fetch';
-import { createClient } from 'redis';
+import { createClient, RedisClientType } from 'redis';
 import { join } from 'path';
 import { CacheEntry } from '../../src/RedisStringsHandler';
 import { revalidate as next1503_revalidatedFetch_route } from './next-app-15-0-3/src/app/api/revalidated-fetch/route';
@@ -16,8 +16,8 @@ const NEXT_START_URL = `http://localhost:${NEXT_START_PORT}`;
 
 const REDIS_BACKGROUND_SYNC_DELAY = 250; //ms delay to prevent flaky tests in slow CI environments
 
-let nextProcess;
-let redisClient;
+let nextProcess: ChildProcessWithoutNullStreams;
+let redisClient: RedisClientType;
 
 async function delay(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
@@ -167,9 +167,9 @@ describe('Next.js Turbo Redis Cache Integration', () => {
         expect(keys.length).toBeGreaterThan(0);
 
         // check the content of redis key
-        const value = await redisClient.get(
+        const value = (await redisClient.get(
           process.env.VERCEL_URL + '/api/cached-static-fetch',
-        );
+        )) as string;
         expect(value).toBeDefined();
         const cacheEntry: CacheEntry = JSON.parse(value);
 
@@ -240,10 +240,10 @@ describe('Next.js Turbo Redis Cache Integration', () => {
         );
         expect(keys.length).toBe(1);
 
-        const hashmap = await redisClient.hGet(
+        const hashmap = (await redisClient.hGet(
           process.env.VERCEL_URL + '__sharedTags__',
           '/api/cached-static-fetch',
-        );
+        )) as string;
         expect(JSON.parse(hashmap)).toEqual([
           '_N_T_/layout',
           '_N_T_/api/layout',
@@ -319,6 +319,63 @@ describe('Next.js Turbo Redis Cache Integration', () => {
       }
     });
 
+    // Next 16-only caching API tests. These routes exist only in the Next 16 test app
+    // and exercise the new revalidateTag profiles and updateTag semantics.
+    if (NEXT_TEST_APP.includes('16.')) {
+      describe('Next 16 caching APIs', () => {
+        const cachedStaticPath = '/api/cached-static-fetch';
+
+        async function assertCachedStaticFetchCleared() {
+          await delay(REDIS_BACKGROUND_SYNC_DELAY);
+          const keys = await redisClient.keys(
+            process.env.VERCEL_URL + cachedStaticPath,
+          );
+          expect(keys.length).toBe(0);
+
+          const hashmap = await redisClient.hGet(
+            process.env.VERCEL_URL + '__sharedTags__',
+            cachedStaticPath,
+          );
+          expect(hashmap).toBeNull();
+        }
+
+        it('revalidateTag(tag, "max") should invalidate cached-static-fetch by tag', async () => {
+          // Warm up cache and sharedTagsMap for cached-static-fetch
+          await fetch(NEXT_START_URL + cachedStaticPath);
+          await delay(REDIS_BACKGROUND_SYNC_DELAY);
+
+          // Use explicit tag for this route as set by Next.js
+          const tag = '_N_T_/api/cached-static-fetch';
+          const res = await fetch(
+            `${NEXT_START_URL}/api/revalidateTag?tag=${encodeURIComponent(
+              tag,
+            )}&profile=max`,
+          );
+          const json: any = await res.json();
+          expect(json.success).toBe(true);
+
+          await assertCachedStaticFetchCleared();
+        });
+
+        it('revalidateTag(tag, { expire: 60 }) should also invalidate cached-static-fetch', async () => {
+          // Warm up cache again
+          await fetch(NEXT_START_URL + cachedStaticPath);
+          await delay(REDIS_BACKGROUND_SYNC_DELAY);
+
+          const tag = '_N_T_/api/cached-static-fetch';
+          const res = await fetch(
+            `${NEXT_START_URL}/api/revalidateTag?tag=${encodeURIComponent(
+              tag,
+            )}&profile=expire`,
+          );
+          const json: any = await res.json();
+          expect(json.success).toBe(true);
+
+          await assertCachedStaticFetchCleared();
+        });
+      });
+    }
+
     describe('should not cache uncached API routes in Redis', () => {
       let counter1: number;
 
@@ -462,10 +519,10 @@ describe('Next.js Turbo Redis Cache Integration', () => {
             );
             expect(keys.length).toBe(1);
 
-            const hashmap = await redisClient.hGet(
+            const hashmap = (await redisClient.hGet(
               process.env.VERCEL_URL + '__sharedTags__',
               cacheEntryKey,
-            );
+            )) as string;
             expect(JSON.parse(hashmap)).toEqual([
               'revalidated-fetch-revalidate3-nested-fetch-in-api-route',
             ]);
@@ -517,10 +574,10 @@ describe('Next.js Turbo Redis Cache Integration', () => {
             );
             expect(keys.length).toBe(1);
 
-            const hashmap = await redisClient.hGet(
+            const hashmap = (await redisClient.hGet(
               process.env.VERCEL_URL + '__sharedTags__',
               cacheEntryKey,
-            );
+            )) as string;
             expect(JSON.parse(hashmap)).toEqual([
               'revalidated-fetch-revalidate3-nested-fetch-in-api-route',
             ]);
@@ -570,9 +627,9 @@ describe('Next.js Turbo Redis Cache Integration', () => {
         });
 
         it('The data in the redis key should match the expected format', async () => {
-          const data = await redisClient.get(
+          const data = (await redisClient.get(
             process.env.VERCEL_URL + '/pages/no-fetch/default-page',
-          );
+          )) as string;
           expect(data).toBeDefined();
           const cacheEntry: CacheEntry = JSON.parse(data);
 
@@ -667,10 +724,10 @@ describe('Next.js Turbo Redis Cache Integration', () => {
           );
           expect(keys.length).toBe(1);
 
-          const hashmap = await redisClient.hGet(
+          const hashmap = (await redisClient.hGet(
             process.env.VERCEL_URL + '__sharedTags__',
             '/pages/no-fetch/default-page',
-          );
+          )) as string;
           expect(JSON.parse(hashmap)).toEqual([
             '_N_T_/layout',
             '_N_T_/pages/layout',
@@ -723,10 +780,10 @@ describe('Next.js Turbo Redis Cache Integration', () => {
         expect(keys3.length).toBe(1);
 
         // test shared tag hashmap to be set for all keys
-        const hashmap1 = await redisClient.hGet(
+        const hashmap1 = (await redisClient.hGet(
           process.env.VERCEL_URL + '__sharedTags__',
           '/pages/revalidated-fetch/revalidate15--default-page',
-        );
+        )) as string;
         expect(JSON.parse(hashmap1)).toEqual([
           '_N_T_/layout',
           '_N_T_/pages/layout',
@@ -736,17 +793,17 @@ describe('Next.js Turbo Redis Cache Integration', () => {
           '_N_T_/pages/revalidated-fetch/revalidate15--default-page',
           'revalidated-fetch-revalidate15-default-page',
         ]);
-        const hashmap2 = await redisClient.hGet(
+        const hashmap2 = (await redisClient.hGet(
           process.env.VERCEL_URL + '__sharedTags__',
           'e978cf5ddb8bf799209e828635cfe9ae6862f6735cea97f01ab752ff6fa489b4',
-        );
+        )) as string;
         expect(JSON.parse(hashmap2)).toEqual([
           'revalidated-fetch-revalidate15-default-page',
         ]);
-        const hashmap3 = await redisClient.hGet(
+        const hashmap3 = (await redisClient.hGet(
           process.env.VERCEL_URL + '__sharedTags__',
           '/api/revalidated-fetch',
-        );
+        )) as string;
         expect(JSON.parse(hashmap3)).toEqual([
           '_N_T_/layout',
           '_N_T_/api/layout',
@@ -815,10 +872,10 @@ describe('Next.js Turbo Redis Cache Integration', () => {
           process.env.VERCEL_URL + '/api/revalidated-fetch',
         );
         expect(keys3.length).toBe(1);
-        const hashmap3 = await redisClient.hGet(
+        const hashmap3 = (await redisClient.hGet(
           process.env.VERCEL_URL + '__sharedTags__',
           '/api/revalidated-fetch',
-        );
+        )) as string;
         expect(JSON.parse(hashmap3)).toEqual([
           '_N_T_/layout',
           '_N_T_/api/layout',

package/tests/update-tag.spec.ts

@@ -0,0 +1,33 @@
+import { test, expect } from '@playwright/test';
+
+// This test assumes the Next 16 app is already running, e.g.:
+//   cd test/integration/next-app-16-0-3 && pnpm dev
+// on the same origin as baseURL.
+
+test('button click triggers Server Action using updateTag', async ({
+  page,
+}) => {
+  await page.goto('/update-tag-test');
+
+  await expect(page.getByText('UpdateTag Test')).toBeVisible();
+
+  const clicks = page.getByTestId('clicks');
+  const before = await clicks.textContent();
+
+  await page.getByRole('button', { name: 'Increment' }).click();
+
+  // Wait for network and any navigation caused by the Server Action
+  await page.waitForLoadState('networkidle');
+
+  const after = await clicks.textContent();
+
+  // Server Action should have run and updated the UI
+  expect(after).not.toBe(before);
+
+  // Ensure there is no error message about updateTag usage
+  const errorLocator = page.getByText(
+    'updateTag can only be called from within a Server Action',
+    { exact: false },
+  );
+  await expect(errorLocator).toHaveCount(0);
+});

package/vitest.browser.config.ts

@@ -0,0 +1,10 @@
+import { defineConfig } from 'vitest/config';
+
+// Browser mode disabled; Playwright is used via its own runner instead.
+export default defineConfig({
+  test: {
+    browser: {
+      enabled: false,
+    },
+  },
+});