@reckona/mreact-router 0.0.203 → 0.0.205

package/src/dev-server.ts

@@ -1,7 +1,9 @@
 import { createServer, type Server } from "node:http";
 import type { ServerResponse } from "node:http";
 import { readFile } from "node:fs/promises";
-import { resolve } from "node:path";
+import { isIP } from "node:net";
+import { posix, resolve } from "node:path";
+import type { DehydrateOptions } from "@reckona/mreact-query";
 import { createServer as createViteServer, type UserConfig, type ViteDevServer } from "vite";
 import type { AppRouterServerActionOptions } from "./actions.js";
 import { createMemoryRouteCache, type AppRouterCache } from "./cache.js";
@@ -19,12 +21,21 @@ import {
   nodeRequestPath,
   type AppRouterLogger,
 } from "./logger.js";
-import type { HttpUpgradeHandler } from "./upgrade.js";
+import {
+  assertValidHttpUpgradeOriginPolicy,
+  closeServerWithUpgrades,
+  createManagedHttpUpgradeLifecycle,
+  validateHttpUpgradeOrigin,
+  type HttpUpgradeOriginPolicy,
+  type HttpUpgradeOriginValidation,
+  type ManagedHttpUpgradeHandler,
+} from "./upgrade.js";
 
 /**
  * Configures the Vite-powered app-router development server.
  */
 export interface StartDevServerOptions extends AppRouterProjectOptions {
+  dehydrateOptions?: DehydrateOptions | undefined;
   port?: number | undefined;
   hostname?: string;
   importPolicy?: AppRouterImportPolicy | undefined;
@@ -33,7 +44,10 @@ export interface StartDevServerOptions extends AppRouterProjectOptions {
   serverActions?: AppRouterServerActionOptions | undefined;
   verboseErrors?: boolean | undefined;
   viteConfig?: UserConfig | undefined;
-  onUpgrade?: HttpUpgradeHandler | undefined;
+  onUpgrade?: ManagedHttpUpgradeHandler | undefined;
+  upgradeCloseTimeoutMs?: number | undefined;
+  upgradeDecisionTimeoutMs?: number | undefined;
+  upgradeOriginPolicy?: HttpUpgradeOriginPolicy | undefined;
 }
 
 /**
@@ -53,6 +67,17 @@ export async function startDevServer(
   const userHmrConfig =
     typeof userViteServerConfig.hmr === "object" ? userViteServerConfig.hmr : {};
   const port = options.port ?? resolved.serverPort ?? 3001;
+  const upgradeCloseTimeoutMs = finiteNonNegativeTimeout(
+    options.upgradeCloseTimeoutMs,
+    1_000,
+    "upgradeCloseTimeoutMs",
+  );
+  const upgradeDecisionTimeoutMs = finiteNonNegativeTimeout(
+    options.upgradeDecisionTimeoutMs,
+    1_000,
+    "upgradeDecisionTimeoutMs",
+  );
+  assertValidHttpUpgradeOriginPolicy(options.upgradeOriginPolicy);
   const routeCache = options.routeCache ?? createMemoryRouteCache();
   const declaredPackages = await readDeclaredProjectPackages(project.projectRoot);
   const configImportPolicy = resolved.importPolicy;
@@ -68,6 +93,7 @@ export async function startDevServer(
     ],
   };
   let vite: ViteDevServer | undefined;
+  let actualPort = port;
   const server = createServer((incoming, outgoing) => {
     const logger = options.logger;
     const startedAt = logger === undefined ? undefined : logNow();
@@ -115,8 +141,25 @@ export async function startDevServer(
     });
   });
 
-  if (options.onUpgrade !== undefined) {
-    server.on("upgrade", options.onUpgrade);
+  const upgradeLifecycle =
+    options.onUpgrade === undefined
+      ? undefined
+      : createManagedHttpUpgradeLifecycle({
+          decisionTimeoutMs: upgradeDecisionTimeoutMs,
+          handler: options.onUpgrade,
+          isOriginAllowed: (request) =>
+            validateDevUpgradeOrigin(
+              request,
+              options.upgradeOriginPolicy,
+              hostname,
+              actualPort,
+              vite,
+            ),
+          logger: options.logger,
+          shouldBypass: (request) => isViteHmrUpgradeRequest(request, vite),
+        });
+  if (upgradeLifecycle !== undefined) {
+    server.on("upgrade", upgradeLifecycle.handle);
   }
 
   vite = await createViteServer({
@@ -133,6 +176,8 @@ export async function startDevServer(
       ...(userViteConfig.plugins ?? []),
       createAppRouterVitePlugin({
         allowedSourceDirs: project.allowedSourceDirs,
+        dehydrateOptions: options.dehydrateOptions ?? resolved.dehydrateOptions,
+        dehydratePolicyModule: project.dehydratePolicyModule,
         projectRoot: project.projectRoot,
         publicDir: project.publicDir,
         routesDir: project.routesDir,
@@ -151,20 +196,140 @@ export async function startDevServer(
     throw error;
   }
   const address = server.address();
-  const actualPort = typeof address === "object" && address !== null ? address.port : port;
+  actualPort = typeof address === "object" && address !== null ? address.port : port;
+  let closePromise: Promise<void> | undefined;
 
   return {
     server,
-    url: `http://${hostname}:${actualPort}`,
-    close: async () => {
-      await vite?.close();
-      await new Promise<void>((resolve, reject) => {
-        server.close((error) => (error ? reject(error) : resolve()));
-      });
+    url: `http://${formatNodeAuthority(hostname, actualPort)}`,
+    close: () => {
+      closePromise ??= (async () => {
+        upgradeLifecycle?.beginClose();
+        const httpClose =
+          upgradeLifecycle === undefined
+            ? new Promise<void>((resolve, reject) => {
+                server.close((error) => (error ? reject(error) : resolve()));
+              })
+            : closeServerWithUpgrades({
+                lifecycle: upgradeLifecycle,
+                server,
+                timeoutMs: upgradeCloseTimeoutMs,
+              });
+        const results = await Promise.allSettled([vite?.close(), httpClose]);
+        const errors = results.flatMap((result) =>
+          result.status === "rejected" ? [result.reason] : [],
+        );
+        if (errors.length > 0) {
+          throw new AggregateError(errors, "Failed to close the mreact development server.");
+        }
+      })();
+      return closePromise;
     },
   };
 }
 
+function validateDevUpgradeOrigin(
+  request: import("node:http").IncomingMessage,
+  policy: HttpUpgradeOriginPolicy | undefined,
+  hostname: string,
+  port: number,
+  vite: ViteDevServer | undefined,
+): HttpUpgradeOriginValidation {
+  if (!isDevUpgradeHostAllowed(request.headers.host, vite?.config.server.allowedHosts)) {
+    return { ok: false, reason: "disallowed-origin" };
+  }
+  if (policy === "unchecked") {
+    return { ok: true, origin: request.headers.origin };
+  }
+  if (typeof policy === "object") {
+    return validateHttpUpgradeOrigin(request, policy);
+  }
+  try {
+    return validateHttpUpgradeOrigin(request, {
+      allowedOrigins: [`http://${request.headers.host ?? formatNodeAuthority(hostname, port)}`],
+    });
+  } catch {
+    return { ok: false, reason: "malformed-origin" };
+  }
+}
+
+function isDevUpgradeHostAllowed(
+  hostHeader: string | undefined,
+  allowedHosts: true | string[] | undefined,
+): boolean {
+  if (allowedHosts === true || hostHeader === undefined) {
+    return true;
+  }
+
+  const host = hostHeader.trim();
+  if (host.startsWith("[")) {
+    const closingBracket = host.indexOf("]");
+    return closingBracket > 0 && isIP(host.slice(1, closingBracket)) === 6;
+  }
+  const colon = host.indexOf(":");
+  const hostname = colon === -1 ? host : host.slice(0, colon);
+  if (isIP(hostname) === 4 || hostname === "localhost" || hostname.endsWith(".localhost")) {
+    return true;
+  }
+
+  return (allowedHosts ?? []).some(
+    (allowedHost) =>
+      allowedHost === hostname ||
+      (allowedHost.startsWith(".") &&
+        (allowedHost.slice(1) === hostname || hostname.endsWith(allowedHost))),
+  );
+}
+
+function formatNodeAuthority(hostname: string, port: number): string {
+  const host = hostname.includes(":") && !hostname.startsWith("[") ? `[${hostname}]` : hostname;
+  return `${host}:${port}`;
+}
+
+function isViteHmrUpgradeRequest(
+  request: import("node:http").IncomingMessage,
+  vite: ViteDevServer | undefined,
+): boolean {
+  if (vite === undefined) {
+    return false;
+  }
+  const protocol = request.headers["sec-websocket-protocol"];
+  if (protocol !== "vite-hmr" && protocol !== "vite-ping") {
+    return false;
+  }
+  const hmr = vite.config.server.hmr;
+  if (hmr === false) {
+    return false;
+  }
+  const hmrPath = typeof hmr === "object" ? hmr.path : undefined;
+  const expectedPath =
+    hmrPath === undefined ? vite.config.base : posix.join(vite.config.base, hmrPath);
+
+  try {
+    return new URL(request.url ?? "/", "http://mreact.local").pathname === expectedPath;
+  } catch {
+    return false;
+  }
+}
+
+function finiteNonNegativeTimeout(
+  value: number | undefined,
+  fallback: number,
+  name: string,
+): number {
+  const timeout = value ?? fallback;
+  if (
+    !Number.isFinite(timeout) ||
+    timeout < 0 ||
+    !Number.isSafeInteger(timeout) ||
+    timeout > 2_147_483_647
+  ) {
+    throw new TypeError(
+      `${name} must be a finite non-negative safe integer no greater than 2147483647.`,
+    );
+  }
+  return timeout;
+}
+
 function listenDevHttpServer(server: Server, port: number, hostname: string): Promise<void> {
   return new Promise((resolve, reject) => {
     const onError = (error: Error) => {
@@ -202,6 +367,7 @@ function isNodeErrorCode(error: unknown, code: string): boolean {
 }
 
 async function resolveStartDevServerProject(options: StartDevServerOptions): Promise<{
+  dehydrateOptions?: LoadedMreactRouterViteConfig["dehydrateOptions"];
   project: ReturnType<typeof resolveAppRouterProjectOptions>;
   serverPort?: number | undefined;
   importPolicy?: LoadedMreactRouterViteConfig["importPolicy"];
@@ -216,6 +382,9 @@ async function resolveStartDevServerProject(options: StartDevServerOptions): Pro
   );
 
   return {
+    ...(config?.dehydrateOptions === undefined
+      ? {}
+      : { dehydrateOptions: config.dehydrateOptions }),
     ...(config?.importPolicy === undefined ? {} : { importPolicy: config.importPolicy }),
     project: resolveAppRouterProjectOptions({
       ...config?.project,
@@ -280,7 +449,11 @@ function sendDevServerError(
 ): void {
   outgoing.statusCode = 500;
   outgoing.setHeader("content-type", "text/plain; charset=utf-8");
-  outgoing.end(options.verboseErrors === true
-    ? error instanceof Error ? error.stack : String(error)
-    : "Internal Server Error");
+  outgoing.end(
+    options.verboseErrors === true
+      ? error instanceof Error
+        ? error.stack
+        : String(error)
+      : "Internal Server Error",
+  );
 }

package/src/http.ts

@@ -7,8 +7,10 @@ const rawUrlByRequest = new WeakMap<Request, string>();
 export function nodeRequestToWebRequest(
   incoming: IncomingMessage,
   origin: string,
+  outgoing?: ServerResponse,
 ): Request {
   const method = incoming.method ?? "GET";
+  const rawUrl = incoming.url ?? "/";
   const headers = new Headers();
 
   for (const [name, value] of Object.entries(incoming.headers)) {
@@ -29,16 +31,81 @@ export function nodeRequestToWebRequest(
     method,
   };
 
+  if (outgoing !== undefined) {
+    init.signal = nodeRequestSignal(incoming, outgoing);
+  }
+
   if (method !== "GET" && method !== "HEAD") {
     init.body = Readable.toWeb(incoming) as ReadableStream<Uint8Array>;
     init.duplex = "half";
   }
 
-  const request = new Request(new URL(incoming.url ?? "/", origin), init);
-  rawUrlByRequest.set(request, incoming.url ?? "/");
+  const request = new Request(nodeRequestUrl(rawUrl, origin), init);
+  rawUrlByRequest.set(request, rawUrl);
   return request;
 }
 
+function nodeRequestSignal(incoming: IncomingMessage, outgoing: ServerResponse): AbortSignal {
+  const controller = new AbortController();
+  let disposed = false;
+
+  const dispose = (): void => {
+    if (disposed) {
+      return;
+    }
+    disposed = true;
+    incoming.off("aborted", onIncomingAborted);
+    outgoing.off("close", onOutgoingClose);
+    outgoing.off("error", onOutgoingError);
+    outgoing.off("finish", onOutgoingFinish);
+  };
+  const abort = (reason: Error): void => {
+    controller.abort(reason);
+    dispose();
+  };
+  const onIncomingAborted = (): void => {
+    abort(new Error("The incoming HTTP request was aborted."));
+  };
+  const onOutgoingClose = (): void => {
+    if (!outgoing.writableFinished) {
+      abort(new Error("The outgoing HTTP response closed before completion."));
+      return;
+    }
+    dispose();
+  };
+  const onOutgoingError = (error: Error): void => {
+    abort(error);
+  };
+  const onOutgoingFinish = (): void => {
+    dispose();
+  };
+
+  incoming.once("aborted", onIncomingAborted);
+  outgoing.once("close", onOutgoingClose);
+  outgoing.once("error", onOutgoingError);
+  outgoing.once("finish", onOutgoingFinish);
+
+  if (incoming.aborted) {
+    onIncomingAborted();
+  } else if (outgoing.destroyed && !outgoing.writableFinished) {
+    onOutgoingClose();
+  }
+
+  return controller.signal;
+}
+
+function nodeRequestUrl(rawUrl: string, origin: string): URL {
+  const validatedOrigin = new URL(origin).origin;
+  const rootedPath = rawUrl.startsWith("/") ? rawUrl : `/${rawUrl}`;
+  const requestUrl = new URL(`${validatedOrigin}${rootedPath}`);
+
+  if (requestUrl.origin !== validatedOrigin) {
+    throw new TypeError("Node request target changed the validated request origin.");
+  }
+
+  return requestUrl;
+}
+
 export function rawNodeRequestUrl(request: Request): string | undefined {
   return rawUrlByRequest.get(request);
 }
@@ -121,12 +188,13 @@ export async function sendResponse(
     return;
   }
 
-  outgoing.flushHeaders();
   const reader = response.body.getReader();
+  const lifecycle = observeOutgoingFailure(outgoing);
+  outgoing.flushHeaders();
 
   try {
     while (true) {
-      const result = await reader.read();
+      const result = await readWithAbort(reader, lifecycle.signal);
 
       if (result.done) {
         outgoing.end();
@@ -134,16 +202,114 @@ export async function sendResponse(
       }
 
       if (!outgoing.write(result.value)) {
-        await new Promise<void>((resolve) => outgoing.once("drain", resolve));
+        await waitForDrain(outgoing, lifecycle.signal);
       }
     }
   } catch (error) {
-    outgoing.destroy(error instanceof Error ? error : new Error(String(error)));
+    const reason = error instanceof Error ? error : new Error(String(error));
+    try {
+      await reader.cancel(reason);
+    } catch {
+      // The stream may already be errored or cancelled.
+    }
+    if (!outgoing.destroyed) {
+      outgoing.destroy(reason);
+    }
   } finally {
+    lifecycle.dispose();
     reader.releaseLock();
   }
 }
 
+function observeOutgoingFailure(outgoing: ServerResponse): {
+  dispose(): void;
+  signal: AbortSignal;
+} {
+  const controller = new AbortController();
+  let disposed = false;
+
+  const dispose = (): void => {
+    if (disposed) {
+      return;
+    }
+    disposed = true;
+    outgoing.off("close", onClose);
+    outgoing.off("error", onError);
+  };
+  const abort = (reason: Error): void => {
+    controller.abort(reason);
+    dispose();
+  };
+  const onClose = (): void => {
+    abort(new Error("The outgoing HTTP response closed during streaming."));
+  };
+  const onError = (error: Error): void => {
+    abort(error);
+  };
+
+  outgoing.once("close", onClose);
+  outgoing.once("error", onError);
+  if (outgoing.destroyed) {
+    onClose();
+  }
+
+  return { dispose, signal: controller.signal };
+}
+
+function readWithAbort(
+  reader: ReadableStreamDefaultReader<Uint8Array>,
+  signal: AbortSignal,
+): Promise<ReadableStreamReadResult<Uint8Array>> {
+  if (signal.aborted) {
+    return Promise.reject(abortReason(signal));
+  }
+
+  return new Promise((resolve, reject) => {
+    const onAbort = (): void => {
+      signal.removeEventListener("abort", onAbort);
+      reject(abortReason(signal));
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    void reader.read().then(
+      (result) => {
+        signal.removeEventListener("abort", onAbort);
+        resolve(result);
+      },
+      (error: unknown) => {
+        signal.removeEventListener("abort", onAbort);
+        reject(error);
+      },
+    );
+  });
+}
+
+function waitForDrain(outgoing: ServerResponse, signal: AbortSignal): Promise<void> {
+  if (signal.aborted) {
+    return Promise.reject(abortReason(signal));
+  }
+
+  return new Promise((resolve, reject) => {
+    const dispose = (): void => {
+      outgoing.off("drain", onDrain);
+      signal.removeEventListener("abort", onAbort);
+    };
+    const onDrain = (): void => {
+      dispose();
+      resolve();
+    };
+    const onAbort = (): void => {
+      dispose();
+      reject(abortReason(signal));
+    };
+    outgoing.once("drain", onDrain);
+    signal.addEventListener("abort", onAbort, { once: true });
+  });
+}
+
+function abortReason(signal: AbortSignal): Error {
+  return signal.reason instanceof Error ? signal.reason : new Error("HTTP streaming was aborted.");
+}
+
 function responseSetCookieHeaders(headers: Headers): string[] {
   const getSetCookie = (headers as Headers & { getSetCookie?: () => string[] }).getSetCookie;
 

package/src/index.ts

@@ -33,7 +33,17 @@ export type {
 } from "./multipart.js";
 export { getNavigationState, subscribeNavigationState } from "./navigation-state.js";
 export { getRouterRuntimeCacheStats } from "./runtime-cache.js";
-export type { HttpUpgradeHandler } from "./upgrade.js";
+export { validateHttpUpgradeOrigin } from "./upgrade.js";
+export type {
+  HttpUpgradeContext,
+  HttpUpgradeDisposition,
+  HttpUpgradeHandler,
+  HttpUpgradeOriginFailureReason,
+  HttpUpgradeOriginPolicy,
+  HttpUpgradeOriginValidation,
+  ManagedHttpUpgradeHandler,
+  ValidateHttpUpgradeOriginOptions,
+} from "./upgrade.js";
 export {
   cookies,
   headers,
@@ -250,6 +260,8 @@ export type {
   AppRouterRenderTimingLogEvent,
   AppRouterRequestStartLogEvent,
   AppRouterRequestTimingLogEvent,
+  AppRouterUpgradeErrorLogEvent,
+  AppRouterUpgradeRejectedLogEvent,
 } from "./logger.js";
 export type { DetectedLocale, LocaleRoutingOptions, MessageTree } from "./i18n.js";
 export {
@@ -288,6 +300,7 @@ export type {
   AppRouterRenderPreload,
   AppRouterResponseHook,
   AppRouterResponseHookContext,
+  AppRouterServerRenderArtifactLoader,
   RenderAppRequestOptions,
 } from "./render.js";
 export { parseTraceContext, traceContextFromRequest } from "./trace.js";

package/src/logger.ts

@@ -27,7 +27,9 @@ export type AppRouterLogEvent =
   | AppRouterRequestErrorLogEvent
   | AppRouterRequestTimingLogEvent
   | AppRouterRenderTimingLogEvent
-  | AppRouterCspInlineNonceWarningLogEvent;
+  | AppRouterCspInlineNonceWarningLogEvent
+  | AppRouterUpgradeErrorLogEvent
+  | AppRouterUpgradeRejectedLogEvent;
 
 /**
  * Logs the start of an app-router request.
@@ -63,6 +65,29 @@ export interface AppRouterRequestErrorLogEvent {
   type: "router:request:error";
 }
 
+/**
+ * Logs a failed or timed-out HTTP upgrade handler.
+ */
+export interface AppRouterUpgradeErrorLogEvent {
+  durationMs: number;
+  error: AppRouterLogError;
+  method: string;
+  path: string;
+  runtime: "node";
+  type: "router:upgrade:error";
+}
+
+/**
+ * Logs an HTTP upgrade rejected before application ownership.
+ */
+export interface AppRouterUpgradeRejectedLogEvent {
+  method: string;
+  path: string;
+  reason: "disallowed-origin" | "malformed-origin" | "missing-origin" | "opaque-origin";
+  runtime: "node";
+  type: "router:upgrade:rejected";
+}
+
 /**
  * Logs per-phase timings for a complete app-router request.
  */
@@ -116,7 +141,12 @@ export function emitRouterLog(
   level: AppRouterLogLevel,
   event: AppRouterLogEvent,
 ): void {
-  const sink = logger?.[level];
+  let sink: AppRouterLogger[AppRouterLogLevel];
+  try {
+    sink = logger?.[level];
+  } catch {
+    return;
+  }
 
   if (sink === undefined) {
     return;
@@ -176,15 +206,22 @@ export function logDurationMs(startedAt: number): number {
 }
 
 export function logError(error: unknown): AppRouterLogError {
-  if (error instanceof Error) {
+  try {
+    if (error instanceof Error) {
+      return {
+        message: String(error.message),
+        name: String(error.name),
+      };
+    }
+
     return {
-      message: error.message,
-      name: error.name,
+      message: String(error),
+      name: "Error",
+    };
+  } catch {
+    return {
+      message: "Unknown non-coercible error",
+      name: "Error",
     };
   }
-
-  return {
-    message: String(error),
-    name: "Error",
-  };
 }