@tanstack/start-server-core 1.143.9 → 1.144.0

package/dist/esm/createStartHandler.js

@@ -1,5 +1,5 @@
 import { createMemoryHistory } from "@tanstack/history";
-import { flattenMiddlewares, mergeHeaders } from "@tanstack/start-client-core";
+import { flattenMiddlewares, createNullProtoObject, mergeHeaders, safeObjectMerge } from "@tanstack/start-client-core";
 import { isRedirect, isResolvedRedirect, executeRewriteInput } from "@tanstack/router-core";
 import { getOrigin, attachRouterServerSsrUtils } from "@tanstack/router-core/ssr/server";
 import { runWithStartContext } from "@tanstack/start-storage-context";
@@ -19,31 +19,110 @@ function getStartResponseHeaders(opts) {
   );
   return headers;
 }
-function createStartHandler(cb) {
-  const ROUTER_BASEPATH = process.env.TSS_ROUTER_BASEPATH || "/";
-  let startRoutesManifest = null;
-  let startEntry = null;
-  let routerEntry = null;
-  const getEntries = async () => {
-    if (routerEntry === null) {
-      routerEntry = await import("#tanstack-router-entry");
+let cachedStartEntry = null;
+let cachedRouterEntry = null;
+let cachedManifest = null;
+async function getEntries() {
+  if (cachedRouterEntry === null) {
+    cachedRouterEntry = await import("#tanstack-router-entry");
+  }
+  if (cachedStartEntry === null) {
+    cachedStartEntry = await import("#tanstack-start-entry");
+  }
+  return {
+    startEntry: cachedStartEntry,
+    routerEntry: cachedRouterEntry
+  };
+}
+async function getManifest() {
+  if (cachedManifest === null) {
+    cachedManifest = await getStartManifest();
+  }
+  return cachedManifest;
+}
+const ROUTER_BASEPATH = process.env.TSS_ROUTER_BASEPATH || "/";
+const SERVER_FN_BASE = process.env.TSS_SERVER_FN_BASE;
+const IS_PRERENDERING = process.env.TSS_PRERENDERING === "true";
+const IS_SHELL_ENV = process.env.TSS_SHELL === "true";
+const IS_DEV = process.env.NODE_ENV === "development";
+const ERR_NO_RESPONSE = IS_DEV ? `It looks like you forgot to return a response from your server route handler. If you want to defer to the app router, make sure to have a component set in this route.` : "Internal Server Error";
+const ERR_NO_DEFER = IS_DEV ? `You cannot defer to the app router if there is no component defined on this route.` : "Internal Server Error";
+function throwRouteHandlerError() {
+  throw new Error(ERR_NO_RESPONSE);
+}
+function throwIfMayNotDefer() {
+  throw new Error(ERR_NO_DEFER);
+}
+function isSpecialResponse(value) {
+  return value instanceof Response || isRedirect(value);
+}
+function handleCtxResult(result) {
+  if (isSpecialResponse(result)) {
+    return { response: result };
+  }
+  return result;
+}
+function executeMiddleware(middlewares, ctx) {
+  let index = -1;
+  const next = async (nextCtx) => {
+    if (nextCtx) {
+      if (nextCtx.context) {
+        ctx.context = safeObjectMerge(ctx.context, nextCtx.context);
+      }
+      for (const key of Object.keys(nextCtx)) {
+        if (key !== "context") {
+          ctx[key] = nextCtx[key];
+        }
+      }
     }
-    if (startEntry === null) {
-      startEntry = await import("#tanstack-start-entry");
+    index++;
+    const middleware = middlewares[index];
+    if (!middleware) return ctx;
+    let result;
+    try {
+      result = await middleware({ ...ctx, next });
+    } catch (err) {
+      if (isSpecialResponse(err)) {
+        ctx.response = err;
+        return ctx;
+      }
+      throw err;
+    }
+    const normalized = handleCtxResult(result);
+    if (normalized) {
+      if (normalized.response !== void 0) {
+        ctx.response = normalized.response;
+      }
+      if (normalized.context) {
+        ctx.context = safeObjectMerge(ctx.context, normalized.context);
+      }
+    }
+    return ctx;
+  };
+  return next();
+}
+function handlerToMiddleware(handler, mayDefer = false) {
+  if (mayDefer) {
+    return handler;
+  }
+  return async (ctx) => {
+    const response = await handler({ ...ctx, next: throwIfMayNotDefer });
+    if (!response) {
+      throwRouteHandlerError();
     }
-    return {
-      startEntry,
-      routerEntry
-    };
+    return response;
   };
+}
+function createStartHandler(cb) {
   const startRequestResolver = async (request, requestOpts) => {
     let router = null;
     let cbWillCleanup = false;
     try {
-      const origin = getOrigin(request);
       const url = new URL(request.url);
       const href = url.href.replace(url.origin, "");
-      const startOptions = await (await getEntries()).startEntry.startInstance?.getOptions() || {};
+      const origin = getOrigin(request);
+      const entries = await getEntries();
+      const startOptions = await entries.startEntry.startInstance?.getOptions() || {};
       const serializationAdapters = [
         ...startOptions.serializationAdapters || [],
         ServerFunctionSerializationAdapter
@@ -52,12 +131,15 @@ function createStartHandler(cb) {
         ...startOptions,
         serializationAdapters
       };
+      const flattenedRequestMiddlewares = startOptions.requestMiddleware ? flattenMiddlewares(startOptions.requestMiddleware) : [];
+      const executedRequestMiddlewares = new Set(
+        flattenedRequestMiddlewares
+      );
       const getRouter = async () => {
         if (router) return router;
-        router = await (await getEntries()).routerEntry.getRouter();
-        const isPrerendering = process.env.TSS_PRERENDERING === "true";
-        let isShell = process.env.TSS_SHELL === "true";
-        if (isPrerendering && !isShell) {
+        router = await entries.routerEntry.getRouter();
+        let isShell = IS_SHELL_ENV;
+        if (IS_PRERENDERING && !isShell) {
           isShell = request.headers.get(HEADERS.TSS_SHELL) === "true";
         }
         const history = createMemoryHistory({
@@ -66,7 +148,7 @@ function createStartHandler(cb) {
         router.update({
           history,
           isShell,
-          isPrerendering,
+          isPrerendering: IS_PRERENDERING,
           origin: router.options.origin ?? origin,
           ...{
             defaultSsr: requestStartOptions.defaultSsr,
@@ -79,140 +161,107 @@ function createStartHandler(cb) {
         });
         return router;
       };
-      const requestHandlerMiddleware = handlerToMiddleware(
-        async ({ context }) => {
-          const response2 = await runWithStartContext(
+      if (SERVER_FN_BASE && url.pathname.startsWith(SERVER_FN_BASE)) {
+        const serverFnId = url.pathname.slice(SERVER_FN_BASE.length).split("/")[0];
+        if (!serverFnId) {
+          throw new Error("Invalid server action param for serverFnId");
+        }
+        const serverFnHandler = async ({ context }) => {
+          return runWithStartContext(
             {
               getRouter,
               startOptions: requestStartOptions,
               contextAfterGlobalMiddlewares: context,
-              request
+              request,
+              executedRequestMiddlewares
             },
-            async () => {
-              try {
-                if (href.startsWith(process.env.TSS_SERVER_FN_BASE)) {
-                  return await handleServerAction({
-                    request,
-                    context: requestOpts?.context
-                  });
-                }
-                const executeRouter = async ({
-                  serverContext
-                }) => {
-                  const requestAcceptHeader = request.headers.get("Accept") || "*/*";
-                  const splitRequestAcceptHeader = requestAcceptHeader.split(",");
-                  const supportedMimeTypes = ["*/*", "text/html"];
-                  const isRouterAcceptSupported = supportedMimeTypes.some(
-                    (mimeType) => splitRequestAcceptHeader.some(
-                      (acceptedMimeType) => acceptedMimeType.trim().startsWith(mimeType)
-                    )
-                  );
-                  if (!isRouterAcceptSupported) {
-                    return Response.json(
-                      {
-                        error: "Only HTML requests are supported here"
-                      },
-                      {
-                        status: 500
-                      }
-                    );
-                  }
-                  if (startRoutesManifest === null) {
-                    startRoutesManifest = await getStartManifest();
-                  }
-                  const router2 = await getRouter();
-                  attachRouterServerSsrUtils({
-                    router: router2,
-                    manifest: startRoutesManifest
-                  });
-                  router2.update({ additionalContext: { serverContext } });
-                  await router2.load();
-                  if (router2.state.redirect) {
-                    return router2.state.redirect;
-                  }
-                  await router2.serverSsr.dehydrate();
-                  const responseHeaders = getStartResponseHeaders({ router: router2 });
-                  cbWillCleanup = true;
-                  const response4 = await cb({
-                    request,
-                    router: router2,
-                    responseHeaders
-                  });
-                  return response4;
-                };
-                const response3 = await handleServerRoutes({
-                  getRouter,
-                  request,
-                  executeRouter,
-                  context
-                });
-                return response3;
-              } catch (err) {
-                if (err instanceof Response) {
-                  return err;
-                }
-                throw err;
-              }
-            }
+            () => handleServerAction({
+              request,
+              context: requestOpts?.context,
+              serverFnId
+            })
           );
-          return response2;
-        }
-      );
-      const flattenedMiddlewares = startOptions.requestMiddleware ? flattenMiddlewares(startOptions.requestMiddleware) : [];
-      const middlewares = flattenedMiddlewares.map((d) => d.options.server);
-      const ctx = await executeMiddleware(
-        [...middlewares, requestHandlerMiddleware],
-        {
+        };
+        const middlewares2 = flattenedRequestMiddlewares.map(
+          (d) => d.options.server
+        );
+        const ctx2 = await executeMiddleware([...middlewares2, serverFnHandler], {
           request,
-          context: requestOpts?.context || {}
-        }
-      );
-      const response = ctx.response;
-      if (isRedirect(response)) {
-        if (isResolvedRedirect(response)) {
-          if (request.headers.get("x-tsr-redirect") === "manual") {
-            return Response.json(
-              {
-                ...response.options,
-                isSerializedRedirect: true
-              },
-              {
-                headers: response.headers
-              }
-            );
-          }
-          return response;
-        }
-        if (response.options.to && typeof response.options.to === "string" && !response.options.to.startsWith("/")) {
-          throw new Error(
-            `Server side redirects must use absolute paths via the 'href' or 'to' options. The redirect() method's "to" property accepts an internal path only. Use the "href" property to provide an external URL. Received: ${JSON.stringify(response.options)}`
+          context: createNullProtoObject(requestOpts?.context)
+        });
+        return handleRedirectResponse(ctx2.response, request, getRouter);
+      }
+      const executeRouter = async (serverContext) => {
+        const acceptHeader = request.headers.get("Accept") || "*/*";
+        const acceptParts = acceptHeader.split(",");
+        const supportedMimeTypes = ["*/*", "text/html"];
+        const isSupported = supportedMimeTypes.some(
+          (mimeType) => acceptParts.some((part) => part.trim().startsWith(mimeType))
+        );
+        if (!isSupported) {
+          return Response.json(
+            { error: "Only HTML requests are supported here" },
+            { status: 500 }
           );
         }
-        if (["params", "search", "hash"].some(
-          (d) => typeof response.options[d] === "function"
-        )) {
-          throw new Error(
-            `Server side redirects must use static search, params, and hash values and do not support functional values. Received functional values for: ${Object.keys(
-              response.options
-            ).filter((d) => typeof response.options[d] === "function").map((d) => `"${d}"`).join(", ")}`
-          );
+        const manifest = await getManifest();
+        const routerInstance = await getRouter();
+        attachRouterServerSsrUtils({
+          router: routerInstance,
+          manifest
+        });
+        routerInstance.update({ additionalContext: { serverContext } });
+        await routerInstance.load();
+        if (routerInstance.state.redirect) {
+          return routerInstance.state.redirect;
         }
-        const router2 = await getRouter();
-        const redirect = router2.resolveRedirect(response);
-        if (request.headers.get("x-tsr-redirect") === "manual") {
-          return Response.json(
-            {
-              ...response.options,
-              isSerializedRedirect: true
-            },
-            {
-              headers: response.headers
+        await routerInstance.serverSsr.dehydrate();
+        const responseHeaders = getStartResponseHeaders({
+          router: routerInstance
+        });
+        cbWillCleanup = true;
+        return cb({
+          request,
+          router: routerInstance,
+          responseHeaders
+        });
+      };
+      const requestHandlerMiddleware = async ({ context }) => {
+        return runWithStartContext(
+          {
+            getRouter,
+            startOptions: requestStartOptions,
+            contextAfterGlobalMiddlewares: context,
+            request,
+            executedRequestMiddlewares
+          },
+          async () => {
+            try {
+              return await handleServerRoutes({
+                getRouter,
+                request,
+                url,
+                executeRouter,
+                context,
+                executedRequestMiddlewares
+              });
+            } catch (err) {
+              if (err instanceof Response) {
+                return err;
+              }
+              throw err;
             }
-          );
-        }
-        return redirect;
-      }
-      return response;
+          }
+        );
+      };
+      const middlewares = flattenedRequestMiddlewares.map(
+        (d) => d.options.server
+      );
+      const ctx = await executeMiddleware(
+        [...middlewares, requestHandlerMiddleware],
+        { request, context: createNullProtoObject(requestOpts?.context) }
+      );
+      return handleRedirectResponse(ctx.response, request, getRouter);
     } finally {
       if (router && !cbWillCleanup) {
         router.serverSsr?.cleanup();
@@ -222,137 +271,99 @@ function createStartHandler(cb) {
   };
   return requestHandler(startRequestResolver);
 }
+async function handleRedirectResponse(response, request, getRouter) {
+  if (!isRedirect(response)) {
+    return response;
+  }
+  if (isResolvedRedirect(response)) {
+    if (request.headers.get("x-tsr-serverFn") === "true") {
+      return Response.json(
+        { ...response.options, isSerializedRedirect: true },
+        { headers: response.headers }
+      );
+    }
+    return response;
+  }
+  const opts = response.options;
+  if (opts.to && typeof opts.to === "string" && !opts.to.startsWith("/")) {
+    throw new Error(
+      `Server side redirects must use absolute paths via the 'href' or 'to' options. The redirect() method's "to" property accepts an internal path only. Use the "href" property to provide an external URL. Received: ${JSON.stringify(opts)}`
+    );
+  }
+  if (["params", "search", "hash"].some(
+    (d) => typeof opts[d] === "function"
+  )) {
+    throw new Error(
+      `Server side redirects must use static search, params, and hash values and do not support functional values. Received functional values for: ${Object.keys(
+        opts
+      ).filter((d) => typeof opts[d] === "function").map((d) => `"${d}"`).join(", ")}`
+    );
+  }
+  const router = await getRouter();
+  const redirect = router.resolveRedirect(response);
+  if (request.headers.get("x-tsr-serverFn") === "true") {
+    return Response.json(
+      { ...response.options, isSerializedRedirect: true },
+      { headers: response.headers }
+    );
+  }
+  return redirect;
+}
 async function handleServerRoutes({
   getRouter,
   request,
+  url,
   executeRouter,
-  context
+  context,
+  executedRequestMiddlewares
 }) {
   const router = await getRouter();
-  let url = new URL(request.url);
-  url = executeRewriteInput(router.rewrite, url);
-  const pathname = url.pathname;
+  const rewrittenUrl = executeRewriteInput(router.rewrite, url);
+  const pathname = rewrittenUrl.pathname;
   const { matchedRoutes, foundRoute, routeParams } = router.getMatchedRoutes(pathname);
   const isExactMatch = foundRoute && routeParams["**"] === void 0;
-  const middlewares = flattenMiddlewares(
-    matchedRoutes.flatMap((r) => r.options.server?.middleware).filter(Boolean)
-  ).map((d) => d.options.server);
+  const routeMiddlewares = [];
+  for (const route of matchedRoutes) {
+    const serverMiddleware = route.options.server?.middleware;
+    if (serverMiddleware) {
+      const flattened = flattenMiddlewares(serverMiddleware);
+      for (const m of flattened) {
+        if (!executedRequestMiddlewares.has(m)) {
+          routeMiddlewares.push(m.options.server);
+        }
+      }
+    }
+  }
   const server = foundRoute?.options.server;
-  if (server && isExactMatch) {
-    if (server.handlers) {
-      const handlers = typeof server.handlers === "function" ? server.handlers({
-        createHandlers: (d) => d
-      }) : server.handlers;
-      const requestMethod = request.method.toUpperCase();
-      const handler = handlers[requestMethod] ?? handlers["ANY"];
-      if (handler) {
-        const mayDefer = !!foundRoute.options.component;
-        if (typeof handler === "function") {
-          middlewares.push(handlerToMiddleware(handler, mayDefer));
-        } else {
-          const { middleware } = handler;
-          if (middleware && middleware.length) {
-            middlewares.push(
-              ...flattenMiddlewares(middleware).map((d) => d.options.server)
-            );
-          }
-          if (handler.handler) {
-            middlewares.push(handlerToMiddleware(handler.handler, mayDefer));
+  if (server?.handlers && isExactMatch) {
+    const handlers = typeof server.handlers === "function" ? server.handlers({ createHandlers: (d) => d }) : server.handlers;
+    const requestMethod = request.method.toUpperCase();
+    const handler = handlers[requestMethod] ?? handlers["ANY"];
+    if (handler) {
+      const mayDefer = !!foundRoute.options.component;
+      if (typeof handler === "function") {
+        routeMiddlewares.push(handlerToMiddleware(handler, mayDefer));
+      } else {
+        if (handler.middleware?.length) {
+          const handlerMiddlewares = flattenMiddlewares(handler.middleware);
+          for (const m of handlerMiddlewares) {
+            routeMiddlewares.push(m.options.server);
           }
         }
+        if (handler.handler) {
+          routeMiddlewares.push(handlerToMiddleware(handler.handler, mayDefer));
+        }
       }
     }
   }
-  middlewares.push(
-    handlerToMiddleware((ctx2) => executeRouter({ serverContext: ctx2.context }))
-  );
-  const ctx = await executeMiddleware(middlewares, {
+  routeMiddlewares.push((ctx2) => executeRouter(ctx2.context));
+  const ctx = await executeMiddleware(routeMiddlewares, {
     request,
     context,
     params: routeParams,
     pathname
   });
-  const response = ctx.response;
-  return response;
-}
-function throwRouteHandlerError() {
-  if (process.env.NODE_ENV === "development") {
-    throw new Error(
-      `It looks like you forgot to return a response from your server route handler. If you want to defer to the app router, make sure to have a component set in this route.`
-    );
-  }
-  throw new Error("Internal Server Error");
-}
-function throwIfMayNotDefer() {
-  if (process.env.NODE_ENV === "development") {
-    throw new Error(
-      `You cannot defer to the app router if there is no component defined on this route.`
-    );
-  }
-  throw new Error("Internal Server Error");
-}
-function handlerToMiddleware(handler, mayDefer = false) {
-  if (mayDefer) {
-    return handler;
-  }
-  return async ({ next: _next, ...rest }) => {
-    const response = await handler({ ...rest, next: throwIfMayNotDefer });
-    if (!response) {
-      throwRouteHandlerError();
-    }
-    return response;
-  };
-}
-function executeMiddleware(middlewares, ctx) {
-  let index = -1;
-  const next = async (ctx2) => {
-    index++;
-    const middleware = middlewares[index];
-    if (!middleware) return ctx2;
-    let result;
-    try {
-      result = await middleware({
-        ...ctx2,
-        // Allow the middleware to call the next middleware in the chain
-        next: async (nextCtx) => {
-          const nextResult = await next({
-            ...ctx2,
-            ...nextCtx,
-            context: {
-              ...ctx2.context,
-              ...nextCtx?.context || {}
-            }
-          });
-          return Object.assign(ctx2, handleCtxResult(nextResult));
-        }
-        // Allow the middleware result to extend the return context
-      });
-    } catch (err) {
-      if (isSpecialResponse(err)) {
-        result = {
-          response: err
-        };
-      } else {
-        throw err;
-      }
-    }
-    return Object.assign(ctx2, handleCtxResult(result));
-  };
-  return handleCtxResult(next(ctx));
-}
-function handleCtxResult(result) {
-  if (isSpecialResponse(result)) {
-    return {
-      response: result
-    };
-  }
-  return result;
-}
-function isSpecialResponse(err) {
-  return isResponse(err) || isRedirect(err);
-}
-function isResponse(response) {
-  return response instanceof Response;
+  return ctx.response;
 }
 export {
   createStartHandler