fix(hono): Use Proxy for patchAppRequest and patchRoute to preserve original function properties

Author: s1gr1d

packages/hono/src/shared/patchAppRequest.ts

@@ -2,7 +2,6 @@ import {
   debug,
   getActiveSpan,
   getOriginalFunction,
-  markFunctionWrapped,
   SEMANTIC_ATTRIBUTE_SENTRY_OP,
   SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN,
   startSpan,
@@ -14,9 +13,6 @@ import { DEBUG_BUILD } from '../debug-build';
 const INTERNAL_REQUEST_OP = 'hono.request';
 const INTERNAL_REQUEST_ORIGIN = 'auto.http.hono.internal_request';
 
-// Widened type to allow forwarding opaque args (env bindings, execution context)
-type LooseRequestFn = (input: string | Request | URL, requestInit?: RequestInit, ...rest: unknown[]) => unknown;
-
 function extractPathname(input: string | Request | URL): string {
   if (typeof input === 'string') {
     return /^https?:\/\//.test(input) ? new URL(input).pathname : input;
@@ -39,34 +35,41 @@ export function patchAppRequest<E extends Env>(app: Hono<E>): void {
     return;
   }
 
-  const originalRequest = app.request as LooseRequestFn;
+  const originalRequest = app.request;
 
-  const patchedRequest = (input: string | Request | URL, requestInit?: RequestInit, ...rest: unknown[]) => {
-    if (!getActiveSpan()) {
-      return originalRequest(input, requestInit, ...rest);
-    }
+  app.request = new Proxy(originalRequest, {
+    apply(_target, thisArg, args: [string | Request | URL, RequestInit?, ...unknown[]]) {
+      const [input, requestInit, ...rest] = args;
 
-    let method = requestInit?.method ?? (input instanceof Request ? input.method : 'GET');
-    method = method.toUpperCase();
+      if (!getActiveSpan()) {
+        return Reflect.apply(_target, thisArg, args);
+      }
 
-    const path = extractPathname(input);
+      let method = requestInit?.method ?? (input instanceof Request ? input.method : 'GET');
+      method = method.toUpperCase();
 
-    return startSpan(
-      {
-        name: `${method} ${path}`,
-        op: INTERNAL_REQUEST_OP,
-        onlyIfParent: true,
-        attributes: {
-          [SEMANTIC_ATTRIBUTE_SENTRY_OP]: INTERNAL_REQUEST_OP,
-          [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: INTERNAL_REQUEST_ORIGIN,
-        },
-      },
-      () => originalRequest(input, requestInit, ...rest),
-    );
-  };
+      const path = extractPathname(input);
 
-  markFunctionWrapped(patchedRequest as unknown as WrappedFunction, originalRequest as unknown as WrappedFunction);
-  app.request = patchedRequest as typeof app.request;
+      return startSpan(
+        {
+          name: `${method} ${path}`,
+          op: INTERNAL_REQUEST_OP,
+          onlyIfParent: true,
+          attributes: {
+            [SEMANTIC_ATTRIBUTE_SENTRY_OP]: INTERNAL_REQUEST_OP,
+            [SEMANTIC_ATTRIBUTE_SENTRY_ORIGIN]: INTERNAL_REQUEST_ORIGIN,
+          },
+        },
+        () => Reflect.apply(_target, thisArg, [input, requestInit, ...rest]),
+      );
+    },
+    get(target, prop, receiver) {
+      if (prop === '__sentry_original__') {
+        return originalRequest;
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+  });
 
   DEBUG_BUILD && debug.log('[hono] Patched app.request for internal dispatch tracing.');
 }

packages/hono/src/shared/patchRoute.ts

@@ -1,4 +1,4 @@
-import { debug, getOriginalFunction, markFunctionWrapped } from '@sentry/core';
+import { debug, getOriginalFunction } from '@sentry/core';
 import type { WrappedFunction } from '@sentry/core';
 import type { Hono, MiddlewareHandler } from 'hono';
 import { Hono as HonoClass } from 'hono';
@@ -81,16 +81,22 @@ export function installRouteHookOnPrototype(): RouteHookHandle {
   const originalRoute = honoBaseProto.route;
   const { handle, onSubAppMounted } = createRouteHook();
 
-  const patchedRoute = function (this: HonoAny, path: string, subApp: HonoAny): HonoAny {
-    if (subApp && Array.isArray(subApp.routes)) {
-      onSubAppMounted(subApp);
-    }
-
-    return originalRoute.call(this, path, subApp);
-  };
+  honoBaseProto.route = new Proxy(originalRoute, {
+    apply(_target, thisArg, args: [string, HonoAny]) {
+      const [, subApp] = args;
+      if (subApp && Array.isArray(subApp.routes)) {
+        onSubAppMounted(subApp);
+      }
 
-  markFunctionWrapped(patchedRoute as unknown as WrappedFunction, originalRoute as unknown as WrappedFunction);
-  honoBaseProto.route = patchedRoute;
+      return Reflect.apply(_target, thisArg, args);
+    },
+    get(target, prop, receiver) {
+      if (prop === '__sentry_original__') {
+        return originalRoute;
+      }
+      return Reflect.get(target, prop, receiver);
+    },
+  });
   honoBaseProto.__sentryRouteHook__ = handle;
 
   DEBUG_BUILD && debug.log('[hono] Installed route hook on HonoBase.prototype.');

packages/hono/test/shared/applyPatches.test.ts

@@ -395,6 +395,105 @@ describe('applyPatches', () => {
     });
   });
 
+  describe('wrapSubAppMiddleware non-invasive patching', () => {
+    it('preserves symbol-keyed properties on sub-app middleware handlers', async () => {
+      const app = new Hono();
+      applyPatches(app);
+
+      const OPENAPI = Symbol('openapi');
+      const META = Symbol('meta');
+      const middleware = async function authMiddleware(_c: unknown, next: () => Promise<void>) {
+        await next();
+      };
+      (middleware as any)[OPENAPI] = { security: [{ bearer: [] }] };
+      (middleware as any)[META] = { rateLimit: 100 };
+      (middleware as any).customProp = 'preserved';
+
+      const subApp = new Hono();
+      subApp.use(middleware);
+      subApp.get('/', () => new Response('ok'));
+
+      app.route('/api', subApp);
+
+      const route = (subApp.routes as Array<{ handler: Function }>).find(
+        r => (r.handler as any).__sentry_original__ === middleware || r.handler === middleware,
+      );
+      expect(route).toBeDefined();
+
+      const wrappedHandler = route!.handler;
+      const symbols = Object.getOwnPropertySymbols(wrappedHandler);
+      expect(symbols).toContain(OPENAPI);
+      expect(symbols).toContain(META);
+      expect((wrappedHandler as any)[OPENAPI]).toEqual({ security: [{ bearer: [] }] });
+      expect((wrappedHandler as any)[META]).toEqual({ rateLimit: 100 });
+      expect((wrappedHandler as any).customProp).toBe('preserved');
+    });
+
+    it('preserves function.name on sub-app middleware after wrapping', async () => {
+      const app = new Hono();
+      applyPatches(app);
+
+      const subApp = new Hono();
+      subApp.use(async function corsMiddleware(_c: unknown, next: () => Promise<void>) {
+        await next();
+      });
+      subApp.get('/', () => new Response('ok'));
+
+      app.route('/api', subApp);
+
+      const route = (subApp.routes as Array<{ handler: Function; method: string }>).find(
+        r => r.method === 'ALL' && r.handler.name === 'corsMiddleware',
+      );
+      expect(route).toBeDefined();
+      expect(route!.handler.name).toBe('corsMiddleware');
+    });
+
+    it('preserves function.length on sub-app middleware after wrapping', async () => {
+      const app = new Hono();
+      applyPatches(app);
+
+      const subApp = new Hono();
+      const mw = async function twoArgMw(_c: unknown, next: () => Promise<void>) {
+        await next();
+      };
+      const originalLength = mw.length;
+      subApp.use(mw);
+      subApp.get('/', () => new Response('ok'));
+
+      app.route('/api', subApp);
+
+      const route = (subApp.routes as Array<{ handler: Function; method: string }>).find(
+        r => r.method === 'ALL' && r.handler.length === originalLength,
+      );
+      expect(route).toBeDefined();
+      expect(route!.handler.length).toBe(originalLength);
+    });
+
+    it('does not alter the behavior of sub-app route handlers (non-middleware)', async () => {
+      const app = new Hono();
+      applyPatches(app);
+
+      const HANDLER_META = Symbol('handler-meta');
+      const handler = async function getItems() {
+        return new Response('items');
+      };
+      (handler as any)[HANDLER_META] = { cached: true };
+
+      const subApp = new Hono();
+      subApp.get('/items', handler);
+
+      app.route('/api', subApp);
+
+      const route = (subApp.routes as Array<{ handler: Function; path: string }>).find(r => r.path === '/items');
+      expect(route).toBeDefined();
+      expect((route!.handler as any)[HANDLER_META]).toEqual({ cached: true });
+
+      const res = await app.fetch(new Request('http://localhost/api/items'));
+      expect(res.status).toBe(200);
+      expect(await res.text()).toBe('items');
+    });
+  });
+
   describe('patchAppRequest integration', () => {
     it('patches .request() on sub-apps when they are mounted via route()', async () => {
       const app = new Hono();

packages/hono/test/shared/earlyPatchRoute.test.ts

@@ -140,3 +140,73 @@ describe('installRouteHookOnPrototype idempotency', () => {
     expect(startSpanMock).toHaveBeenCalledTimes(1);
   });
 });
+
+describe('installRouteHookOnPrototype non-invasive patching', () => {
+  afterAll(() => {
+    honoBaseProto.route = originalRoute;
+  });
+
+  it('preserves function.name of the original route method', () => {
+    honoBaseProto.route = originalRoute;
+    const originalName = originalRoute.name;
+
+    installRouteHookOnPrototype();
+
+    expect(honoBaseProto.route!.name).toBe(originalName);
+  });
+
+  it('preserves function.length of the original route method', () => {
+    honoBaseProto.route = originalRoute;
+    const originalLength = originalRoute.length;
+
+    installRouteHookOnPrototype();
+
+    expect(honoBaseProto.route!.length).toBe(originalLength);
+  });
+
+  it('preserves symbol-keyed properties on the route method', () => {
+    honoBaseProto.route = originalRoute;
+    const ROUTER_META = Symbol('router-meta');
+    (originalRoute as any)[ROUTER_META] = { version: 3 };
+
+    installRouteHookOnPrototype();
+
+    const symbols = Object.getOwnPropertySymbols(honoBaseProto.route!);
+    expect(symbols).toContain(ROUTER_META);
+    expect((honoBaseProto.route as any)[ROUTER_META]).toEqual({ version: 3 });
+  });
+
+  it('preserves string-keyed custom properties on the route method', () => {
+    honoBaseProto.route = originalRoute;
+    (originalRoute as any).pluginId = 'openapi-router';
+    (originalRoute as any).__patched_by_other_lib__ = true;
+
+    installRouteHookOnPrototype();
+
+    expect((honoBaseProto.route as any).pluginId).toBe('openapi-router');
+    expect((honoBaseProto.route as any).__patched_by_other_lib__).toBe(true);
+  });
+
+  it('preserves prototype chain of the original function', () => {
+    honoBaseProto.route = originalRoute;
+    const originalProto = Object.getPrototypeOf(originalRoute);
+
+    installRouteHookOnPrototype();
+
+    expect(Object.getPrototypeOf(honoBaseProto.route!)).toBe(originalProto);
+  });
+
+  it('correctly calls the original route and preserves return value', () => {
+    honoBaseProto.route = originalRoute;
+    installRouteHookOnPrototype();
+
+    const app = new Hono();
+    applyPatches(app);
+
+    const subApp = new Hono();
+    subApp.get('/test', c => c.text('ok'));
+
+    const result = app.route('/api', subApp);
+    expect(result).toBe(app);
+  });
+});

packages/hono/test/shared/patchAppRequest.test.ts

@@ -154,4 +154,72 @@ describe('patchAppRequest', () => {
       expect.any(Function),
     );
   });
+
+  describe('non-invasive patching (preserves existing properties)', () => {
+    it('preserves symbol-keyed properties on app.request', () => {
+      const app = new Hono();
+      const CUSTOM_SYMBOL = Symbol('custom-meta');
+      (app.request as any)[CUSTOM_SYMBOL] = { version: 2 };
+
+      patchAppRequest(app);
+
+      const symbols = Object.getOwnPropertySymbols(app.request);
+      expect(symbols).toContain(CUSTOM_SYMBOL);
+      expect((app.request as any)[CUSTOM_SYMBOL]).toEqual({ version: 2 });
+    });
+
+    it('preserves string-keyed custom properties on app.request', () => {
+      const app = new Hono();
+      (app.request as any).customFlag = true;
+      (app.request as any).metadata = { wrapped: false };
+
+      patchAppRequest(app);
+
+      expect((app.request as any).customFlag).toBe(true);
+      expect((app.request as any).metadata).toEqual({ wrapped: false });
+    });
+
+    it('preserves function.name of the original request method', () => {
+      const app = new Hono();
+      const originalName = app.request.name;
+      patchAppRequest(app);
+
+      expect(app.request.name).toBe(originalName);
+    });
+
+    it('preserves function.length of the original request method', () => {
+      const app = new Hono();
+      const originalLength = app.request.length;
+      patchAppRequest(app);
+
+      expect(app.request.length).toBe(originalLength);
+    });
+
+    it('does not interfere with instanceof or typeof checks', () => {
+      const app = new Hono();
+      patchAppRequest(app);
+
+      expect(typeof app.request).toBe('function');
+    });
+
+    it('preserves prototype chain of the original function', () => {
+      const app = new Hono();
+      const originalProto = Object.getPrototypeOf(app.request);
+      patchAppRequest(app);
+
+      expect(Object.getPrototypeOf(app.request)).toBe(originalProto);
+    });
+
+    it('preserves properties added by third-party libraries (e.g. OpenAPI metadata)', () => {
+      const app = new Hono();
+      const OPENAPI = Symbol('openapi');
+      (app.request as any)[OPENAPI] = { paths: { '/hello': { get: {} } } };
+      (app.request as any).__middleware_chain__ = ['auth', 'cors'];
+
+      patchAppRequest(app);
+
+      expect((app.request as any)[OPENAPI]).toEqual({ paths: { '/hello': { get: {} } } });
+      expect((app.request as any).__middleware_chain__).toEqual(['auth', 'cors']);
+    });
+  });
 });