fix: revalidation with file-system-cache (#58508)

### What?

When using the file system cache with `isrMemoryCacheSize: 0`, time-based revalidation is not working, and the file is constantly updated. I have also added some debug logging to mirror that in the `fetch-cache` handler

Detailed explanation in #58507

### Why?

The cached object's tags are incorrectly accessed, causing the cache to be rewritten every hit. This is catastrophic for a caching system that relies on file modification timestamps. The tags are one level up in the object from where [they are currently being accessed](https://github.com/vercel/next.js/blob/9ab8828f72e96f5de86a7c50b67a1c5abe6e146c/packages/next/src/server/lib/incremental-cache/file-system-cache.ts#L178).

Below shows a cached fetch representation on disk. When written, the tags reside at `obj.tags` instead of `obj.data.tags`

```json
{
  "kind": "FETCH",
  "data": {
    "headers": {
      "connection": "keep-alive",
      "content-encoding": "br",
      "content-type": "application/json; charset=utf-8",
      "date": "Wed, 15 Nov 2023 21:17:42 GMT",
      "server": "nginx/1.18.0 (Ubuntu)",
      "transfer-encoding": "chunked",
      "vary": "Accept-Encoding"
    },
    "body": "[SNIP]",
    "status": 200,
    "url": "https://timeapi.io/api/Time/current/zone?timeZone=UTC"
    # this is where the current code is trying to pull the tags
    # "tags": [ "time-with-fetch" ]
  },
  "revalidate": 20,
  # tags actually live here
  "tags": [
    "time-with-fetch"
  ]
}
```

Fixes #58507

packages/next/src/server/lib/incremental-cache/file-system-cache.ts

@@ -38,6 +38,7 @@ export default class FileSystemCache implements CacheHandler {
   private tagsManifestPath?: string
   private revalidatedTags: string[]
   private readonly experimental: { ppr: boolean }
+  private debug: boolean
 
   constructor(ctx: FileSystemCacheContext) {
     this.fs = ctx.fs
@@ -47,8 +48,13 @@ export default class FileSystemCache implements CacheHandler {
     this.pagesDir = !!ctx._pagesDir
     this.revalidatedTags = ctx.revalidatedTags
     this.experimental = ctx.experimental
+    this.debug = !!process.env.NEXT_PRIVATE_DEBUG_CACHE
 
     if (ctx.maxMemoryCacheSize && !memoryCache) {
+      if (this.debug) {
+        console.log('using memory store for fetch cache')
+      }
+
       memoryCache = new LRUCache({
         max: ctx.maxMemoryCacheSize,
         length({ value }) {
@@ -69,7 +75,10 @@ export default class FileSystemCache implements CacheHandler {
           )
         },
       })
+    } else if (this.debug) {
+      console.log('not using memory store for fetch cache')
     }
+
     if (this.serverDistDir && this.fs) {
       this.tagsManifestPath = path.join(
         this.serverDistDir,
@@ -91,9 +100,14 @@ export default class FileSystemCache implements CacheHandler {
     } catch (err: any) {
       tagsManifest = { version: 1, items: {} }
     }
+    if (this.debug) console.log('loadTagsManifest', tagsManifest)
   }
 
   public async revalidateTag(tag: string) {
+    if (this.debug) {
+      console.log('revalidateTag', tag)
+    }
+
     // we need to ensure the tagsManifest is refreshed
     // since separate workers can be updating it at the same
     // time and we can't flush out of sync data
@@ -112,6 +126,9 @@ export default class FileSystemCache implements CacheHandler {
         this.tagsManifestPath,
         JSON.stringify(tagsManifest || {})
       )
+      if (this.debug) {
+        console.log('Updated tags manifest', tagsManifest)
+      }
     } catch (err: any) {
       console.warn('Failed to update tags manifest.', err)
     }
@@ -122,6 +139,10 @@ export default class FileSystemCache implements CacheHandler {
     const { tags, softTags, kindHint } = ctx
     let data = memoryCache?.get(key)
 
+    if (this.debug) {
+      console.log('get', key, tags, kindHint, !!data)
+    }
+
     // let's check the disk for seed data
     if (!data && process.env.NEXT_RUNTIME !== 'edge') {
       try {
@@ -175,12 +196,15 @@ export default class FileSystemCache implements CacheHandler {
           }
 
           if (data.value?.kind === 'FETCH') {
-            const storedTags = data.value?.data?.tags
+            const storedTags = data.value?.tags
 
             // update stored tags if a new one is being added
             // TODO: remove this when we can send the tags
             // via header on GET same as SET
             if (!tags?.every((tag) => storedTags?.includes(tag))) {
+              if (this.debug) {
+                console.log('tags vs storedTags mismatch', tags, storedTags)
+              }
               await this.set(key, data.value, { tags })
             }
           }
@@ -296,6 +320,10 @@ export default class FileSystemCache implements CacheHandler {
       value: data,
       lastModified: Date.now(),
     })
+    if (this.debug) {
+      console.log('set', key)
+    }
+
     if (!this.flushToDisk) return
 
     if (data?.kind === 'ROUTE') {

packages/next/src/server/response-cache/types.ts

@@ -28,10 +28,10 @@ export interface CachedFetchValue {
     body: string
     url: string
     status?: number
-    // tags are only present with file-system-cache
-    // fetch cache stores tags outside of cache entry
-    tags?: string[]
   }
+  // tags are only present with file-system-cache
+  // fetch cache stores tags outside of cache entry
+  tags?: string[]
   revalidate: number
 }
 

test/unit/incremental-cache/file-system-cache.test.ts

@@ -47,3 +47,83 @@ describe('FileSystemCache', () => {
     })
   })
 })
+
+describe('FileSystemCache (isrMemory 0)', () => {
+  const fsCache = new FileSystemCache({
+    _appDir: true,
+    _pagesDir: true,
+    _requestHeaders: {},
+    flushToDisk: true,
+    fs: nodeFs,
+    serverDistDir: cacheDir,
+    revalidatedTags: [],
+    experimental: {
+      ppr: false,
+    },
+    maxMemoryCacheSize: 0, // disable memory cache
+  })
+
+  it('should cache fetch', async () => {
+    await fsCache.set(
+      'fetch-cache',
+      {
+        kind: 'FETCH',
+        data: {
+          headers: {},
+          body: 'MTcwMDA1NjM4MQ==',
+          status: 200,
+          url: 'http://my-api.local',
+        },
+        revalidate: 30,
+      },
+      {
+        fetchCache: true,
+        revalidate: 30,
+        fetchUrl: 'http://my-api.local',
+        fetchIdx: 5,
+        tags: ['server-time'],
+      }
+    )
+
+    const res = await fsCache.get('fetch-cache', {
+      tags: ['server-time'],
+      kindHint: 'fetch',
+    })
+
+    expect(res.value).toEqual({
+      kind: 'FETCH',
+      data: {
+        headers: {},
+        body: 'MTcwMDA1NjM4MQ==',
+        status: 200,
+        url: 'http://my-api.local',
+      },
+      revalidate: 30,
+      tags: ['server-time'],
+    })
+  })
+
+  it('should cache unstable_cache', async () => {
+    await fsCache.set(
+      'unstable-cache',
+      {
+        kind: 'FETCH',
+        data: { headers: {}, body: '1700056381', status: 200, url: '' },
+        revalidate: 30,
+      },
+      { revalidate: 30, fetchCache: true, tags: ['server-time2'] }
+    )
+
+    const res = await fsCache.get('unstable-cache', {
+      tags: ['server-time'],
+      kindHint: 'fetch',
+    })
+
+    expect(res.value).toEqual({
+      kind: 'FETCH',
+      data: { headers: {}, body: '1700056381', status: 200, url: '' },
+      revalidate: 30,
+      tags: ['server-time2'],
+    })
+  })
+})