@tanstack/start-server-core 1.132.0-alpha.8 → 1.132.0

package/dist/esm/createStartHandler.d.ts

@@ -1,7 +1,4 @@
-import { RequestHandler } from './request-response.js';
-import { AnyRouter, Awaitable } from '@tanstack/router-core';
+import { RequestHandler } from './request-handler.js';
+import { AnyRouter, Register } from '@tanstack/router-core';
 import { HandlerCallback } from '@tanstack/router-core/ssr/server';
-export type CustomizeStartHandler<TRouter extends AnyRouter> = (cb: HandlerCallback<TRouter>) => RequestHandler;
-export declare function createStartHandler<TRouter extends AnyRouter>({ createRouter, }: {
-    createRouter: () => Awaitable<TRouter>;
-}): CustomizeStartHandler<TRouter>;
+export declare function createStartHandler<TRegister = Register>(cb: HandlerCallback<AnyRouter>): RequestHandler<TRegister>;

package/dist/esm/createStartHandler.js

@@ -1,13 +1,11 @@
 import { createMemoryHistory } from "@tanstack/history";
-import { json, mergeHeaders, flattenMiddlewares } from "@tanstack/start-client-core";
-import { joinPaths, trimPath, processRouteTree, isRedirect, isResolvedRedirect, getMatchedRoutes } from "@tanstack/router-core";
+import { flattenMiddlewares, json, mergeHeaders } from "@tanstack/start-client-core";
+import { joinPaths, trimPath, isRedirect, isResolvedRedirect, executeRewriteInput } from "@tanstack/router-core";
 import { attachRouterServerSsrUtils } from "@tanstack/router-core/ssr/server";
 import { runWithStartContext } from "@tanstack/start-storage-context";
 import { requestHandler, getResponseHeaders } from "./request-response.js";
 import { getStartManifest } from "./router-manifest.js";
 import { handleServerAction } from "./server-functions-handler.js";
-import { VIRTUAL_MODULES } from "./virtual-modules.js";
-import { loadVirtualModule } from "./loadVirtualModule.js";
 import { HEADERS } from "./constants.js";
 import { ServerFunctionSerializationAdapter } from "./serializer/ServerFunctionSerializationAdapter.js";
 function getStartResponseHeaders(opts) {
@@ -22,172 +20,180 @@ function getStartResponseHeaders(opts) {
   );
   return headers;
 }
-function createStartHandler({
-  createRouter
-}) {
-  let routeTreeModule = null;
+function createStartHandler(cb) {
+  if (!process.env.TSS_SERVER_FN_BASE) {
+    throw new Error(
+      "tanstack/start-server-core: TSS_SERVER_FN_BASE must be defined in your environment for createStartHandler()"
+    );
+  }
+  const APP_BASE = process.env.TSS_APP_BASE || "/";
+  const serverFnBase = joinPaths([
+    APP_BASE,
+    trimPath(process.env.TSS_SERVER_FN_BASE),
+    "/"
+  ]);
   let startRoutesManifest = null;
-  let processedServerRouteTree = void 0;
-  return (cb) => {
-    const originalFetch = globalThis.fetch;
-    const startRequestResolver = async (request) => {
-      globalThis.fetch = async function(input, init) {
-        function resolve(url2, requestOptions) {
-          const fetchRequest = new Request(url2, requestOptions);
-          return startRequestResolver(fetchRequest);
-        }
-        function getOrigin() {
-          return request.headers.get("Origin") || request.headers.get("Referer") || "http://localhost";
-        }
-        if (typeof input === "string" && input.startsWith("/")) {
-          const url2 = new URL(input, getOrigin());
-          return resolve(url2, init);
-        } else if (typeof input === "object" && "url" in input && typeof input.url === "string" && input.url.startsWith("/")) {
-          const url2 = new URL(input.url, getOrigin());
-          return resolve(url2, init);
-        }
-        return originalFetch(input, init);
-      };
-      const url = new URL(request.url);
-      const href = url.href.replace(url.origin, "");
-      const APP_BASE = process.env.TSS_APP_BASE || "/";
-      const router = await createRouter();
-      const history = createMemoryHistory({
-        initialEntries: [href]
-      });
+  let startEntry = null;
+  let routerEntry = null;
+  const getEntries = async () => {
+    if (routerEntry === null) {
+      routerEntry = await import("#tanstack-router-entry");
+    }
+    if (startEntry === null) {
+      startEntry = await import("#tanstack-start-entry");
+    }
+    return {
+      startEntry,
+      routerEntry
+    };
+  };
+  const originalFetch = globalThis.fetch;
+  const startRequestResolver = async (request, requestOpts) => {
+    function getOrigin() {
+      const originHeader = request.headers.get("Origin");
+      if (originHeader) {
+        return originHeader;
+      }
+      try {
+        return new URL(request.url).origin;
+      } catch {
+      }
+      return "http://localhost";
+    }
+    globalThis.fetch = async function(input, init) {
+      function resolve(url2, requestOptions) {
+        const fetchRequest = new Request(url2, requestOptions);
+        return startRequestResolver(fetchRequest, requestOpts);
+      }
+      if (typeof input === "string" && input.startsWith("/")) {
+        const url2 = new URL(input, getOrigin());
+        return resolve(url2, init);
+      } else if (typeof input === "object" && "url" in input && typeof input.url === "string" && input.url.startsWith("/")) {
+        const url2 = new URL(input.url, getOrigin());
+        return resolve(url2, init);
+      }
+      return originalFetch(input, init);
+    };
+    const url = new URL(request.url);
+    const href = url.href.replace(url.origin, "");
+    let router = null;
+    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) {
         isShell = request.headers.get(HEADERS.TSS_SHELL) === "true";
       }
-      const serializationAdapters = (router.options.serializationAdapters ?? []).concat(ServerFunctionSerializationAdapter);
+      const history = createMemoryHistory({
+        initialEntries: [href]
+      });
+      const origin = router.options.origin ?? getOrigin();
       router.update({
         history,
         isShell,
         isPrerendering,
-        serializationAdapters
+        origin,
+        ...{
+          defaultSsr: startOptions.defaultSsr,
+          serializationAdapters: startOptions.serializationAdapters
+        }
       });
-      const response = await runWithStartContext({ router }, async () => {
-        try {
-          if (!process.env.TSS_SERVER_FN_BASE) {
-            throw new Error(
-              "tanstack/start-server-core: TSS_SERVER_FN_BASE must be defined in your environment for createStartHandler()"
-            );
-          }
-          const serverFnBase = joinPaths([
-            APP_BASE,
-            trimPath(process.env.TSS_SERVER_FN_BASE),
-            "/"
-          ]);
-          if (href.startsWith(serverFnBase)) {
-            return await handleServerAction({ request });
-          }
-          if (routeTreeModule === null) {
+      return router;
+    };
+    const startOptions = await (await getEntries()).startEntry.startInstance?.getOptions() || {};
+    startOptions.serializationAdapters = startOptions.serializationAdapters || [];
+    startOptions.serializationAdapters.push(ServerFunctionSerializationAdapter);
+    const requestHandlerMiddleware = handlerToMiddleware(
+      async ({ context }) => {
+        const response2 = await runWithStartContext(
+          {
+            getRouter,
+            startOptions,
+            contextAfterGlobalMiddlewares: context
+          },
+          async () => {
             try {
-              routeTreeModule = await loadVirtualModule(
-                VIRTUAL_MODULES.routeTree
-              );
-              if (routeTreeModule.serverRouteTree) {
-                processedServerRouteTree = processRouteTree({
-                  routeTree: routeTreeModule.serverRouteTree,
-                  initRoute: (route, i) => {
-                    route.init({
-                      originalIndex: i
-                    });
-                  }
+              if (href.startsWith(serverFnBase)) {
+                return await handleServerAction({
+                  request,
+                  context: requestOpts?.context
                 });
               }
-            } catch (e) {
-              console.log(e);
-            }
-          }
-          const executeRouter = async () => {
-            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 json(
-                {
-                  error: "Only HTML requests are supported here"
-                },
-                {
-                  status: 500
+              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 json(
+                    {
+                      error: "Only HTML requests are supported here"
+                    },
+                    {
+                      status: 500
+                    }
+                  );
                 }
-              );
-            }
-            if (startRoutesManifest === null) {
-              startRoutesManifest = await getStartManifest({
-                basePath: APP_BASE
+                if (startRoutesManifest === null) {
+                  startRoutesManifest = await getStartManifest({
+                    basePath: APP_BASE
+                  });
+                }
+                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 });
+                const response4 = await cb({
+                  request,
+                  router: router2,
+                  responseHeaders
+                });
+                return response4;
+              };
+              const response3 = await handleServerRoutes({
+                getRouter,
+                request,
+                executeRouter
               });
-            }
-            attachRouterServerSsrUtils(router, startRoutesManifest);
-            await router.load();
-            if (router.state.redirect) {
-              return router.state.redirect;
-            }
-            await router.serverSsr.dehydrate();
-            const responseHeaders = getStartResponseHeaders({ router });
-            const response2 = await cb({
-              request,
-              router,
-              responseHeaders
-            });
-            return response2;
-          };
-          if (processedServerRouteTree) {
-            const [_matchedRoutes, response2] = await handleServerRoutes({
-              processedServerRouteTree,
-              router,
-              request,
-              basePath: APP_BASE,
-              executeRouter
-            });
-            if (response2) return response2;
-          }
-          const routerResponse = await executeRouter();
-          return routerResponse;
-        } catch (err) {
-          if (err instanceof Response) {
-            return err;
-          }
-          throw err;
-        }
-      });
-      if (isRedirect(response)) {
-        if (isResolvedRedirect(response)) {
-          if (request.headers.get("x-tsr-redirect") === "manual") {
-            return json(
-              {
-                ...response.options,
-                isSerializedRedirect: true
-              },
-              {
-                headers: response.headers
+              return response3;
+            } catch (err) {
+              if (err instanceof Response) {
+                return err;
               }
-            );
+              throw err;
+            }
           }
-          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)}`
-          );
-        }
-        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 redirect = router.resolveRedirect(response);
+        );
+        return response2;
+      }
+    );
+    const flattenedMiddlewares = startOptions.requestMiddleware ? flattenMiddlewares(startOptions.requestMiddleware) : [];
+    const middlewares = flattenedMiddlewares.map((d) => d.options.server);
+    const ctx = await executeMiddleware(
+      [...middlewares, requestHandlerMiddleware],
+      {
+        request,
+        context: requestOpts?.context || {}
+      }
+    );
+    const response = ctx.response;
+    if (isRedirect(response)) {
+      if (isResolvedRedirect(response)) {
         if (request.headers.get("x-tsr-redirect") === "manual") {
           return json(
             {
@@ -199,96 +205,131 @@ function createStartHandler({
             }
           );
         }
-        return redirect;
+        return response;
       }
-      return response;
-    };
-    return requestHandler(startRequestResolver);
+      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)}`
+        );
+      }
+      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 router2 = await getRouter();
+      const redirect = router2.resolveRedirect(response);
+      if (request.headers.get("x-tsr-redirect") === "manual") {
+        return json(
+          {
+            ...response.options,
+            isSerializedRedirect: true
+          },
+          {
+            headers: response.headers
+          }
+        );
+      }
+      return redirect;
+    }
+    return response;
   };
+  return requestHandler(startRequestResolver);
 }
-async function handleServerRoutes(opts) {
-  const url = new URL(opts.request.url);
+async function handleServerRoutes({
+  getRouter,
+  request,
+  executeRouter
+}) {
+  const router = await getRouter();
+  let url = new URL(request.url);
+  url = executeRewriteInput(router.rewrite, url);
   const pathname = url.pathname;
-  const serverTreeResult = getMatchedRoutes({
+  const { matchedRoutes, foundRoute, routeParams } = router.getMatchedRoutes(
     pathname,
-    basepath: opts.basePath,
-    caseSensitive: true,
-    routesByPath: opts.processedServerRouteTree.routesByPath,
-    routesById: opts.processedServerRouteTree.routesById,
-    flatRoutes: opts.processedServerRouteTree.flatRoutes
-  });
-  const routeTreeResult = opts.router.getMatchedRoutes(pathname, void 0);
-  let response;
-  let matchedRoutes = [];
-  matchedRoutes = serverTreeResult.matchedRoutes;
-  if (routeTreeResult.foundRoute) {
-    if (serverTreeResult.matchedRoutes.length < routeTreeResult.matchedRoutes.length) {
-      const closestCommon = [...routeTreeResult.matchedRoutes].reverse().find((r) => {
-        return opts.processedServerRouteTree.routesById[r.id] !== void 0;
-      });
-      if (closestCommon) {
-        let routeId = closestCommon.id;
-        matchedRoutes = [];
-        do {
-          const route = opts.processedServerRouteTree.routesById[routeId];
-          if (!route) {
-            break;
-          }
-          matchedRoutes.push(route);
-          routeId = route.parentRoute?.id;
-        } while (routeId);
-        matchedRoutes.reverse();
-      }
-    }
-  }
-  if (matchedRoutes.length) {
-    const middlewares = flattenMiddlewares(
-      matchedRoutes.flatMap((r) => r.options.middleware).filter(Boolean)
-    ).map((d) => d.options.server);
-    if (serverTreeResult.foundRoute?.options.methods) {
-      const method = Object.keys(
-        serverTreeResult.foundRoute.options.methods
-      ).find(
-        (method2) => method2.toLowerCase() === opts.request.method.toLowerCase()
+    void 0
+  );
+  const middlewares = flattenMiddlewares(
+    matchedRoutes.flatMap((r) => r.options.server?.middleware).filter(Boolean)
+  ).map((d) => d.options.server);
+  const server = foundRoute?.options.server;
+  if (server) {
+    if (server.handlers) {
+      const handlers = typeof server.handlers === "function" ? server.handlers({
+        createHandlers: (d) => d
+      }) : server.handlers;
+      const requestMethod = request.method.toLowerCase();
+      let method = Object.keys(handlers).find(
+        (method2) => method2.toLowerCase() === requestMethod
       );
+      if (!method) {
+        method = Object.keys(handlers).find(
+          (method2) => method2.toLowerCase() === "all"
+        ) ? "all" : void 0;
+      }
       if (method) {
-        const handler = serverTreeResult.foundRoute.options.methods[method];
+        const handler = handlers[method];
         if (handler) {
+          const mayDefer = !!foundRoute.options.component;
           if (typeof handler === "function") {
-            middlewares.push(handlerToMiddleware(handler));
+            middlewares.push(handlerToMiddleware(handler, mayDefer));
           } else {
-            if (handler._options.middlewares && handler._options.middlewares.length) {
+            const { middleware } = handler;
+            if (middleware && middleware.length) {
               middlewares.push(
-                ...flattenMiddlewares(handler._options.middlewares).map(
-                  (d) => d.options.server
-                )
+                ...flattenMiddlewares(middleware).map((d) => d.options.server)
               );
             }
-            if (handler._options.handler) {
-              middlewares.push(handlerToMiddleware(handler._options.handler));
+            if (handler.handler) {
+              middlewares.push(handlerToMiddleware(handler.handler, mayDefer));
             }
           }
         }
       }
     }
-    middlewares.push(handlerToMiddleware(opts.executeRouter));
-    const ctx = await executeMiddleware(middlewares, {
-      request: opts.request,
-      context: {},
-      params: serverTreeResult.routeParams,
-      pathname
-    });
-    response = ctx.response;
   }
-  return [matchedRoutes, response];
+  middlewares.push(
+    handlerToMiddleware((ctx2) => executeRouter({ serverContext: ctx2.context }))
+  );
+  const ctx = await executeMiddleware(middlewares, {
+    request,
+    context: {},
+    params: routeParams,
+    pathname
+  });
+  const response = ctx.response;
+  return response;
 }
-function handlerToMiddleware(handler) {
+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);
-    if (response) {
-      return { response };
+    const response = await handler({ ...rest, next: throwIfMayNotDefer });
+    if (!response) {
+      throwRouteHandlerError();
     }
-    return _next(rest);
+    return response;
   };
 }
 function executeMiddleware(middlewares, ctx) {