fix(response): absorb errors thrown in onResponse hook

pi0 · pi0 · commit 4a32c1b75528 · 2026-07-22T14:26:29.000Z
diff --git a/src/response.ts b/src/response.ts
@@ -28,13 +28,22 @@ export function toResponse(
 
   const { onResponse } = config;
   if (onResponse) {
-    return Promise.resolve(onResponse(response as Response, event)).then(
-      () =>
-        ((event as any)[kEventDispose] as DisposeState | undefined)?.observe(
-          response as Response,
-          val,
-        ) ?? (response as Response),
-    );
+    // onResponse is a terminal side-effect hook (returns void). A throw/rejection here must not
+    // escape the lifecycle (onError already ran); absorb and log it (consistent with dispose
+    // callbacks), then still return the already-built response. The hook is invoked inside `.then`
+    // so a synchronous throw is caught too (not just a rejected promise).
+    return Promise.resolve()
+      .then(() => onResponse(response as Response, event))
+      .catch((error) => {
+        if (!config.silent) console.error(error);
+      })
+      .then(
+        () =>
+          ((event as any)[kEventDispose] as DisposeState | undefined)?.observe(
+            response as Response,
+            val,
+          ) ?? (response as Response),
+      );
   }
   return (
     ((event as any)[kEventDispose] as DisposeState | undefined)?.observe(
diff --git a/test/bench/bundle.test.ts b/test/bench/bundle.test.ts
@@ -18,7 +18,7 @@ describe("benchmark", () => {
     if (process.env.DEBUG) {
       console.log(`Bundle size (H3): ${bundle.bytes} (gzip: ${bundle.gzipSize})`);
     }
-    expect(bundle.bytes).toBeLessThanOrEqual(18_350); // <18.35kb
+    expect(bundle.bytes).toBeLessThanOrEqual(18_400); // <18.4kb
     expect(bundle.gzipSize).toBeLessThanOrEqual(6_950); // <6.95kb
   });
 
@@ -34,7 +34,7 @@ describe("benchmark", () => {
     if (process.env.DEBUG) {
       console.log(`Bundle size (H3Core): ${bundle.bytes} (gzip: ${bundle.gzipSize})`);
     }
-    expect(bundle.bytes).toBeLessThanOrEqual(7550); // <7.55kb
+    expect(bundle.bytes).toBeLessThanOrEqual(7600); // <7.6kb
     expect(bundle.gzipSize).toBeLessThanOrEqual(3000); // <3kb
   });
 
diff --git a/test/hooks.test.ts b/test/hooks.test.ts
@@ -53,6 +53,26 @@ describeMatrix("hooks", (t, { it, expect }) => {
     expect(t.hooks.onResponse).toHaveBeenCalledTimes(1);
   });
 
+  it("absorbs a throwing onResponse hook without failing the request", async () => {
+    t.app.use(() => "Hello World!");
+    const hookError = new Error("onResponse boom");
+    t.hooks.onResponse.mockImplementationOnce(() => {
+      throw hookError;
+    });
+    const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
+
+    const res = await t.fetch("/foo");
+
+    // Request still succeeds with the already-built response
+    expect(res.status).toBe(200);
+    expect(await res.text()).toBe("Hello World!");
+
+    // Error is absorbed and logged, not routed back into onError
+    expect(t.hooks.onError).toHaveBeenCalledTimes(0);
+    expect(consoleError).toHaveBeenCalledWith(hookError);
+    consoleError.mockRestore();
+  });
+
   it("calls onRequest and onResponse when an unhandled error occurs", async () => {
     t.app.use((event) => {
       // @ts-expect-error
