@rangojs/router 0.0.0-experimental.66 → 0.0.0-experimental.66f5aa51

package/src/rsc/response-error.ts

@@ -1,37 +1,104 @@
 /**
- * Response Error Payload Builder
+ * Problem Details (RFC 9457) Builder
  *
- * Builds a ResponseError object from a caught error, controlling
- * what information is exposed based on error type and environment.
+ * Builds a problem+json error body from a caught error, controlling what
+ * information is exposed based on error type and environment.
  */
 
 import { RouterError } from "../errors.js";
-import type { ResponseError } from "../urls.js";
+import type { ProblemDetails } from "../urls.js";
 
 /**
- * Build a ResponseError payload from a caught error.
- * RouterError messages are always exposed (developer-crafted).
+ * HTTP reason phrases for the problem `title` member. Inlined because the
+ * router targets edge/worker runtimes without node's `http.STATUS_CODES`;
+ * covers the full standard 4xx/5xx range, with a generic fallback for any
+ * non-standard status a handler might set.
+ */
+const STATUS_PHRASES: Record<number, string> = {
+  400: "Bad Request",
+  401: "Unauthorized",
+  402: "Payment Required",
+  403: "Forbidden",
+  404: "Not Found",
+  405: "Method Not Allowed",
+  406: "Not Acceptable",
+  407: "Proxy Authentication Required",
+  408: "Request Timeout",
+  409: "Conflict",
+  410: "Gone",
+  411: "Length Required",
+  412: "Precondition Failed",
+  413: "Payload Too Large",
+  414: "URI Too Long",
+  415: "Unsupported Media Type",
+  416: "Range Not Satisfiable",
+  417: "Expectation Failed",
+  418: "I'm a Teapot",
+  421: "Misdirected Request",
+  422: "Unprocessable Entity",
+  423: "Locked",
+  424: "Failed Dependency",
+  425: "Too Early",
+  426: "Upgrade Required",
+  428: "Precondition Required",
+  429: "Too Many Requests",
+  431: "Request Header Fields Too Large",
+  451: "Unavailable For Legal Reasons",
+  500: "Internal Server Error",
+  501: "Not Implemented",
+  502: "Bad Gateway",
+  503: "Service Unavailable",
+  504: "Gateway Timeout",
+  505: "HTTP Version Not Supported",
+  506: "Variant Also Negotiates",
+  507: "Insufficient Storage",
+  508: "Loop Detected",
+  510: "Not Extended",
+  511: "Network Authentication Required",
+};
+
+function statusPhrase(status: number): string {
+  return STATUS_PHRASES[status] ?? "Error";
+}
+
+/**
+ * Build an RFC 9457 problem+json body from a caught error.
+ * RouterError messages/codes are always exposed (developer-crafted).
  * Standard Error messages are hidden in production.
+ *
+ * The `type` member is omitted in this phase: per RFC 9457 an absent `type` is
+ * treated as `"about:blank"` (no semantics beyond the HTTP status), so emitting
+ * it adds nothing. Per-route problem-type URIs arrive with the declared-errors
+ * map later. `code` is always present so consumers can branch on it
+ * (`"INTERNAL"` for non-RouterError failures).
  */
-export function createResponseErrorPayload(
+export function createProblemDetails(
   error: unknown,
+  status: number,
   isDev: boolean,
-): ResponseError {
+): ProblemDetails {
   if (error instanceof RouterError) {
     return {
-      message: error.message,
+      title: statusPhrase(status),
+      status,
+      detail: error.message,
       code: error.code,
-      ...(error.type ? { type: error.type } : {}),
       ...(isDev && error.stack ? { stack: error.stack } : {}),
     };
   }
   if (error instanceof Error) {
     return {
-      message: isDev ? error.message : "Internal Server Error",
+      title: statusPhrase(status),
+      status,
+      detail: isDev ? error.message : "Internal Server Error",
+      code: "INTERNAL",
       ...(isDev && error.stack ? { stack: error.stack } : {}),
     };
   }
   return {
-    message: isDev ? String(error) : "Internal Server Error",
+    title: statusPhrase(status),
+    status,
+    detail: isDev ? String(error) : "Internal Server Error",
+    code: "INTERNAL",
   };
 }

package/src/rsc/response-route-handler.ts

@@ -7,11 +7,12 @@
  */
 
 import { RouterError } from "../errors.js";
-import { requireRequestContext } from "../server/request-context.js";
+import { getRequestContext } from "../server/request-context.js";
 import { contextGet } from "../context-var.js";
 import { NOCACHE_SYMBOL } from "../cache/taint.js";
-import { traverseBack } from "../router/pattern-matching.js";
-import { createCacheScope } from "../cache/cache-scope.js";
+import { RESPONSE_TYPE_MIME } from "../router/content-negotiation.js";
+import { createCacheScope, resolveCacheTags } from "../cache/cache-scope.js";
+import { serveResponseRouteWithCache } from "./response-cache-serve.js";
 import { executeMiddleware } from "../router/middleware.js";
 import {
   createReverseFunction,
@@ -20,13 +21,21 @@ import {
 import type { MiddlewareFn } from "../router/middleware.js";
 import type { EntryData } from "../server/context.js";
 import type { HandlerContext } from "./handler-context.js";
-import { createResponseErrorPayload } from "./response-error.js";
+import { createProblemDetails } from "./response-error.js";
 import {
   createResponseWithMergedHeaders,
   finalizeResponse,
   isCacheableStatus,
   buildRouteMiddlewareEntries,
+  mergeStubHeadersAndFinalize,
 } from "./helpers.js";
+import { isWebSocketUpgradeResponse } from "../response-utils.js";
+import { stringifyJsonRouteResult } from "./json-route-result.js";
+import {
+  EXTERNAL_REDIRECT_MARKER,
+  isExternalRedirect,
+  markExternalRedirect,
+} from "../redirect-origin.js";
 
 export interface ResponseRouteMatch {
   responseType: string;
@@ -70,7 +79,7 @@ export async function handleResponseRoute<TEnv>(
   }
 
   // Build lightweight context for response handler
-  const reqCtx = requireRequestContext();
+  const reqCtx = getRequestContext();
   const cleanUrl = stripInternalParams(url);
   const responseHandlerCtx = {
     request,
@@ -78,10 +87,13 @@ export async function handleResponseRoute<TEnv>(
     env,
     searchParams: cleanUrl.searchParams,
     url: cleanUrl,
+    originalUrl: reqCtx.originalUrl,
     pathname: url.pathname,
     reverse: createReverseFunction(handlerCtx.getRequiredRouteMap()),
     get: ((keyOrVar: any) => contextGet(variables, keyOrVar)) as any,
     header: (name: string, value: string) => reqCtx.header(name, value),
+    waitUntil: reqCtx.waitUntil.bind(reqCtx),
+    executionContext: reqCtx.executionContext,
     _responseType: preview.responseType,
   };
   // Brand with taint symbol so "use cache" detects it as request-scoped
@@ -96,51 +108,39 @@ export async function handleResponseRoute<TEnv>(
     // so that stub headers (cookies, custom headers set via ctx.header()) are included.
     // Use Headers (not Record<string, string>) to preserve duplicate entries like Set-Cookie.
     const rewrapResponse = (result: Response) => {
+      // 204/205/304 are NOT short-circuited — they're valid for the Response
+      // constructor and must honor ctx.setStatus() overrides. Only upgrade
+      // responses (status 101 / `webSocket` property) bypass reconstruction.
+      if (isWebSocketUpgradeResponse(result)) {
+        return mergeStubHeadersAndFinalize(result);
+      }
       const headers = new Headers();
       result.headers.forEach((value, key) => {
+        // Never copy the reserved external-redirect marker off a handler result.
+        // It is not a trust signal -- the opt-in is the out-of-band brand below
+        // -- and a proxy-style route returning an attacker-controlled upstream
+        // response must not let a forged value ride through to the browser.
+        if (key.toLowerCase() === EXTERNAL_REDIRECT_MARKER) return;
         if (key.toLowerCase() === "set-cookie") {
           headers.append(key, value);
         } else {
           headers.set(key, value);
         }
       });
-      return createResponseWithMergedHeaders(result.body, {
+      const rewrapped = createResponseWithMergedHeaders(result.body, {
         status: result.status,
         headers,
       });
-    };
-
-    // JSON response routes: wrap in { data } / { error } envelope
-    if (preview.responseType === "json") {
-      try {
-        const result = await (preview.handler as Function)(responseHandlerCtx);
-        if (result instanceof Response) {
-          return rewrapResponse(result);
-        }
-        return createResponseWithMergedHeaders(
-          JSON.stringify({ data: result }),
-          {
-            status: 200,
-            headers: { "content-type": "application/json;charset=utf-8" },
-          },
-        );
-      } catch (error) {
-        handlerCtx.callOnError(error, "handler", errorCtx);
-        const isDev = process.env.NODE_ENV !== "production";
-        const status = error instanceof RouterError ? error.status : 500;
-        return createResponseWithMergedHeaders(
-          JSON.stringify({
-            error: createResponseErrorPayload(error, isDev),
-          }),
-          {
-            status,
-            headers: { "content-type": "application/json;charset=utf-8" },
-          },
-        );
+      // Transfer the out-of-band external brand only when the handler result is
+      // genuinely branded (a real redirect(url, { external: true })). A proxied
+      // upstream Response is never branded, so an attacker cannot opt a response
+      // route's redirect out of the same-origin guard by injecting the header.
+      if (isExternalRedirect(result)) {
+        markExternalRedirect(rewrapped);
       }
-    }
+      return rewrapped;
+    };
 
-    // Non-JSON response routes: catch errors and return plain Response
     try {
       const result = await (preview.handler as Function)(responseHandlerCtx);
 
@@ -148,38 +148,56 @@ export async function handleResponseRoute<TEnv>(
         return rewrapResponse(result);
       }
 
-      // Auto-wrap based on response type tag
-      switch (preview.responseType) {
-        case "text":
-          return createResponseWithMergedHeaders(String(result), {
-            status: 200,
-            headers: { "content-type": "text/plain;charset=utf-8" },
-          });
-        case "html":
-          return createResponseWithMergedHeaders(String(result), {
-            status: 200,
-            headers: { "content-type": "text/html;charset=utf-8" },
-          });
-        case "xml":
-          return createResponseWithMergedHeaders(String(result), {
-            status: 200,
-            headers: { "content-type": "application/xml;charset=utf-8" },
-          });
-        case "md":
-          return createResponseWithMergedHeaders(String(result), {
-            status: 200,
-            headers: { "content-type": "text/markdown;charset=utf-8" },
-          });
-        default:
-          // image, stream, any -- must return Response
-          throw new Error(
-            `Response route handler for "${preview.responseType}" must return a Response object, got ${typeof result}`,
-          );
+      // Handled before the MIME lookup (json is also a RESPONSE_TYPE_MIME key).
+      if (preview.responseType === "json") {
+        // Runtime guard: the json() return type rejects nested Promises at
+        // compile time, but an `as`-cast or untyped (JS) handler can still slip
+        // one through. stringifyJsonRouteResult throws a clear error instead of
+        // shipping empty data (shared with dispatch() so the two cannot drift).
+        const body = stringifyJsonRouteResult(result);
+        return createResponseWithMergedHeaders(body, {
+          status: 200,
+          headers: { "content-type": "application/json;charset=utf-8" },
+        });
       }
+
+      // Object.hasOwn (not truthiness) so prototype names like "toString" are not
+      // matched; image/stream/any are absent and fall through to the throw.
+      if (Object.hasOwn(RESPONSE_TYPE_MIME, preview.responseType)) {
+        return createResponseWithMergedHeaders(String(result), {
+          status: 200,
+          headers: {
+            "content-type": `${RESPONSE_TYPE_MIME[preview.responseType]};charset=utf-8`,
+          },
+        });
+      }
+
+      throw new Error(
+        `Response route handler for "${preview.responseType}" must return a Response object, got ${typeof result}`,
+      );
     } catch (error) {
       handlerCtx.callOnError(error, "handler", errorCtx);
       const isDev = process.env.NODE_ENV !== "production";
-      const status = error instanceof RouterError ? error.status : 500;
+      const derivedStatus = error instanceof RouterError ? error.status : 500;
+      // Resolve the effective status the same way createResponseWithMergedHeaders
+      // will (ctx.res.status override) so the problem body's status/title match
+      // the actual HTTP status — e.g. when a handler called ctx.setStatus()
+      // before throwing.
+      const status =
+        reqCtx.res.status !== 200 ? reqCtx.res.status : derivedStatus;
+
+      if (preview.responseType === "json") {
+        return createResponseWithMergedHeaders(
+          JSON.stringify(createProblemDetails(error, status, isDev)),
+          {
+            status,
+            headers: {
+              "content-type": "application/problem+json;charset=utf-8",
+            },
+          },
+        );
+      }
+
       const message =
         error instanceof RouterError
           ? error.message
@@ -196,7 +214,9 @@ export async function handleResponseRoute<TEnv>(
   // Wrap callHandler to append Vary: Accept on content-negotiated responses
   const callHandlerWithVary = async () => {
     const response = await callHandler();
-    if (preview.negotiated) {
+    if (preview.negotiated && !isWebSocketUpgradeResponse(response)) {
+      // Skip Vary on upgrade responses: headers are semantically immutable
+      // on some runtimes, and Vary is meaningless for a 101 response.
       response.headers.append("Vary", "Accept");
     }
     return response;
@@ -217,130 +237,20 @@ export async function handleResponseRoute<TEnv>(
     return callHandlerWithVary();
   };
 
-  // Resolve cache config from entry tree (same pattern as match-api.ts)
+  // Response-route cache: resolved through the shared serve leaf
+  // (rsc/response-cache-serve.ts) so production and the dispatch testing
+  // primitive share ONE owner of the cache contract. Returns undefined when no
+  // cache applies, so we fall through to a plain handler run.
   if (preview.manifestEntry) {
-    let cacheScope: ReturnType<typeof createCacheScope> = null;
-    for (const entry of traverseBack(preview.manifestEntry)) {
-      if (entry.cache) {
-        cacheScope = createCacheScope(entry.cache, cacheScope);
-      }
-    }
-
-    if (cacheScope?.enabled) {
-      // Evaluate condition — skip response cache when condition returns false
-      let conditionPassed = true;
-      if (cacheScope.config !== false && cacheScope.config.condition) {
-        try {
-          conditionPassed = !!cacheScope.config.condition(reqCtx);
-        } catch {
-          conditionPassed = false;
-        }
-      }
-
-      const store = cacheScope.getStore() ?? reqCtx._cacheStore;
-      if (conditionPassed && store?.getResponse && store?.putResponse) {
-        // Build cache key with response:{type}: prefix to avoid collision
-        // with segment keys and differentiate between response types.
-        // Include host and url.search so query-driven and multi-host
-        // responses cache separately.
-        let cacheKey = `response:${preview.responseType}:${url.host}${url.pathname}${url.search}`;
-
-        // Priority 1: Route-level key function (full override)
-        if (cacheScope.config !== false && cacheScope.config.key) {
-          try {
-            const customKey = await cacheScope.config.key(reqCtx);
-            cacheKey = `response:${customKey}`;
-          } catch {
-            // Fall back to default key on route-level key failure
-          }
-        } else if (store.keyGenerator) {
-          // Priority 2: Store-level keyGenerator (modifies default key)
-          try {
-            cacheKey = await store.keyGenerator(reqCtx, cacheKey);
-          } catch {
-            // Fall back to default key on keyGenerator failure
-          }
-        }
-
-        // Save pre-handler callbacks (registered by app-level middleware
-        // before we reach the cache block) and clear the live array.
-        // createResponseWithMergedHeaders (inside the handler) eagerly
-        // executes any callbacks present in _onResponseCallbacks, so
-        // handler-registered callbacks are baked into the handler's
-        // response and the cached artifact. Pre-handler callbacks are
-        // NOT in the live array during execution, so they are applied
-        // once per serve on every path (hit + miss) below.
-        const savedCallbacks = reqCtx._onResponseCallbacks;
-        reqCtx._onResponseCallbacks = [];
-
-        const applyPreHandlerCallbacks = (response: Response): Response => {
-          let result = response;
-          for (const callback of savedCallbacks) {
-            result = callback(result) ?? result;
-          }
-          return result;
-        };
-
-        try {
-          const cached = await store.getResponse(cacheKey);
-
-          if (cached && isCacheableStatus(cached.response.status)) {
-            if (!cached.shouldRevalidate) {
-              // Fresh hit
-              return applyPreHandlerCallbacks(cached.response);
-            }
-
-            // Stale hit (SWR) - return cached, revalidate in background
-            reqCtx.waitUntil(async () => {
-              try {
-                // finalizeResponse drains any onResponse callbacks registered
-                // during middleware execution (e.g. middleware short-circuit)
-                // that createResponseWithMergedHeaders didn't reach.
-                const fresh = finalizeResponse(await executeHandler());
-                if (isCacheableStatus(fresh.status)) {
-                  await store.putResponse!(
-                    cacheKey,
-                    fresh.clone(),
-                    cacheScope!.ttl,
-                    cacheScope!.swr,
-                  );
-                }
-              } catch (error) {
-                console.error(`[ResponseCache] Revalidation failed:`, error);
-              }
-            });
-
-            return applyPreHandlerCallbacks(cached.response);
-          }
-        } catch (error) {
-          console.error(`[ResponseCache] Cache lookup failed:`, error);
-        }
-
-        // Cache miss - execute handler and cache the result.
-        // createResponseWithMergedHeaders inside the handler drains callbacks
-        // registered during handler execution. finalizeResponse catches any
-        // remaining callbacks (e.g. from middleware short-circuit where the
-        // handler never ran) so the cached artifact includes all transforms.
-        const response = finalizeResponse(await executeHandler());
-
-        if (isCacheableStatus(response.status)) {
-          reqCtx.waitUntil(async () => {
-            try {
-              await store.putResponse!(
-                cacheKey,
-                response.clone(),
-                cacheScope!.ttl,
-                cacheScope!.swr,
-              );
-            } catch (error) {
-              console.error(`[ResponseCache] Cache write failed:`, error);
-            }
-          });
-        }
-
-        return applyPreHandlerCallbacks(response);
-      }
-    }
+    const cached = await serveResponseRouteWithCache({
+      reqCtx,
+      manifestEntry: preview.manifestEntry,
+      responseType: preview.responseType,
+      url,
+      executeHandler,
+      deps: { createCacheScope, resolveCacheTags },
+    });
+    if (cached !== undefined) return cached;
   }
 
   return executeHandler().then(finalizeResponse);