[Segment Cache] Support <Link prefetch={true}> (vercel#74172)

This implements support in the Segment Cache for "full" link prefetches,
typically initiated by passing `prefetch={true}` to a `<Link>`.

The goal of a full prefetch is to request all the data needed for a
navigation, both static and dynamic, so that once the navigation occurs,
the router does not need to fetch any additional data. So, a full
prefetch implicitly instructs the client cache to treat the response as
static, even the dynamic data.

The implementation is largely the same as what we do to support
non-PPR-enabled routes — a request tree is sent to the server describing
which segments are already cached and which ones need to be rendered.
While constructing the request tree, if all the segments are already in
the client cache, the request can be skipped entirely. The main
difference is that a full prefetch will only reuse a cached segment
entry if it does not contain any dynamic holes.

Author: acdlite

packages/next/src/client/components/app-router.tsx

@@ -279,11 +279,12 @@ function Router({
         ? // Unlike the old implementation, the Segment Cache doesn't store its
           // data in the router reducer state; it writes into a global mutable
           // cache. So we don't need to dispatch an action.
-          (href) =>
+          (href, options) =>
             prefetchWithSegmentCache(
               href,
               actionQueue.state.nextUrl,
-              actionQueue.state.tree
+              actionQueue.state.tree,
+              options?.kind === PrefetchKind.FULL
             )
         : (href, options) => {
             // Use the old prefetch implementation.

packages/next/src/client/components/segment-cache/cache.ts

@@ -147,6 +147,7 @@ export type RouteCacheEntry =
 
 export const enum FetchStrategy {
   PPR,
+  Full,
   LoadingBoundary,
 }
 
@@ -1005,24 +1006,31 @@ export async function fetchSegmentOnCacheMiss(
   }
 }
 
-export async function fetchSegmentPrefetchesForPPRDisabledRoute(
+export async function fetchSegmentPrefetchesUsingDynamicRequest(
   task: PrefetchTask,
   route: FulfilledRouteCacheEntry,
+  fetchStrategy: FetchStrategy,
   dynamicRequestTree: FlightRouterState,
   spawnedEntries: Map<string, PendingSegmentCacheEntry>
 ): Promise<PrefetchSubtaskResult<null> | null> {
   const href = task.key.href
   const nextUrl = task.key.nextUrl
   const headers: RequestHeaders = {
     [RSC_HEADER]: '1',
-    [NEXT_ROUTER_PREFETCH_HEADER]: '1',
     [NEXT_ROUTER_STATE_TREE_HEADER]: encodeURIComponent(
       JSON.stringify(dynamicRequestTree)
     ),
   }
   if (nextUrl !== null) {
     headers[NEXT_URL] = nextUrl
   }
+  // Only set the prefetch header if we're not doing a "full" prefetch. We
+  // omit the prefetch header from a full prefetch because it's essentially
+  // just a navigation request that happens ahead of time — it should include
+  // all the same data in the response.
+  if (fetchStrategy !== FetchStrategy.Full) {
+    headers[NEXT_ROUTER_PREFETCH_HEADER] = '1'
+  }
   try {
     const response = await fetchPrefetchResponse(href, headers)
     if (!response || !response.ok || !response.body) {

packages/next/src/client/components/segment-cache/prefetch.ts

@@ -7,17 +7,24 @@ import { schedulePrefetchTask } from './scheduler'
  * Entrypoint for prefetching a URL into the Segment Cache.
  * @param href - The URL to prefetch. Typically this will come from a <Link>,
  * or router.prefetch. It must be validated before we attempt to prefetch it.
+ * @param nextUrl - A special header used by the server for interception routes.
+ * Roughly  corresponds to the current URL.
+ * @param treeAtTimeOfPrefetch - The FlightRouterState at the time the prefetch
+ * was requested. This is only used when PPR is disabled.
+ * @param includeDynamicData - Whether to prefetch dynamic data, in addition to
+ * static data. This is used by <Link prefetch={true}>.
  */
 export function prefetch(
   href: string,
   nextUrl: string | null,
-  treeAtTimeOfPrefetch: FlightRouterState
+  treeAtTimeOfPrefetch: FlightRouterState,
+  includeDynamicData: boolean
 ) {
   const url = createPrefetchURL(href)
   if (url === null) {
     // This href should not be prefetched.
     return
   }
   const cacheKey = createCacheKey(url.href, nextUrl)
-  schedulePrefetchTask(cacheKey, treeAtTimeOfPrefetch)
+  schedulePrefetchTask(cacheKey, treeAtTimeOfPrefetch, includeDynamicData)
 }