fix(types): fix middleware union type merging in MergeMiddlewareResponse (#4602)

yusukebe · autofix-ci[bot] · web-flow · commit 489af0b0825f · 2025-12-26T18:26:42.000+09:00
* fix(types): fix middleware union type merging in MergeMiddlewareResponse

* ci: apply automated fixes

* specify `fetch` as app.request

---------

Co-authored-by: autofix-ci[bot] &lt;114827586+autofix-ci[bot]@users.noreply.github.com&gt;
diff --git a/src/types.test.ts b/src/types.test.ts
@@ -2849,6 +2849,30 @@ describe('RPC supports Middleware responses', () => {
     })
   })
 
+  describe('Middleware returning union type (undefined | TypedResponse)', () => {
+    test('middleware that conditionally returns response should merge types', async () => {
+      const middleware = createMiddleware(async (c, next) => {
+        if (Math.random() > 0.5) {
+          return c.json({ cause: 'Unauthorized' }, 401)
+        }
+        await next()
+      })
+
+      const app = new Hono().get('/test', middleware, (c) => c.json({ message: 'Hello' }, 200))
+      const client = hc<typeof app>('http://localhost', {
+        fetch: app.request,
+      })
+      const res = await client.test.$get()
+
+      if (res.status === 200) {
+        expectTypeOf(await res.json()).toEqualTypeOf<{ message: string }>()
+      }
+      if (res.status === 401) {
+        expectTypeOf(await res.json()).toEqualTypeOf<{ cause: string }>()
+      }
+    })
+  })
+
   describe('Merge responses from multiple handlers, no path pattern', () => {
     test('merge responses from 1 middleware', async () => {
       const middleware = createMiddleware(async (c) => c.json({ '400': true }, 400))
diff --git a/src/types.ts b/src/types.ts
@@ -2368,15 +2368,17 @@ type MergeTypedResponse<T> =
         ? T
         : TypedResponse
 
+type ExtractTypedResponseOnly<T> = T extends TypedResponse ? T : never
+
 type MergeMiddlewareResponse<T> = T extends (c: any, next: any) => Promise<infer R>
   ? Exclude<R, void> extends never
     ? never
-    : Exclude<R, void> extends TypedResponse
-      ? Exclude<R, void>
+    : Exclude<R, void> extends Response | TypedResponse<any, any, any>
+      ? ExtractTypedResponseOnly<Exclude<R, void>>
       : never
   : T extends (c: any, next: any) => infer R
-    ? R extends TypedResponse
-      ? R
+    ? R extends Response | TypedResponse<any, any, any>
+      ? ExtractTypedResponseOnly<R>
       : never
     : never
 
