Ensure outputs are correct with cache components in deployment adapters (vercel#87018)

Updates our outputs to ensure we provide correct metadata and ISR pairs
when cache components are enabled.

---------

Co-authored-by: vercel[bot] <35613825+vercel[bot]@users.noreply.github.com>

Author: ijjk

packages/next/src/build/adapter/build-complete.ts

@@ -174,37 +174,50 @@ export interface AdapterOutput {
     /**
      * fallback is initial cache data generated during build for a prerender
      */
-    fallback?: {
-      /**
-       * path to the fallback file can be HTML/JSON/RSC
-       */
-      filePath: string
-      /**
-       * initialStatus is the status code that should be applied
-       * when serving the fallback
-       */
-      initialStatus?: number
-      /**
-       * initialHeaders are the headers that should be sent when
-       * serving the fallback
-       */
-      initialHeaders?: Record<string, string | string[]>
-      /**
-       * initial expiration is how long until the fallback entry
-       * is considered expired and no longer valid to serve
-       */
-      initialExpiration?: number
-      /**
-       * initial revalidate is how long until the fallback is
-       * considered stale and should be revalidated
-       */
-      initialRevalidate?: Revalidate
-
-      /**
-       * postponedState is the PPR state when it postponed and is used for resuming
-       */
-      postponedState?: string
-    }
+    fallback?:
+      | {
+          /**
+           * path to the fallback file can be HTML/JSON/RSC,
+           */
+          filePath: string
+          /**
+           * initialStatus is the status code that should be applied
+           * when serving the fallback
+           */
+          initialStatus?: number
+          /**
+           * initialHeaders are the headers that should be sent when
+           * serving the fallback
+           */
+          initialHeaders?: Record<string, string | string[]>
+          /**
+           * initial expiration is how long until the fallback entry
+           * is considered expired and no longer valid to serve
+           */
+          initialExpiration?: number
+          /**
+           * initial revalidate is how long until the fallback is
+           * considered stale and should be revalidated
+           */
+          initialRevalidate?: Revalidate
+
+          /**
+           * postponedState is the PPR state when it postponed and is used for resuming
+           */
+          postponedState?: string
+        }
+      | {
+          /*
+        a fallback filePath can be omitted when postponedState is
+        present which signals the fallback should just resume with
+        the postpone state but doesn't have fallback to seed cache
+      */
+          postponedState: string
+          initialExpiration?: number
+          initialRevalidate?: Revalidate
+          initialHeaders?: Record<string, string | string[]>
+          initialStatus?: number
+        }
     /**
      * config related to the route
      */
@@ -1164,7 +1177,6 @@ export async function handleBuildComplete({
           initialRevalidateSeconds: initialRevalidate,
           initialHeaders,
           initialStatus,
-          prefetchDataRoute,
           dataRoute,
           renderingMode,
           allowHeader,
@@ -1273,43 +1285,64 @@ export async function handleBuildComplete({
         outputs.prerenders.push(initialOutput)
 
         if (dataRoute) {
-          let dataFilePath = path.join(
+          let dataFilePath: string | undefined = path.join(
             pagesDistDir,
             `${normalizePagePath(route)}.json`
           )
+          let postponed = meta.postponed
 
           if (isAppPage) {
             // When experimental PPR is enabled, we expect that the data
             // that should be served as a part of the prerender should
             // be from the prefetch data route. If this isn't enabled
             // for ppr, the only way to get the data is from the data
             // route.
-            dataFilePath = path.join(
-              appDistDir,
-              prefetchDataRoute &&
-                renderingMode === RenderingMode.PARTIALLY_STATIC
-                ? prefetchDataRoute
-                : dataRoute
-            )
+            dataFilePath = path.join(appDistDir, dataRoute)
           }
 
-          outputs.prerenders.push({
-            ...initialOutput,
-            id: dataRoute,
-            pathname: dataRoute,
-            fallback: isNotFoundTrue
-              ? undefined
-              : {
-                  ...initialOutput.fallback,
-                  initialHeaders: {
-                    ...initialOutput.fallback?.initialHeaders,
-                    'content-type': isAppPage
-                      ? rscContentTypeHeader
-                      : JSON_CONTENT_TYPE_HEADER,
+          if (
+            renderingMode === RenderingMode.PARTIALLY_STATIC &&
+            !(await cachedFilePathCheck(dataFilePath))
+          ) {
+            // TODO: allowQuery should diverge based on app client param
+            // parsing flag
+            outputs.prerenders.push({
+              ...initialOutput,
+              id: dataRoute,
+              pathname: dataRoute,
+              fallback: !postponed
+                ? undefined
+                : {
+                    ...initialOutput.fallback,
+                    postponedState: postponed,
+                    initialHeaders: {
+                      ...initialOutput.fallback?.initialHeaders,
+                      'content-type': isAppPage
+                        ? rscContentTypeHeader
+                        : JSON_CONTENT_TYPE_HEADER,
+                    },
+                    filePath: undefined,
                   },
-                  filePath: dataFilePath,
-                },
-          })
+            })
+          } else {
+            outputs.prerenders.push({
+              ...initialOutput,
+              id: dataRoute,
+              pathname: dataRoute,
+              fallback: isNotFoundTrue
+                ? undefined
+                : {
+                    ...initialOutput.fallback,
+                    initialHeaders: {
+                      ...initialOutput.fallback?.initialHeaders,
+                      'content-type': isAppPage
+                        ? rscContentTypeHeader
+                        : JSON_CONTENT_TYPE_HEADER,
+                    },
+                    filePath: dataFilePath,
+                  },
+            })
+          }
         }
 
         if (isAppPage) {
@@ -1325,13 +1358,16 @@ export async function handleBuildComplete({
           fallbackRevalidate,
           fallbackHeaders,
           fallbackStatus,
+          fallbackSourceRoute,
           allowHeader,
           dataRoute,
           renderingMode,
           experimentalBypassFor,
         } = prerenderManifest.dynamicRoutes[dynamicRoute]
 
-        const isAppPage = Boolean(appOutputMap[dynamicRoute])
+        const srcRoute = fallbackSourceRoute || dynamicRoute
+        const parentOutput = getParentOutput(srcRoute, dynamicRoute)
+        const isAppPage = Boolean(appOutputMap[srcRoute])
 
         const allowQuery = Object.values(
           routesManifest.dynamicRoutes.find(
@@ -1344,7 +1380,7 @@ export async function handleBuildComplete({
           id: dynamicRoute,
           type: AdapterOutputType.PRERENDER,
           pathname: dynamicRoute,
-          parentOutputId: getParentOutput(dynamicRoute, dynamicRoute).id,
+          parentOutputId: parentOutput.id,
           groupId: prerenderGroupId,
           config: {
             allowQuery,
@@ -1380,7 +1416,25 @@ export async function handleBuildComplete({
             await handleAppMeta(dynamicRoute, initialOutput, meta)
           }
 
-          if (dataRoute) {
+          if (renderingMode === RenderingMode.PARTIALLY_STATIC) {
+            outputs.prerenders.push({
+              ...initialOutput,
+              id: `${dynamicRoute}.rsc`,
+              pathname: `${dynamicRoute}.rsc`,
+              fallback: meta.postponed
+                ? {
+                    ...initialOutput.fallback,
+                    postponedState: meta.postponed,
+                    initialHeaders: {
+                      ...initialOutput.fallback?.initialHeaders,
+                      'content-type': isAppPage
+                        ? rscContentTypeHeader
+                        : JSON_CONTENT_TYPE_HEADER,
+                    },
+                  }
+                : undefined,
+            })
+          } else if (dataRoute) {
             outputs.prerenders.push({
               ...initialOutput,
               id: dataRoute,
@@ -1521,7 +1575,7 @@ export async function handleBuildComplete({
           route.page
         ) + getDestinationQuery(route.routeKeys)
 
-      if (appPageKeys && appPageKeys.length > 0 && config.cacheComponents) {
+      if (appPageKeys && appPageKeys.length > 0) {
         // If we have fallback root params (implying we've already
         // emitted a rewrite for the /_tree request), or if the route
         // has PPR enabled and client param parsing is enabled, then

packages/next/src/build/define-env.ts

@@ -147,8 +147,6 @@ export function getDefineEnv({
       : process.env.NEXT_RSPACK
         ? 'Rspack'
         : 'Webpack',
-    // minimal mode is enforced when an adapter is configured
-    'process.env.MINIMAL_MODE': Boolean(config.experimental.adapterPath),
     // TODO: enforce `NODE_ENV` on `process.env`, and add a test:
     'process.env.NODE_ENV':
       dev || config.experimental.allowDevelopmentBuild

packages/next/src/build/templates/app-page.ts

@@ -121,9 +121,7 @@ export async function handler(
   if (routeModule.isDev) {
     addRequestMeta(req, 'devRequestTimingInternalsEnd', process.hrtime.bigint())
   }
-  const isMinimalMode = Boolean(
-    process.env.MINIMAL_MODE || getRequestMeta(req, 'minimalMode')
-  )
+  const isMinimalMode = Boolean(getRequestMeta(req, 'minimalMode'))
 
   let srcPage = 'VAR_DEFINITION_PAGE'
 

packages/next/src/build/templates/app-route.ts

@@ -280,9 +280,7 @@ export async function handler(
         }
       })
     }
-    const isMinimalMode = Boolean(
-      process.env.MINIMAL_MODE || getRequestMeta(req, 'minimalMode')
-    )
+    const isMinimalMode = Boolean(getRequestMeta(req, 'minimalMode'))
 
     const handleResponse = async (currentSpan?: Span) => {
       const responseGenerator: ResponseGenerator = async ({

packages/next/src/server/route-modules/pages/pages-handler.ts

@@ -102,9 +102,7 @@ export const getHandler = ({
       return
     }
 
-    const isMinimalMode = Boolean(
-      process.env.MINIMAL_MODE || getRequestMeta(req, 'minimalMode')
-    )
+    const isMinimalMode = Boolean(getRequestMeta(req, 'minimalMode'))
 
     const render404 = async () => {
       // TODO: should route-module itself handle rendering the 404

packages/next/src/server/route-modules/route-module.ts

@@ -965,10 +965,7 @@ export abstract class RouteModule<
 
   public getResponseCache(req: IncomingMessage | BaseNextRequest) {
     if (!this.responseCache) {
-      const minimalMode =
-        (Boolean(process.env.MINIMAL_MODE) ||
-          getRequestMeta(req, 'minimalMode')) ??
-        false
+      const minimalMode = getRequestMeta(req, 'minimalMode') ?? false
       this.responseCache = new ResponseCache(minimalMode)
     }
     return this.responseCache