Cache in CacheScopeStore in use cache (#71221)

Implements deduping of "use cache" entries using CacheScopeStore. This
is required for dynamic I/O.

We also have the option to use this for dynamic runtime deduping too,
rather than going to the underlying store and ensuring consistency
within the request. There are some negative tradeoffs with this approach
though that it might not be worth it for dynamic requests. For now, it's
up to the Cache Handler to do deduping if it wants to. I implemented
this in the default cache handler.

I tested this with a blank cache implementation since the existing cache
is microtasky. Since a working cache is required for other tests and
should be the default, I reverted the blank cache. So this doesn't have
the full test coverage yet in practice. Once we land configurable caches
we can use a blank cache in the newly added tests to get better
coverage.

I had to make the cache scope external since it's now shared with RSC
layer.

Author: sebmarkbage

packages/next/src/export/worker.ts

@@ -46,7 +46,7 @@ import {
   type FallbackRouteParams,
 } from '../server/request/fallback-params'
 import { needsExperimentalReact } from '../lib/needs-experimental-react'
-import { runWithCacheScope } from '../server/async-storage/cache-scope'
+import { runWithCacheScope } from '../server/async-storage/cache-scope.external'
 import type { AppRouteRouteModule } from '../server/route-modules/app-route/module.compiled'
 
 const envConfig = require('../shared/lib/runtime-config.external')

packages/next/src/server/async-storage/cache-scope-instance.ts

@@ -0,0 +1,6 @@
+import type { CacheScopeStore } from './cache-scope.external'
+
+import { createAsyncLocalStorage } from '../app-render/async-local-storage'
+
+export const cacheScopeAsyncLocalStorage =
+  createAsyncLocalStorage<CacheScopeStore>()

packages/next/src/server/async-storage/cache-scope.ts renamed to packages/next/src/server/async-storage/cache-scope.external.ts

@@ -1,11 +1,10 @@
-import { createAsyncLocalStorage } from '../app-render/async-local-storage'
+import { cacheScopeAsyncLocalStorage } from './cache-scope-instance' with { 'turbopack-transition': 'next-shared' }
 
 export interface CacheScopeStore {
-  cache?: Map<string, any>
+  cache: Map<string, any>
 }
 
-export const cacheScopeAsyncLocalStorage =
-  createAsyncLocalStorage<CacheScopeStore>()
+export { cacheScopeAsyncLocalStorage }
 
 /**
  * For dynamic IO handling we want to have a scoped memory

packages/next/src/server/base-server.ts

@@ -172,10 +172,7 @@ import { FallbackMode, parseFallbackField } from '../lib/fallback'
 import { toResponseCacheEntry } from './response-cache/utils'
 import { scheduleOnNextTick } from '../lib/scheduler'
 import { PrefetchCacheScopes } from './lib/prefetch-cache-scopes'
-import {
-  runWithCacheScope,
-  type CacheScopeStore,
-} from './async-storage/cache-scope'
+import { runWithCacheScope } from './async-storage/cache-scope.external'
 
 export type FindComponentsResult = {
   components: LoadComponentsReturnType
@@ -3039,10 +3036,8 @@ export default abstract class Server<
       responseGenerator = async (
         ...args: Parameters<typeof responseGenerator>
       ): ReturnType<typeof responseGenerator> => {
-        let cache: CacheScopeStore['cache'] | undefined
-
         if (this.renderOpts.dev) {
-          cache = this.prefetchCacheScopesDev.get(urlPathname)
+          let cache = this.prefetchCacheScopesDev.get(urlPathname)
 
           // we need to seed the prefetch cache scope in dev
           // since we did not have a prefetch cache available
@@ -3066,19 +3061,21 @@ export default abstract class Server<
             delete req.headers[RSC_HEADER]
             delete req.headers[NEXT_ROUTER_PREFETCH_HEADER]
           }
-        }
 
-        return runWithCacheScope({ cache }, () =>
-          originalResponseGenerator(...args)
-        ).finally(() => {
-          if (this.renderOpts.dev) {
-            if (isPrefetchRSCRequest) {
-              this.prefetchCacheScopesDev.set(urlPathname, cache)
-            } else {
-              this.prefetchCacheScopesDev.del(urlPathname)
-            }
+          if (cache) {
+            return runWithCacheScope({ cache }, () =>
+              originalResponseGenerator(...args)
+            ).finally(() => {
+              if (isPrefetchRSCRequest) {
+                this.prefetchCacheScopesDev.set(urlPathname, cache)
+              } else {
+                this.prefetchCacheScopesDev.del(urlPathname)
+              }
+            })
           }
-        })
+        }
+
+        return originalResponseGenerator(...args)
       }
     }
 

packages/next/src/server/lib/incremental-cache/index.ts

@@ -10,7 +10,7 @@ import {
 import type { Revalidate } from '../revalidate'
 import type { DeepReadonly } from '../../../shared/lib/deep-readonly'
 
-import { cacheScopeAsyncLocalStorage } from '../../async-storage/cache-scope'
+import { cacheScopeAsyncLocalStorage } from '../../async-storage/cache-scope.external'
 import FetchCache from './fetch-cache'
 import FileSystemCache from './file-system-cache'
 import { normalizePagePath } from '../../../shared/lib/page-path/normalize-page-path'
@@ -414,7 +414,7 @@ export class IncrementalCache implements IncrementalCacheType {
     if (this.hasDynamicIO && ctx.kind === IncrementalCacheKind.FETCH) {
       const cacheScope = cacheScopeAsyncLocalStorage.getStore()
 
-      if (cacheScope?.cache) {
+      if (cacheScope) {
         const memoryCacheData = cacheScope.cache.get(cacheKey)
 
         if (memoryCacheData?.kind === CachedRouteKind.FETCH) {
@@ -538,7 +538,7 @@ export class IncrementalCache implements IncrementalCacheType {
     if (this.hasDynamicIO && data?.kind === CachedRouteKind.FETCH) {
       const cacheScope = cacheScopeAsyncLocalStorage.getStore()
 
-      if (cacheScope?.cache) {
+      if (cacheScope) {
         cacheScope.cache.set(pathname, data)
       }
     }

packages/next/src/server/lib/prefetch-cache-scopes.ts

@@ -1,4 +1,4 @@
-import type { CacheScopeStore } from '../async-storage/cache-scope'
+import type { CacheScopeStore } from '../async-storage/cache-scope.external'
 
 export class PrefetchCacheScopes {
   private cacheScopes = new Map<