@reckona/mreact-router 0.0.175 → 0.0.177

package/src/node-server.ts

@@ -0,0 +1,129 @@
+import { createServer, type Server } from "node:http";
+import { nodeRequestToWebRequest, sendResponse } from "./http.js";
+import {
+  emitRouterLog,
+  logDurationMs,
+  logError,
+  logNow,
+  nodeRequestPath,
+  requestLogFields,
+  type AppRouterLogger,
+} from "./logger.js";
+import type { HttpUpgradeHandler } from "./upgrade.js";
+
+export interface StartNodeRequestServerOptions {
+  allowedHosts?: readonly string[] | undefined;
+  errorHandler?: ((error: unknown) => {
+    body: string;
+    status: number;
+    headers?: Record<string, string>;
+  }) | undefined;
+  hostname?: string | undefined;
+  hostPolicy?: "strict" | "trusted-proxy" | undefined;
+  logger?: AppRouterLogger | undefined;
+  onUpgrade?: HttpUpgradeHandler | undefined;
+  port: number;
+  render(request: Request): Promise<Response>;
+  resolveHost?: ((options: {
+    allowedHosts?: readonly string[] | undefined;
+    fallbackHost: string;
+    hostPolicy?: "strict" | "trusted-proxy" | undefined;
+    rawHost: string | undefined;
+  }) => string) | undefined;
+}
+
+export async function startNodeRequestServer(
+  options: StartNodeRequestServerOptions,
+): Promise<{ close(): Promise<void>; server: Server; url: string }> {
+  const server = createServer(async (incoming, outgoing) => {
+    const startedAt = logNow();
+    const fallbackRequestFields = {
+      method: incoming.method ?? "GET",
+      path: nodeRequestPath(incoming.url),
+      runtime: "node" as const,
+    };
+
+    try {
+      const fallbackHost = `${options.hostname ?? "127.0.0.1"}:${options.port}`;
+      const host = (options.resolveHost ?? defaultResolveRequestHost)({
+        allowedHosts: options.allowedHosts,
+        fallbackHost,
+        hostPolicy: options.hostPolicy,
+        rawHost: incoming.headers.host,
+      });
+      const request = nodeRequestToWebRequest(incoming, `http://${host}`);
+      const logFields = requestLogFields(request, "node");
+      emitRouterLog(options.logger, "info", {
+        ...logFields,
+        type: "router:request:start",
+      });
+      const response = await options.render(request);
+      emitRouterLog(options.logger, "info", {
+        ...logFields,
+        durationMs: logDurationMs(startedAt),
+        status: response.status,
+        type: "router:request:end",
+      });
+
+      await sendResponse(outgoing, response);
+    } catch (error) {
+      // Log the full stack to stderr for operator visibility; never put
+      // it in the response body where attackers can scrape it.
+      emitRouterLog(options.logger, "error", {
+        ...fallbackRequestFields,
+        durationMs: logDurationMs(startedAt),
+        error: logError(error),
+        type: "router:request:error",
+      });
+      if (options.logger === undefined) {
+        console.error("[mreact] startServer request failed:", error);
+      }
+      const payload = options.errorHandler
+        ? options.errorHandler(error)
+        : { body: "Internal Server Error", status: 500 };
+      outgoing.statusCode = payload.status;
+      outgoing.setHeader(
+        "content-type",
+        payload.headers?.["content-type"] ?? "text/plain; charset=utf-8",
+      );
+      for (const [name, value] of Object.entries(payload.headers ?? {})) {
+        if (name.toLowerCase() === "content-type") continue;
+        outgoing.setHeader(name, value);
+      }
+      outgoing.end(payload.body);
+    }
+  });
+
+  if (options.onUpgrade !== undefined) {
+    server.on("upgrade", options.onUpgrade);
+  }
+
+  await new Promise<void>((resolve) =>
+    server.listen(options.port, options.hostname ?? "127.0.0.1", resolve),
+  );
+  const address = server.address();
+  const port = typeof address === "object" && address !== null ? address.port : options.port;
+
+  return {
+    server,
+    url: `http://${options.hostname ?? "127.0.0.1"}:${port}`,
+    close: () =>
+      new Promise<void>((resolve, reject) =>
+        server.close((error) => (error ? reject(error) : resolve())),
+      ),
+  };
+}
+
+function defaultResolveRequestHost(options: {
+  allowedHosts?: readonly string[] | undefined;
+  fallbackHost: string;
+  hostPolicy?: "strict" | "trusted-proxy" | undefined;
+  rawHost: string | undefined;
+}): string {
+  const raw = options.rawHost;
+  if (raw === undefined || raw === "") return options.fallbackHost;
+  if (options.allowedHosts === undefined) {
+    return options.hostPolicy === "strict" ? options.fallbackHost : raw;
+  }
+  return options.allowedHosts.includes(raw) ? raw : options.fallbackHost;
+}

package/src/render.ts

@@ -144,6 +144,12 @@ import {
   prebuiltServerModuleOutputOptionsMatch,
   type BuiltServerModuleOutputLike,
 } from "./route-module-loader.js";
+import {
+  loadRouteDataFromModule,
+  type RouteDataContext,
+  type RouteLoaderModule,
+} from "./route-loader-runtime.js";
+import { pageRouteMethodResponse } from "./route-dispatch.js";
 
 const nativeEscapeTransform = {
   batchImportName: "escapeHtmlBatch",
@@ -166,6 +172,13 @@ interface RenderTiming {
   phases: Record<string, number>;
 }
 
+/**
+ * Loads prebuilt server render artifacts immediately before a route render needs them.
+ */
+export interface AppRouterServerRenderArtifactLoader {
+  load(routeFile: string): Promise<void>;
+}
+
 /**
  * Configures server rendering for a source app-router request.
  */
@@ -205,6 +218,10 @@ export interface RenderAppRequestOptions {
   vitePlugins?: readonly PluginOption[] | undefined;
 }
 
+export interface RenderAppRequestRuntimeOptions extends RenderAppRequestOptions {
+  serverRenderArtifactLoader?: AppRouterServerRenderArtifactLoader | undefined;
+}
+
 export interface AppRouterRenderPreload {
   promise: Promise<void>;
   wait: "before-render";
@@ -723,15 +740,11 @@ async function waitForRenderPreload(
 }
 
 async function loadServerRenderArtifacts(
-  options: RenderAppRequestOptions,
+  options: RenderAppRequestRuntimeOptions,
   routeFile: string,
   timing: RenderTiming | undefined,
 ): Promise<void> {
-  const loader = (
-    options as RenderAppRequestOptions & {
-      __mreactLoadServerRenderArtifacts?: ((routeFile: string) => Promise<void>) | undefined;
-    }
-  ).__mreactLoadServerRenderArtifacts;
+  const loader = options.serverRenderArtifactLoader;
 
   if (loader === undefined) {
     return;
@@ -739,14 +752,14 @@ async function loadServerRenderArtifacts(
 
   const phaseStartedAt = renderTimingPhaseStartedAt(timing);
   try {
-    await loader(routeFile);
+    await loader.load(routeFile);
   } finally {
     finishRenderTimingPhase(timing, phaseStartedAt, "renderArtifactLoadMs");
   }
 }
 
 function emitRenderTiming(
-  options: RenderAppRequestOptions,
+  options: RenderAppRequestRuntimeOptions,
   timing: RenderTiming | undefined,
   status: number,
 ): void {
@@ -798,7 +811,7 @@ export async function resolveAppRouterMiddleware(options: {
   return { response: middlewareResponse, type: "response" };
 }
 
-async function renderAppRequestInternal(options: RenderAppRequestOptions): Promise<Response> {
+async function renderAppRequestInternal(options: RenderAppRequestRuntimeOptions): Promise<Response> {
   warnProductionRenderWithoutPrebuiltModules(options);
   const timing = createRenderTiming(options.logger);
   const clientRouteInferenceCache =
@@ -967,18 +980,9 @@ async function renderAppRequestInternal(options: RenderAppRequestOptions): Promi
     // methods (PUT, PATCH, DELETE, PROPFIND, ...) get 405 with an
     // Allow header so the response shape complies with RFC 9110 §9
     // and so caching intermediaries do not cross-cache method results.
-    const method = options.request.method;
-    if (method === "OPTIONS") {
-      return new Response(null, {
-        status: 204,
-        headers: { allow: "GET, HEAD, OPTIONS" },
-      });
-    }
-    if (method !== "GET" && method !== "HEAD") {
-      return new Response("Method Not Allowed", {
-        status: 405,
-        headers: { allow: "GET, HEAD, OPTIONS" },
-      });
+    const methodResponse = pageRouteMethodResponse(options.request.method);
+    if (methodResponse !== undefined) {
+      return methodResponse;
     }
 
     routeCacheContext = beginRouteCacheContext(options.routeCache);
@@ -4389,17 +4393,6 @@ async function loadRouteMiddlewareControlFile(options: {
   return control;
 }
 
-interface RouteDataContext {
-  env?: unknown;
-  params: RouteParams;
-  queryClient: QueryClient;
-  request: Request;
-}
-
-interface RouteLoaderModule {
-  loader?: (context: RouteDataContext) => unknown;
-}
-
 interface RouteMetadataContext {
   data: unknown;
   params: RouteParams;
@@ -4427,34 +4420,19 @@ async function loadRouteData(options: {
   timing?: RenderTiming | undefined;
   vitePlugins?: readonly PluginOption[] | undefined;
 }): Promise<unknown> {
-  if (!hasLoaderExport(options.code)) {
-    return undefined;
-  }
-
-  let module: RouteLoaderModule;
-  const moduleLoadStartedAt = renderTimingPhaseStartedAt(options.timing);
-  try {
-    module = await loadRouteLoaderModule(options);
-  } finally {
-    finishRenderTimingPhase(options.timing, moduleLoadStartedAt, "loaderModuleLoadMs");
-  }
-
-  if (module.loader === undefined) {
-    return undefined;
-  }
-
-  const executionStartedAt = renderTimingPhaseStartedAt(options.timing);
-  try {
-    return await module.loader(options.context);
-  } catch (error) {
-    if (error instanceof Response) {
-      return error;
-    }
-
-    throw error;
-  } finally {
-    finishRenderTimingPhase(options.timing, executionStartedAt, "loaderExecutionMs");
-  }
+  return await loadRouteDataFromModule({
+    context: options.context,
+    hasLoader: hasLoaderExport(options.code),
+    loadModule: () => loadRouteLoaderModule(options),
+    timing: {
+      finish(startedAt, phase) {
+        finishRenderTimingPhase(options.timing, startedAt, phase);
+      },
+      start() {
+        return renderTimingPhaseStartedAt(options.timing);
+      },
+    },
+  });
 }
 
 async function loadRouteDataWithInstrumentation(options: {

package/src/route-dispatch.ts

@@ -0,0 +1,17 @@
+export function pageRouteMethodResponse(method: string): Response | undefined {
+  if (method === "GET" || method === "HEAD") {
+    return undefined;
+  }
+
+  if (method === "OPTIONS") {
+    return new Response(null, {
+      status: 204,
+      headers: { allow: "GET, HEAD, OPTIONS" },
+    });
+  }
+
+  return new Response("Method Not Allowed", {
+    status: 405,
+    headers: { allow: "GET, HEAD, OPTIONS" },
+  });
+}

package/src/route-loader-runtime.ts

@@ -0,0 +1,54 @@
+import type { QueryClient } from "@reckona/mreact-query";
+import type { RouteParams } from "./types.js";
+
+export interface RouteDataContext {
+  env?: unknown;
+  params: RouteParams;
+  queryClient: QueryClient;
+  request: Request;
+}
+
+export interface RouteLoaderModule {
+  loader?: (context: RouteDataContext) => unknown;
+}
+
+export interface RouteLoaderRuntimeTiming {
+  finish(startedAt: number | undefined, phase: "loaderExecutionMs" | "loaderModuleLoadMs"): void;
+  start(): number | undefined;
+}
+
+export async function loadRouteDataFromModule(options: {
+  context: RouteDataContext;
+  hasLoader: boolean;
+  loadModule(): Promise<RouteLoaderModule>;
+  timing?: RouteLoaderRuntimeTiming | undefined;
+}): Promise<unknown> {
+  if (!options.hasLoader) {
+    return undefined;
+  }
+
+  let module: RouteLoaderModule;
+  const moduleLoadStartedAt = options.timing?.start();
+  try {
+    module = await options.loadModule();
+  } finally {
+    options.timing?.finish(moduleLoadStartedAt, "loaderModuleLoadMs");
+  }
+
+  if (module.loader === undefined) {
+    return undefined;
+  }
+
+  const executionStartedAt = options.timing?.start();
+  try {
+    return await module.loader(options.context);
+  } catch (error) {
+    if (error instanceof Response) {
+      return error;
+    }
+
+    throw error;
+  } finally {
+    options.timing?.finish(executionStartedAt, "loaderExecutionMs");
+  }
+}

package/src/routes.ts

@@ -80,6 +80,11 @@ export interface RouteMatcher {
   match(pathname: string): MatchedRoute | undefined;
 }
 
+interface MatchRouteCacheEntry {
+  fingerprint: string;
+  matcher: RouteMatcher;
+}
+
 export type CompiledRouteMatcherSegment =
   | { kind: "static"; value: string }
   | { kind: "dynamic"; name: string }
@@ -99,6 +104,11 @@ export interface CompiledRouteMatcherArtifact {
   version: 1;
 }
 
+let matchRouteMatcherCache = new WeakMap<readonly AppRoute[], MatchRouteCacheEntry>();
+let matchRouteMatcherBuildCountForTest = 0;
+let matchRouteFingerprintIds = new WeakMap<AppRoute, number>();
+let nextMatchRouteFingerprintId = 1;
+
 /**
  * Scans an app directory and returns sorted app-router route definitions.
  */
@@ -137,7 +147,28 @@ export function matchRoute(
   routes: readonly AppRoute[],
   pathname: string,
 ): MatchedRoute | undefined {
-  return createRouteMatcher(routes).match(pathname);
+  const fingerprint = routeMatcherFingerprint(routes);
+  const cached = matchRouteMatcherCache.get(routes);
+
+  if (cached !== undefined && cached.fingerprint === fingerprint) {
+    return cached.matcher.match(pathname);
+  }
+
+  const matcher = createRouteMatcher(routes);
+  matchRouteMatcherBuildCountForTest += 1;
+  matchRouteMatcherCache.set(routes, { fingerprint, matcher });
+  return matcher.match(pathname);
+}
+
+export function __resetMatchRouteCacheForTest(): void {
+  matchRouteMatcherCache = new WeakMap();
+  matchRouteMatcherBuildCountForTest = 0;
+  matchRouteFingerprintIds = new WeakMap();
+  nextMatchRouteFingerprintId = 1;
+}
+
+export function __getMatchRouteMatcherBuildCountForTest(): number {
+  return matchRouteMatcherBuildCountForTest;
 }
 
 export function compileRouteMatcherArtifact(
@@ -204,6 +235,44 @@ function compileRouteMatcherEntry(
       };
 }
 
+function routeMatcherFingerprint(routes: readonly AppRoute[]): string {
+  const parts: string[] = [String(routes.length)];
+
+  for (const route of routes) {
+    parts.push(
+      String(routeMatcherRouteFingerprintId(route)),
+      route.kind,
+      route.path,
+      String(route.segments.length),
+    );
+
+    for (const segment of route.segments) {
+      parts.push(segment.kind);
+
+      if (segment.kind === "static") {
+        parts.push(segment.value);
+      } else {
+        parts.push(segment.name);
+      }
+    }
+  }
+
+  return parts.map((part) => `${part.length}:${part}`).join("|");
+}
+
+function routeMatcherRouteFingerprintId(route: AppRoute): number {
+  const cached = matchRouteFingerprintIds.get(route);
+
+  if (cached !== undefined) {
+    return cached;
+  }
+
+  const id = nextMatchRouteFingerprintId;
+  nextMatchRouteFingerprintId += 1;
+  matchRouteFingerprintIds.set(route, id);
+  return id;
+}
+
 function matchCompiledRoutes(
   routes: readonly AppRoute[],
   artifact: CompiledRouteMatcherArtifact,