always return non-exotic promises in cacheComponents

Author: lubieowoce

packages/next/errors.json

@@ -770,5 +770,9 @@
   "769": "createSearchParamsFromClient should not be called in a runtime prerender.",
   "770": "createParamsFromClient should not be called in a runtime prerender.",
   "771": "\\`%s\\` was called during a runtime prerender. Next.js should be preventing %s from being included in server components statically, but did not in this case.",
-  "772": "FetchStrategy.PPRRuntime should never be used when `experimental.clientSegmentCache` is disabled"
+  "772": "FetchStrategy.PPRRuntime should never be used when `experimental.clientSegmentCache` is disabled",
+  "773": "createParamsFromClient should not be called in a server prerender.",
+  "774": "createServerParamsForRoute should not be called in a client prerender.",
+  "775": "createServerParamsForServerSegment should not be called in a client prerender.",
+  "776": "createPrerenderParamsForClientSegment should not be called in a server prerender."
 }

packages/next/src/server/request/cookies.ts

@@ -116,7 +116,19 @@ export function cookies(): Promise<ReadonlyRequestCookies> {
           )
         case 'prerender-runtime':
         case 'private-cache':
-          return makeUntrackedExoticCookies(workUnitStore.cookies)
+          if (process.env.__NEXT_CACHE_COMPONENTS) {
+            if (process.env.NODE_ENV === 'development') {
+              return makeUntrackedCookiesWithDevWarnings(workUnitStore.cookies)
+            }
+            return makeUntrackedCookies(workUnitStore.cookies)
+          } else {
+            if (process.env.NODE_ENV === 'development') {
+              return makeUntrackedExoticCookiesWithDevWarnings(
+                workUnitStore.cookies
+              )
+            }
+            return makeUntrackedExoticCookies(workUnitStore.cookies)
+          }
         case 'request':
           trackDynamicDataInDynamicRender(workUnitStore)
 
@@ -131,24 +143,24 @@ export function cookies(): Promise<ReadonlyRequestCookies> {
             underlyingCookies = workUnitStore.cookies
           }
 
-          if (
-            process.env.NODE_ENV === 'development' &&
-            !workStore?.isPrefetchRequest
-          ) {
-            if (process.env.__NEXT_CACHE_COMPONENTS) {
+          if (process.env.__NEXT_CACHE_COMPONENTS) {
+            if (process.env.NODE_ENV === 'development') {
               return makeUntrackedCookiesWithDevWarnings(
                 underlyingCookies,
                 workStore?.route
               )
             }
-
-            return makeUntrackedExoticCookiesWithDevWarnings(
-              underlyingCookies,
-              workStore?.route
-            )
+            return makeUntrackedCookies(underlyingCookies)
           } else {
+            if (process.env.NODE_ENV === 'development') {
+              return makeUntrackedExoticCookiesWithDevWarnings(
+                underlyingCookies,
+                workStore?.route
+              )
+            }
             return makeUntrackedExoticCookies(underlyingCookies)
           }
+
         default:
           workUnitStore satisfies never
       }
@@ -186,6 +198,15 @@ function makeHangingCookies(
   return promise
 }
 
+function makeUntrackedCookies(underlyingCookies: ReadonlyRequestCookies) {
+  let promise = CachedCookies.get(underlyingCookies)
+  if (!promise) {
+    promise = Promise.resolve(underlyingCookies)
+    CachedCookies.set(underlyingCookies, promise)
+  }
+  return promise
+}
+
 function makeUntrackedExoticCookies(
   underlyingCookies: ReadonlyRequestCookies
 ): Promise<ReadonlyRequestCookies> {

packages/next/src/server/request/draft-mode.ts

@@ -93,32 +93,31 @@ function createOrGetCachedDraftMode(
   workStore: WorkStore | undefined
 ): Promise<DraftMode> {
   const cacheKey = draftModeProvider ?? NullDraftMode
-  const cachedDraftMode = CachedDraftModes.get(cacheKey)
-
-  if (cachedDraftMode) {
-    return cachedDraftMode
-  }
-
-  let promise: Promise<DraftMode>
-
-  if (process.env.NODE_ENV === 'development' && !workStore?.isPrefetchRequest) {
-    const route = workStore?.route
+  let promise = CachedDraftModes.get(cacheKey)
 
+  if (!promise) {
     if (process.env.__NEXT_CACHE_COMPONENTS) {
-      return createDraftModeWithDevWarnings(draftModeProvider, route)
-    }
-
-    promise = createExoticDraftModeWithDevWarnings(draftModeProvider, route)
-  } else {
-    if (process.env.__NEXT_CACHE_COMPONENTS) {
-      return Promise.resolve(new DraftMode(draftModeProvider))
+      if (process.env.NODE_ENV === 'development') {
+        promise = createDraftModeWithDevWarnings(
+          draftModeProvider,
+          workStore?.route
+        )
+      } else {
+        promise = Promise.resolve(new DraftMode(draftModeProvider))
+      }
+    } else {
+      if (process.env.NODE_ENV === 'development') {
+        promise = createExoticDraftModeWithDevWarnings(
+          draftModeProvider,
+          workStore?.route
+        )
+      } else {
+        promise = createExoticDraftMode(draftModeProvider)
+      }
     }
-
-    promise = createExoticDraftMode(draftModeProvider)
+    CachedDraftModes.set(cacheKey, promise)
   }
 
-  CachedDraftModes.set(cacheKey, promise)
-
   return promise
 }
 

packages/next/src/server/request/headers.ts

@@ -150,25 +150,24 @@ export function headers(): Promise<ReadonlyHeaders> {
         case 'request':
           trackDynamicDataInDynamicRender(workUnitStore)
 
-          if (
-            process.env.NODE_ENV === 'development' &&
-            !workStore?.isPrefetchRequest
-          ) {
-            if (process.env.__NEXT_CACHE_COMPONENTS) {
+          if (process.env.__NEXT_CACHE_COMPONENTS) {
+            if (process.env.NODE_ENV === 'development') {
               return makeUntrackedHeadersWithDevWarnings(
                 workUnitStore.headers,
                 workStore?.route
               )
             }
-
-            return makeUntrackedExoticHeadersWithDevWarnings(
-              workUnitStore.headers,
-              workStore?.route
-            )
+            return makeUntrackedHeaders(workUnitStore.headers)
           } else {
+            if (process.env.NODE_ENV === 'development') {
+              return makeUntrackedExoticHeadersWithDevWarnings(
+                workUnitStore.headers,
+                workStore?.route
+              )
+            }
             return makeUntrackedExoticHeaders(workUnitStore.headers)
           }
-          break
+
         default:
           workUnitStore satisfies never
       }
@@ -199,6 +198,17 @@ function makeHangingHeaders(
   return promise
 }
 
+function makeUntrackedHeaders(
+  underlyingHeaders: ReadonlyHeaders
+): Promise<ReadonlyHeaders> {
+  let promise = CachedHeaders.get(underlyingHeaders)
+  if (!promise) {
+    promise = Promise.resolve(underlyingHeaders)
+    CachedHeaders.set(underlyingHeaders, promise)
+  }
+  return promise
+}
+
 function makeUntrackedExoticHeaders(
   underlyingHeaders: ReadonlyHeaders
 ): Promise<ReadonlyHeaders> {

packages/next/src/server/request/params.ts

@@ -63,11 +63,14 @@ export function createParamsFromClient(
   const workUnitStore = workUnitAsyncStorage.getStore()
   if (workUnitStore) {
     switch (workUnitStore.type) {
-      case 'prerender':
       case 'prerender-client':
       case 'prerender-ppr':
       case 'prerender-legacy':
         return createPrerenderParams(underlyingParams, workStore, workUnitStore)
+      case 'prerender':
+        throw new InvariantError(
+          'createParamsFromClient should not be called in a server prerender.'
+        )
       case 'cache':
       case 'private-cache':
       case 'unstable-cache':
@@ -100,10 +103,13 @@ export function createServerParamsForRoute(
   if (workUnitStore) {
     switch (workUnitStore.type) {
       case 'prerender':
-      case 'prerender-client':
       case 'prerender-ppr':
       case 'prerender-legacy':
         return createPrerenderParams(underlyingParams, workStore, workUnitStore)
+      case 'prerender-client':
+        throw new InvariantError(
+          'createServerParamsForRoute should not be called in a client prerender.'
+        )
       case 'cache':
       case 'private-cache':
       case 'unstable-cache':
@@ -128,10 +134,13 @@ export function createServerParamsForServerSegment(
   if (workUnitStore) {
     switch (workUnitStore.type) {
       case 'prerender':
-      case 'prerender-client':
       case 'prerender-ppr':
       case 'prerender-legacy':
         return createPrerenderParams(underlyingParams, workStore, workUnitStore)
+      case 'prerender-client':
+        throw new InvariantError(
+          'createServerParamsForServerSegment should not be called in a client prerender.'
+        )
       case 'cache':
       case 'private-cache':
       case 'unstable-cache':
@@ -154,7 +163,6 @@ export function createPrerenderParamsForClientSegment(
   const workUnitStore = workUnitAsyncStorage.getStore()
   if (workUnitStore) {
     switch (workUnitStore.type) {
-      case 'prerender':
       case 'prerender-client':
         const fallbackParams = workUnitStore.fallbackRouteParams
         if (fallbackParams) {
@@ -169,6 +177,10 @@ export function createPrerenderParamsForClientSegment(
           }
         }
         break
+      case 'prerender':
+        throw new InvariantError(
+          'createPrerenderParamsForClientSegment should not be called in a server prerender.'
+        )
       case 'cache':
       case 'private-cache':
       case 'unstable-cache':
@@ -245,23 +257,21 @@ function createRenderParams(
   underlyingParams: Params,
   workStore: WorkStore
 ): Promise<Params> {
-  if (process.env.NODE_ENV === 'development' && !workStore.isPrefetchRequest) {
-    if (process.env.__NEXT_CACHE_COMPONENTS) {
+  if (process.env.__NEXT_CACHE_COMPONENTS) {
+    if (process.env.NODE_ENV === 'development') {
       return makeDynamicallyTrackedParamsWithDevWarnings(
         underlyingParams,
         workStore
       )
     }
-
-    return makeDynamicallyTrackedExoticParamsWithDevWarnings(
-      underlyingParams,
-      workStore
-    )
+    return makeUntrackedParams(underlyingParams)
   } else {
-    if (process.env.__NEXT_CACHE_COMPONENTS) {
-      return makeUntrackedParams(underlyingParams)
+    if (process.env.NODE_ENV === 'development') {
+      return makeDynamicallyTrackedExoticParamsWithDevWarnings(
+        underlyingParams,
+        workStore
+      )
     }
-
     return makeUntrackedExoticParams(underlyingParams)
   }
 }

packages/next/src/server/request/search-params.ts

@@ -198,26 +198,21 @@ function createRenderSearchParams(
     // dictionary object.
     return Promise.resolve({})
   } else {
-    if (
-      process.env.NODE_ENV === 'development' &&
-      !workStore.isPrefetchRequest
-    ) {
-      if (process.env.__NEXT_CACHE_COMPONENTS) {
+    if (process.env.__NEXT_CACHE_COMPONENTS) {
+      if (process.env.NODE_ENV === 'development') {
         return makeUntrackedSearchParamsWithDevWarnings(
           underlyingSearchParams,
           workStore
         )
       }
-
-      return makeDynamicallyTrackedExoticSearchParamsWithDevWarnings(
-        underlyingSearchParams,
-        workStore
-      )
+      return makeUntrackedSearchParams(underlyingSearchParams)
     } else {
-      if (process.env.__NEXT_CACHE_COMPONENTS) {
-        return makeUntrackedSearchParams(underlyingSearchParams)
+      if (process.env.NODE_ENV === 'development') {
+        return makeDynamicallyTrackedExoticSearchParamsWithDevWarnings(
+          underlyingSearchParams,
+          workStore
+        )
       }
-
       return makeUntrackedExoticSearchParams(underlyingSearchParams)
     }
   }