Bring over Remix 2.9.2 logic for single fetch resource routes

integration/helpers/create-fixture.ts

@@ -27,7 +27,6 @@ export interface FixtureInit {
   template?: "cf-template" | "deno-template" | "node-template";
   useReactRouterServe?: boolean;
   spaMode?: boolean;
-  singleFetch?: boolean;
   port?: number;
 }
 
@@ -312,7 +311,7 @@ export async function createFixtureProject(
     filename.startsWith("vite.config.")
   );
 
-  let { singleFetch, spaMode } = init;
+  let { spaMode } = init;
 
   await writeTestFiles(
     {
@@ -321,7 +320,6 @@ export async function createFixtureProject(
         : {
             "vite.config.js": await viteConfig.basic({
               port,
-              singleFetch,
               spaMode,
             }),
           }),

integration/helpers/vite.ts

@@ -36,7 +36,6 @@ export const viteConfig = {
   basic: async (args: {
     port: number;
     fsAllow?: string[];
-    singleFetch?: boolean;
     spaMode?: boolean;
   }) => {
     let pluginOptions: VitePluginConfig = {

packages/remix-server-runtime/server.ts

@@ -32,11 +32,13 @@ import {
   getResponseStubs,
   getSingleFetchDataStrategy,
   getSingleFetchRedirect,
+  getSingleFetchResourceRouteDataStrategy,
   mergeResponseStubs,
   singleFetchAction,
   singleFetchLoaders,
   SingleFetchRedirectSymbol,
 } from "./single-fetch";
+import { ResponseStubOperationsSymbol } from "./routeModules";
 
 export type RequestHandler = (
   request: Request,
@@ -184,6 +186,7 @@ export const createRequestHandler: CreateRequestHandlerFunction = (
     ) {
       response = await handleResourceRequest(
         serverMode,
+        _build,
         staticHandler,
         matches.slice(-1)[0].route.id,
         request,
@@ -433,33 +436,47 @@ async function handleDocumentRequest(
 
 async function handleResourceRequest(
   serverMode: ServerMode,
+  build: ServerBuild,
   staticHandler: StaticHandler,
   routeId: string,
   request: Request,
   loadContext: AppLoadContext,
   handleError: (err: unknown) => void
 ) {
   try {
+    let responseStubs = getResponseStubs();
     // Note we keep the routeId here to align with the Remix handling of
     // resource routes which doesn't take ?index into account and just takes
     // the leaf match
     let response = await staticHandler.queryRoute(request, {
       routeId,
       requestContext: loadContext,
+      unstable_dataStrategy: getSingleFetchResourceRouteDataStrategy({
+        responseStubs,
+      }),
     });
+
     if (typeof response === "object") {
       invariant(
         !(DEFERRED_SYMBOL in response),
         `You cannot return a \`defer()\` response from a Resource Route.  Did you ` +
           `forget to export a default UI component from the "${routeId}" route?`
       );
     }
-    // callRouteLoader/callRouteAction always return responses (w/o single fetch).
-    // With single fetch, users should always be Responses from resource routes
+
     invariant(
       isResponse(response),
-      "Expected a Response to be returned from queryRoute"
+      "Expected a Response to be returned from resource route handler"
     );
+
+    let stub = responseStubs[routeId];
+    // Use the response status and merge any response stub headers onto it
+    let ops = stub[ResponseStubOperationsSymbol];
+    for (let [op, ...args] of ops) {
+      // @ts-expect-error
+      response.headers[op](...args);
+    }
+
     return response;
   } catch (error: unknown) {
     if (isResponse(error)) {

packages/remix-server-runtime/single-fetch.ts

@@ -1,6 +1,7 @@
 import type {
   StaticHandler,
   unstable_DataStrategyFunctionArgs as DataStrategyFunctionArgs,
+  unstable_DataStrategyFunction as DataStrategyFunction,
   StaticHandlerContext,
   UNSAFE_SingleFetchRedirectResult as SingleFetchRedirectResult,
   UNSAFE_SingleFetchResult as SingleFetchResult,
@@ -39,7 +40,7 @@ export function getSingleFetchDataStrategy(
     isActionDataRequest,
     loadRouteIds,
   }: { isActionDataRequest?: boolean; loadRouteIds?: string[] } = {}
-) {
+): DataStrategyFunction {
   return async ({ request, matches }: DataStrategyFunctionArgs) => {
     // Don't call loaders on action data requests
     if (isActionDataRequest && request.method === "GET") {
@@ -92,6 +93,32 @@ export function getSingleFetchDataStrategy(
   };
 }
 
+export function getSingleFetchResourceRouteDataStrategy({
+  responseStubs,
+}: {
+  responseStubs: ReturnType<typeof getResponseStubs>;
+}): DataStrategyFunction {
+  return async ({ matches }: DataStrategyFunctionArgs) => {
+    let results = await Promise.all(
+      matches.map(async (match) => {
+        let responseStub = match.shouldLoad
+          ? responseStubs[match.route.id]
+          : null;
+        let result = await match.resolve(async (handler) => {
+          // Cast `ResponseStubImpl -> ResponseStub` to hide the symbol in userland
+          let ctx: DataStrategyCtx = {
+            response: responseStub as ResponseStub,
+          };
+          let data = await handler(ctx);
+          return { type: "data", result: data };
+        });
+        return result;
+      })
+    );
+    return results;
+  };
+}
+
 export async function singleFetchAction(
   serverMode: ServerMode,
   staticHandler: StaticHandler,
@@ -118,7 +145,7 @@ export async function singleFetchAction(
       }),
     });
 
-    // Unlike `handleDataRequest`, when singleFetch is enabled, queryRoute does
+    // Unlike `handleDataRequest`, when singleFetch is enabled, query does
     // let non-Response return values through
     if (isResponse(result)) {
       return {