Refactor getSingleFetchDataStrategy to better support rsc

Author: brophdawg11

packages/react-router/index.ts

@@ -351,7 +351,7 @@ export {
 } from "./lib/dom/ssr/routes";
 
 /** @internal */
-export { getSingleFetchDataStrategy as UNSAFE_getSingleFetchDataStrategy } from "./lib/dom/ssr/single-fetch";
+export { getTurboStreamSingleFetchDataStrategy as UNSAFE_getTurboStreamSingleFetchDataStrategy } from "./lib/dom/ssr/single-fetch";
 
 /** @internal */
 export {

packages/react-router/lib/dom-export/hydrated-router.tsx

@@ -16,7 +16,7 @@ import {
   UNSAFE_createClientRoutes as createClientRoutes,
   UNSAFE_createRouter as createRouter,
   UNSAFE_deserializeErrors as deserializeErrors,
-  UNSAFE_getSingleFetchDataStrategy as getSingleFetchDataStrategy,
+  UNSAFE_getTurboStreamSingleFetchDataStrategy as getTurboStreamSingleFetchDataStrategy,
   UNSAFE_getPatchRoutesOnNavigationFunction as getPatchRoutesOnNavigationFunction,
   UNSAFE_shouldHydrateRouteLoader as shouldHydrateRouteLoader,
   UNSAFE_useFogOFWarDiscovery as useFogOFWarDiscovery,
@@ -176,22 +176,10 @@ function createHydratedRouter({
     future: {
       unstable_middleware: ssrInfo.context.future.unstable_middleware,
     },
-    dataStrategy: getSingleFetchDataStrategy(
+    dataStrategy: getTurboStreamSingleFetchDataStrategy(
       () => router,
-      (routeId: string) => {
-        let manifestRoute = ssrInfo!.manifest.routes[routeId];
-        invariant(manifestRoute, "Route not found in manifest/routeModules");
-        let routeModule = ssrInfo!.routeModules[routeId];
-        return {
-          hasLoader: manifestRoute.hasLoader,
-          hasClientLoader: manifestRoute.hasClientLoader,
-          // In some cases the module may not be loaded yet and we don't care
-          // if it's got shouldRevalidate or not
-          hasShouldRevalidate: routeModule
-            ? routeModule.shouldRevalidate != null
-            : undefined,
-        };
-      },
+      ssrInfo.manifest,
+      ssrInfo.routeModules,
       ssrInfo.context.ssr,
       ssrInfo.context.basename
     ),

packages/react-router/lib/dom/ssr/single-fetch.tsx

@@ -15,9 +15,11 @@ import {
   stripBasename,
 } from "../../router/utils";
 import { createRequestInit } from "./data";
-import type { EntryContext } from "./entry";
+import type { AssetsManifest, EntryContext } from "./entry";
 import { escapeHtml } from "./markup";
 import invariant from "./invariant";
+import type { RouteModules } from "./routeModules";
+import type { DataRouteMatch } from "../../context";
 
 export const SingleFetchRedirectSymbol = Symbol("SingleFetchRedirect");
 
@@ -147,10 +149,10 @@ export function StreamTransfer({
   }
 }
 
-type GetRouteInfoFunction = (routeId: string) => {
+type GetRouteInfoFunction = (match: DataRouteMatch) => {
   hasLoader: boolean;
-  hasClientLoader: boolean; // TODO: Can this be read from match.route?
-  hasShouldRevalidate: boolean | undefined; // TODO: Can this be read from match.route?
+  hasClientLoader: boolean;
+  hasShouldRevalidate: boolean;
 };
 
 type FetchAndDecodeFunction = (
@@ -159,23 +161,33 @@ type FetchAndDecodeFunction = (
   targetRoutes?: string[]
 ) => Promise<{ status: number; data: DecodedSingleFetchResults }>;
 
-export function getSingleFetchDataStrategy(
+export function getTurboStreamSingleFetchDataStrategy(
   getRouter: () => DataRouter,
-  getRouteInfo: GetRouteInfoFunction,
+  manifest: AssetsManifest,
+  routeModules: RouteModules,
   ssr: boolean,
   basename: string | undefined
 ): DataStrategyFunction {
-  let dataStrategy = getSingleFetchDataStrategyImpl(
+  let dataStrategy = getTurboStreamSingleFetchDataStrategyImpl(
     getRouter,
-    getRouteInfo,
+    (match: DataRouteMatch) => {
+      let manifestRoute = manifest.routes[match.route.id];
+      invariant(manifestRoute, "Route not found in manifest");
+      let routeModule = routeModules[match.route.id];
+      return {
+        hasLoader: manifestRoute.hasLoader,
+        hasClientLoader: manifestRoute.hasClientLoader,
+        hasShouldRevalidate: Boolean(routeModule?.shouldRevalidate),
+      };
+    },
     fetchAndDecodeViaTurboStream,
     ssr,
     basename
   );
   return async (args) => args.unstable_runClientMiddleware(dataStrategy);
 }
 
-export function getSingleFetchDataStrategyImpl(
+export function getTurboStreamSingleFetchDataStrategyImpl(
   getRouter: () => DataRouter,
   getRouteInfo: GetRouteInfoFunction,
   fetchAndDecode: FetchAndDecodeFunction,
@@ -192,7 +204,7 @@ export function getSingleFetchDataStrategyImpl(
     }
 
     let foundRevalidatingServerLoader = matches.some((m) => {
-      let { hasLoader, hasClientLoader } = getRouteInfo(m.route.id);
+      let { hasLoader, hasClientLoader } = getRouteInfo(m);
       return m.unstable_shouldCallHandler() && hasLoader && !hasClientLoader;
     });
     if (!ssr && !foundRevalidatingServerLoader) {
@@ -298,7 +310,7 @@ async function nonSsrStrategy(
     matchesToLoad.map((m) =>
       m.resolve(async (handler) => {
         try {
-          let { hasClientLoader } = getRouteInfo(m.route.id);
+          let { hasClientLoader } = getRouteInfo(m);
           // Need to pass through a `singleFetch` override handler so
           // clientLoader's can still call server loaders through `.data`
           // requests
@@ -350,7 +362,7 @@ async function singleFetchLoaderNavigationStrategy(
         routeDfds[i].resolve();
         let routeId = m.route.id;
         let { hasLoader, hasClientLoader, hasShouldRevalidate } =
-          getRouteInfo(routeId);
+          getRouteInfo(m);
 
         let defaultShouldRevalidate =
           !m.unstable_shouldRevalidateArgs ||