Function createBaseHandler

packages/start/src/server/handler.ts:18–135

(
  createPageEvent: (e: FetchEvent) => Promise<PageEvent>,
  fn: (context: PageEvent) => JSX.Element,
  options: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>) = {},
)

const SERVER_FN_BASE = "/_server";

export function createBaseHandler(
  createPageEvent: (e: FetchEvent) => Promise<PageEvent>,
  fn: (context: PageEvent) => JSX.Element,
  options: HandlerOptions | ((context: PageEvent) => HandlerOptions | Promise<HandlerOptions>) = {},
) {
  const handler = defineHandler({
    middleware: middleware.length ? middleware.map(decorateMiddleware) : undefined,
    handler: decorateHandler(async (e: H3Event) => {
      const event = getRequestEvent()!;
      const url = new URL(event.request.url);
      const pathname = stripBaseUrl(url.pathname);

      if (pathname.startsWith(SERVER_FN_BASE)) {
        const serverFnResponse = await handleServerFunction(e);

        if (serverFnResponse instanceof Response)
          return produceResponseWithEventHeaders(serverFnResponse);

        return new Response(serverFnResponse as any, {
          headers: e.res.headers,
        });
      }

      const match = matchAPIRoute(pathname, event.request.method);
      if (match) {
        const mod = await match.handler.import();
        const fn =
          event.request.method === "HEAD" ? mod["HEAD"] || mod["GET"] : mod[event.request.method];
        if (typeof fn === "function") {
          (event as APIEvent).params = match.params || {};
          // @ts-expect-error
          sharedConfig.context = { event };
          const res = await fn(event);
          if (res !== undefined) {
            if (res instanceof Response) return produceResponseWithEventHeaders(res);

            return res;
          }
          if (event.request.method !== "GET") {
            throw new Error(
              `API handler for ${event.request.method} "${event.request.url}" did not return a response.`,
            );
          }
          if (!match.isPage) return;
        }
      }

      const context = await createPageEvent(event);

      const resolvedOptions =
        typeof options === "function" ? await options(context) : { ...options };
      const mode = resolvedOptions.mode || "stream";
      if (resolvedOptions.nonce) context.nonce = resolvedOptions.nonce;

      if (mode === "sync" || !import.meta.env.START_SSR) {
        const html = renderToString(() => {
          (sharedConfig.context as any).event = context;
          return fn(context);