unjs · pi0 · Jan 11, 2023 · Jan 11, 2023
diff --git a/src/dev/error.ts b/src/dev/error.ts
@@ -1,22 +1,22 @@
 import { NitroErrorHandler } from "../types";
 
 function errorHandler(error, event) {
-  event.res.setHeader("Content-Type", "text/html; charset=UTF-8");
-  event.res.statusCode = 503;
-  event.res.statusMessage = "Server Unavailable";
+  event.node.res.setHeader("Content-Type", "text/html; charset=UTF-8");
+  event.node.res.statusCode = 503;
+  event.node.res.statusMessage = "Server Unavailable";
 
   let body;
   let title;
   if (error) {
-    title = `${event.res.statusCode} ${event.res.statusMessage}`;
+    title = `${event.node.res.statusCode} ${event.node.res.statusMessage}`;
     body = `<code><pre>${error.stack}</pre></code>`;
   } else {
     title = "Reloading server...";
     body =
       "<progress></progress><script>document.querySelector('progress').indeterminate=true</script>";
   }
 
-  event.res.end(`<!DOCTYPE html>
+  event.node.res.end(`<!DOCTYPE html>
   <html lang="en">
   <head>
     <meta charset="utf-8">

diff --git a/src/dev/server.ts b/src/dev/server.ts
@@ -223,8 +223,8 @@ function createProxy(defaults: HTTPProxyOptions = {}) {
   const handle = (event: H3Event, opts: HTTPProxyOptions = {}) => {
     return new Promise<void>((resolve, reject) => {
       proxy.web(
-        event.req,
-        event.res,
+        event.node.req,
+        event.node.res,
         { ...defaults, ...opts },
         (error: any) => {
           if (error.code !== "ECONNRESET") {

diff --git a/src/runtime/cache.ts b/src/runtime/cache.ts
@@ -149,7 +149,7 @@ export function defineCachedEventHandler<T = any>(
       if (key) {
         return escapeKey(key);
       }
-      const url = event.req.originalUrl || event.req.url;
+      const url = event.node.req.originalUrl || event.node.req.url;
       const friendlyName = escapeKey(decodeURI(parseURL(url).pathname)).slice(
         0,
         16
@@ -173,10 +173,10 @@ export function defineCachedEventHandler<T = any>(
   const _cachedHandler = cachedFunction<ResponseCacheEntry<T>>(
     async (incomingEvent: H3Event) => {
       // Create proxies to avoid sharing state with user request
-      const reqProxy = cloneWithProxy(incomingEvent.req, { headers: {} });
+      const reqProxy = cloneWithProxy(incomingEvent.node.req, { headers: {} });
       const resHeaders: Record<string, number | string | string[]> = {};
       let _resSendBody;
-      const resProxy = cloneWithProxy(incomingEvent.res, {
+      const resProxy = cloneWithProxy(incomingEvent.node.res, {
         statusCode: 200,
         getHeader(name) {
           return resHeaders[name];
@@ -238,7 +238,7 @@ export function defineCachedEventHandler<T = any>(
       const body = (await handler(event)) || _resSendBody;
 
       // Collect cachable headers
-      const headers = event.res.getHeaders();
+      const headers = event.node.res.getHeaders();
       headers.etag = headers.Etag || headers.etag || `W/"${hash(body)}"`;
       headers["last-modified"] =
         headers["Last-Modified"] ||
@@ -263,7 +263,7 @@ export function defineCachedEventHandler<T = any>(
 
       // Create cache entry for response
       const cacheEntry: ResponseCacheEntry<T> = {
-        code: event.res.statusCode,
+        code: event.node.res.statusCode,
         headers,
         body,
       };
@@ -287,7 +287,7 @@ export function defineCachedEventHandler<T = any>(
     const response = await _cachedHandler(event);
 
     // Don't continue if response is already handled by user
-    if (event.res.headersSent || event.res.writableEnded) {
+    if (event.node.res.headersSent || event.node.res.writableEnded) {
       return response.body;
     }
 
@@ -303,9 +303,9 @@ export function defineCachedEventHandler<T = any>(
     }
 
     // Send status and headers
-    event.res.statusCode = response.code;
+    event.node.res.statusCode = response.code;
     for (const name in response.headers) {
-      event.res.setHeader(name, response.headers[name]);
+      event.node.res.setHeader(name, response.headers[name]);
     }
 
     // Send body

diff --git a/src/runtime/error.ts b/src/runtime/error.ts
@@ -18,7 +18,7 @@ export default <NitroErrorHandler>function (error, event) {
   const showDetails = isDev && statusCode !== 404;
 
   const errorObject = {
-    url: event.req.url || "",
+    url: event.node.req.url || "",
     statusCode,
     statusMessage,
     message,
@@ -41,17 +41,17 @@ export default <NitroErrorHandler>function (error, event) {
     );
   }
 
-  event.res.statusCode = statusCode;
+  event.node.res.statusCode = statusCode;
   if (statusMessage) {
-    event.res.statusMessage = statusMessage;
+    event.node.res.statusMessage = statusMessage;
   }
 
   if (isJsonRequest(event)) {
-    event.res.setHeader("Content-Type", "application/json");
-    event.res.end(JSON.stringify(errorObject));
+    event.node.res.setHeader("Content-Type", "application/json");
+    event.node.res.end(JSON.stringify(errorObject));
   } else {
-    event.res.setHeader("Content-Type", "text/html");
-    event.res.end(renderHTMLError(errorObject));
+    event.node.res.setHeader("Content-Type", "text/html");
+    event.node.res.end(renderHTMLError(errorObject));
   }
 };
 

diff --git a/src/runtime/renderer.ts b/src/runtime/renderer.ts
@@ -15,21 +15,21 @@ export type RenderHandler = (
 export function defineRenderHandler(handler: RenderHandler) {
   return eventHandler(async (event) => {
     // TODO: Use serve-placeholder
-    if (event.req.url.endsWith("/favicon.ico")) {
-      event.res.setHeader("Content-Type", "image/x-icon");
-      event.res.end(
+    if (event.node.req.url.endsWith("/favicon.ico")) {
+      event.node.res.setHeader("Content-Type", "image/x-icon");
+      event.node.res.end(
         "data:image/gif;base64,R0lGODlhAQABAIAAAAAAAP///yH5BAEAAAAALAAAAAABAAEAAAIBRAA7"
       );
       return;
     }
 
     const response = await handler(event);
     if (!response) {
-      if (!event.res.writableEnded) {
-        event.res.statusCode =
-          event.res.statusCode === 200 ? 500 : event.res.statusCode;
-        event.res.end(
-          "No response returned from render handler: " + event.req.url
+      if (!event.node.res.writableEnded) {
+        event.node.res.statusCode =
+          event.node.res.statusCode === 200 ? 500 : event.node.res.statusCode;
+        event.node.res.end(
+          "No response returned from render handler: " + event.node.req.url
         );
       }
       return;
@@ -44,15 +44,15 @@ export function defineRenderHandler(handler: RenderHandler) {
     // TODO: Caching support
 
     // Send headers
-    if (!event.res.headersSent && response.headers) {
+    if (!event.node.res.headersSent && response.headers) {
       for (const header in response.headers) {
-        event.res.setHeader(header, response.headers[header]);
+        event.node.res.setHeader(header, response.headers[header]);
       }
       if (response.statusCode) {
-        event.res.statusCode = response.statusCode;
+        event.node.res.statusCode = response.statusCode;
       }
       if (response.statusMessage) {
-        event.res.statusMessage = response.statusMessage;
+        event.node.res.statusMessage = response.statusMessage;
       }
     }
 

diff --git a/src/runtime/route-rules.ts b/src/runtime/route-rules.ts
@@ -32,7 +32,7 @@ export function createRouteRulesHandler() {
 export function getRouteRules(event: H3Event): NitroRouteRules {
   event.context._nitro = event.context._nitro || {};
   if (!event.context._nitro.routeRules) {
-    const path = new URL(event.req.url, "http://localhost").pathname;
+    const path = new URL(event.node.req.url, "http://localhost").pathname;
     event.context._nitro.routeRules = getRouteRulesForPath(
       withoutBase(path, useRuntimeConfig().app.baseURL)
     );

diff --git a/src/runtime/static.ts b/src/runtime/static.ts
@@ -11,16 +11,20 @@ const METHODS = new Set(["HEAD", "GET"]);
 const EncodingMap = { gzip: ".gz", br: ".br" };
 
 export default eventHandler((event) => {
-  if (event.req.method && !METHODS.has(event.req.method)) {
+  if (event.node.req.method && !METHODS.has(event.node.req.method)) {
     return;
   }
 
   let id = decodeURIComponent(
-    withLeadingSlash(withoutTrailingSlash(parseURL(event.req.url).pathname))
+    withLeadingSlash(
+      withoutTrailingSlash(parseURL(event.node.req.url).pathname)
+    )
   );
   let asset;
 
-  const encodingHeader = String(event.req.headers["accept-encoding"] || "");
+  const encodingHeader = String(
+    event.node.req.headers["accept-encoding"] || ""
+  );
   const encodings = [
     ...encodingHeader
       .split(",")
@@ -30,7 +34,7 @@ export default eventHandler((event) => {
     "",
   ];
   if (encodings.length > 1) {
-    event.res.setHeader("Vary", "Accept-Encoding");
+    event.node.res.setHeader("Vary", "Accept-Encoding");
   }
 
   for (const encoding of encodings) {
@@ -54,48 +58,48 @@ export default eventHandler((event) => {
     return;
   }
 
-  const ifNotMatch = event.req.headers["if-none-match"] === asset.etag;
+  const ifNotMatch = event.node.req.headers["if-none-match"] === asset.etag;
   if (ifNotMatch) {
-    event.res.statusCode = 304;
-    event.res.end();
+    event.node.res.statusCode = 304;
+    event.node.res.end();
     return;
   }
 
-  const ifModifiedSinceH = event.req.headers["if-modified-since"];
+  const ifModifiedSinceH = event.node.req.headers["if-modified-since"];
   if (
     ifModifiedSinceH &&
     asset.mtime &&
     new Date(ifModifiedSinceH) >= new Date(asset.mtime)
   ) {
-    event.res.statusCode = 304;
-    event.res.end();
+    event.node.res.statusCode = 304;
+    event.node.res.end();
     return;
   }
 
-  if (asset.type && !event.res.getHeader("Content-Type")) {
-    event.res.setHeader("Content-Type", asset.type);
+  if (asset.type && !event.node.res.getHeader("Content-Type")) {
+    event.node.res.setHeader("Content-Type", asset.type);
   }
 
-  if (asset.etag && !event.res.getHeader("ETag")) {
-    event.res.setHeader("ETag", asset.etag);
+  if (asset.etag && !event.node.res.getHeader("ETag")) {
+    event.node.res.setHeader("ETag", asset.etag);
   }
 
-  if (asset.mtime && !event.res.getHeader("Last-Modified")) {
-    event.res.setHeader("Last-Modified", asset.mtime);
+  if (asset.mtime && !event.node.res.getHeader("Last-Modified")) {
+    event.node.res.setHeader("Last-Modified", asset.mtime);
   }
 
-  if (asset.encoding && !event.res.getHeader("Content-Encoding")) {
-    event.res.setHeader("Content-Encoding", asset.encoding);
+  if (asset.encoding && !event.node.res.getHeader("Content-Encoding")) {
+    event.node.res.setHeader("Content-Encoding", asset.encoding);
   }
 
-  if (asset.size > 0 && !event.res.getHeader("Content-Length")) {
-    event.res.setHeader("Content-Length", asset.size);
+  if (asset.size > 0 && !event.node.res.getHeader("Content-Length")) {
+    event.node.res.setHeader("Content-Length", asset.size);
   }
 
   // TODO: Asset dir cache control
   // if (isBuildAsset) {
   // const TWO_DAYS = 2 * 60 * 60 * 24
-  // event.res.setHeader('Cache-Control', `max-age=${TWO_DAYS}, immutable`)
+  // event.node.res.setHeader('Cache-Control', `max-age=${TWO_DAYS}, immutable`)
   // }
 
   return readAsset(id);

diff --git a/src/runtime/timing.ts b/src/runtime/timing.ts
@@ -10,8 +10,8 @@ export const globalTiming = globalThis.__timing__ || {
 export const timingMiddleware = eventHandler((event) => {
   const start = globalTiming.start();
 
-  const _end = event.res.end;
-  event.res.end = function (
+  const _end = event.node.res.end;
+  event.node.res.end = function (
     chunk: any,
     encoding: BufferEncoding,
     cb?: () => void
@@ -23,10 +23,10 @@ export const timingMiddleware = eventHandler((event) => {
     const serverTiming = metrics
       .map((m) => `-;dur=${m[1]};desc="${encodeURIComponent(m[0])}"`)
       .join(", ");
-    if (!event.res.headersSent) {
-      event.res.setHeader("Server-Timing", serverTiming);
+    if (!event.node.res.headersSent) {
+      event.node.res.setHeader("Server-Timing", serverTiming);
     }
-    _end.call(event.res, chunk, encoding, cb);
+    _end.call(event.node.res, chunk, encoding, cb);
     return this;
-  }.bind(event.res);
+  }.bind(event.node.res);
 });
diff --git a/src/runtime/utils.ts b/src/runtime/utils.ts
@@ -41,8 +41,8 @@ export function isJsonRequest(event: H3Event) {
     hasReqHeader(event, "accept", "application/json") ||
     hasReqHeader(event, "user-agent", "curl/") ||
     hasReqHeader(event, "user-agent", "httpie/") ||
-    event.req.url?.endsWith(".json") ||
-    event.req.url?.includes("/api/")
+    event.node.req.url?.endsWith(".json") ||
+    event.node.req.url?.includes("/api/")
   );
 }