refactor: use event.path instead of event.node.req.url for internal utils

Author: pi0

src/app.ts

@@ -102,22 +102,29 @@ export function use(
 export function createAppEventHandler(stack: Stack, options: AppOptions) {
   const spacing = options.debug ? 2 : undefined;
   return eventHandler(async (event) => {
-    (event.node.req as any).originalUrl =
-      (event.node.req as any).originalUrl || event.node.req.url || "/";
-    const reqUrl = event.node.req.url || "/";
+    const _reqPath = event.path;
+    let _layerPath: string;
     for (const layer of stack) {
+      // 1. Remove prefix from path
       if (layer.route.length > 1) {
-        if (!reqUrl.startsWith(layer.route)) {
+        if (!_reqPath.startsWith(layer.route)) {
           continue;
         }
-        event.node.req.url = reqUrl.slice(layer.route.length) || "/";
+        _layerPath = _reqPath.slice(layer.route.length) || "/";
       } else {
-        event.node.req.url = reqUrl;
+        _layerPath = _reqPath;
       }
-      if (layer.match && !layer.match(event.node.req.url as string, event)) {
+
+      // 2. Custom matcher
+      if (layer.match && !layer.match(_layerPath, event)) {
         continue;
       }
 
+      // 3. Update event path with layer path
+      event._path = _layerPath;
+      event.node.req.url = _layerPath; // Express compatibility
+
+      // 4. Handle request
       const val = await layer.handler(event);
 
       // Already handled
@@ -181,9 +188,7 @@ export function createAppEventHandler(stack: Stack, options: AppOptions) {
     if (!event.handled) {
       throw createError({
         statusCode: 404,
-        statusMessage: `Cannot find any path matching ${
-          event.node.req.url || "/"
-        }.`,
+        statusMessage: `Cannot find any path matching ${event.path || "/"}.`,
       });
     }
   });

src/event/event.ts

@@ -1,14 +1,11 @@
 import type { IncomingHttpHeaders } from "node:http";
 import type { H3EventContext, HTTPMethod } from "../types";
 import type { NodeIncomingMessage, NodeServerResponse } from "../node";
-import {
-  MIMES,
-  sanitizeStatusCode,
-  sanitizeStatusMessage,
-  getRequestPath,
-} from "../utils";
+import { MIMES, sanitizeStatusCode, sanitizeStatusMessage } from "../utils";
 import { H3Response } from "./response";
 
+const DOUBLE_SLASH_RE = /[/\\]{2,}/g; // TODO: Dedup from request.ts
+
 export interface NodeEventContext {
   req: NodeIncomingMessage;
   res: NodeServerResponse;
@@ -24,6 +21,7 @@ export class H3Event implements Pick<FetchEvent, "respondWith"> {
   // Request
   _method: HTTPMethod | undefined;
   _headers: Headers | undefined;
+  _path: string | undefined;
 
   // Response
   _handled = false;
@@ -32,8 +30,19 @@ export class H3Event implements Pick<FetchEvent, "respondWith"> {
     this.node = { req, res };
   }
 
+  get _originalPath() {
+    return (
+      (this.node.req as { originalUrl?: string }).originalUrl ||
+      this.node.req.url ||
+      "/"
+    );
+  }
+
   get path() {
-    return getRequestPath(this);
+    if (!this._path) {
+      this._path = this._originalPath.replace(DOUBLE_SLASH_RE, "/");
+    }
+    return this._path;
   }
 
   get handled(): boolean {

src/router.ts

@@ -76,7 +76,7 @@ export function createRouter(opts: CreateRouterOptions = {}): Router {
   // Main handle
   router.handler = eventHandler((event) => {
     // Remove query parameters for matching
-    let path = event.node.req.url || "/";
+    let path = event.path || "/";
     const qIndex = path.indexOf("?");
     if (qIndex !== -1) {
       path = path.slice(0, Math.max(0, qIndex));
@@ -89,9 +89,7 @@ export function createRouter(opts: CreateRouterOptions = {}): Router {
         throw createError({
           statusCode: 404,
           name: "Not Found",
-          statusMessage: `Cannot find any route matching ${
-            event.node.req.url || "/"
-          }.`,
+          statusMessage: `Cannot find any route matching ${event.path || "/"}.`,
         });
       } else {
         return; // Let app match other handlers

src/utils/request.ts

@@ -4,7 +4,7 @@ import type { HTTPMethod, RequestHeaders } from "../types";
 import type { H3Event } from "../event";
 
 export function getQuery(event: H3Event) {
-  return _getQuery(event.node.req.url || "");
+  return _getQuery(event.path || "");
 }
 
 export function getRouterParams(
@@ -113,11 +113,9 @@ export function getRequestProtocol(
   return (event.node.req.connection as any).encrypted ? "https" : "http";
 }
 
-const DOUBLE_SLASH_RE = /[/\\]{2,}/g;
-
+/** @deprecated Use `event.path` directly */
 export function getRequestPath(event: H3Event): string {
-  const path = (event.node.req.url || "/").replace(DOUBLE_SLASH_RE, "/");
-  return path;
+  return event.path;
 }
 
 export function getRequestURL(

src/utils/route.ts

@@ -7,10 +7,13 @@ export function useBase(base: string, handler: EventHandler): EventHandler {
   if (!base) {
     return handler;
   }
-  return eventHandler((event) => {
-    (event.node.req as any).originalUrl =
-      (event.node.req as any).originalUrl || event.node.req.url || "/";
-    event.node.req.url = withoutBase(event.node.req.url || "/", base);
-    return handler(event);
+  return eventHandler(async (event) => {
+    const _path = event._path;
+    event._path = withoutBase(event.path || "/", base);
+    try {
+      return await handler(event);
+    } finally {
+      event._path = _path;
+    }
   });
 }

test/app.test.ts

@@ -27,7 +27,7 @@ describe("app", () => {
   it("can return JSON directly", async () => {
     app.use(
       "/api",
-      eventHandler((event) => ({ url: event.node.req.url }))
+      eventHandler((event) => ({ url: event.path }))
     );
     const res = await request.get("/api");
 

test/utils.test.ts

@@ -40,7 +40,7 @@ describe("", () => {
         "/",
         useBase(
           "/api",
-          eventHandler((event) => Promise.resolve(event.node.req.url || "none"))
+          eventHandler((event) => Promise.resolve(event.path))
         )
       );
       const result = await request.get("/api/test");
@@ -52,7 +52,7 @@ describe("", () => {
         "/",
         useBase(
           "",
-          eventHandler((event) => Promise.resolve(event.node.req.url || "none"))
+          eventHandler((event) => Promise.resolve(event.path))
         )
       );
       const result = await request.get("/api/test");