fix(parseResponse): should not include error responses in result (#4348)

* fix(client): improve parseResponse type inference for conditional responses

Previously, parseResponse would infer union types for routes that return
different response types based on conditions (e.g., success vs error responses).
This was incorrect because parseResponse throws errors for non-OK responses
and should only return the success response type.

Changes:
- Use Extract<> utility type to filter success status code responses from union types
- Add fallback logic for responses without explicit success status codes
- Update test cases to match the corrected behavior
- Add comprehensive test case for conditional response type inference

The fix ensures that parseResponse(client['conditional-route'].$get()) correctly
infers only the success response type instead of a union of all possible response types.

* ci: apply automated fixes

* test(client): fix parsedResponse test issue and remove unused test case

* fix: minor type error in current runtime version

* chore: add more test cases

* feat: add `FilterClientResponses` util

* fix(parseResponse): should not include error responses in result

* chore: refactor to type-only tests and ordering

* chore: rename type util and add JSDOC describe

---------

Co-authored-by: Zed tse <[email protected]>
Co-authored-by: autofix-ci[bot] <114827586+autofix-ci[bot]@users.noreply.github.com>

Author: 3 people

src/client/types.ts

@@ -136,6 +136,18 @@ export type InferRequestOptionsType<T> = T extends (
   ? NonNullable<R>
   : never
 
+/**
+ * Filter a ClientResponse type so it only includes responses of specific status codes.
+ */
+export type FilterClientResponseByStatusCode<
+  T extends ClientResponse<any, any, any>,
+  U extends number = StatusCode
+> = T extends ClientResponse<infer RT, infer RC, infer RF>
+  ? RC extends U
+    ? ClientResponse<RT, RC, RF>
+    : never
+  : never
+
 type PathToChain<
   Path extends string,
   E extends Schema,

src/client/utils.test.ts

@@ -150,7 +150,20 @@ describe('parseResponse', async () => {
   const app = new Hono()
     .get('/text', (c) => c.text('hi'))
     .get('/json', (c) => c.json({ message: 'hi' }))
-    .get('/404', (c) => c.notFound())
+    .get('/might-error-json', (c) => {
+      if (Math.random() > 0.5) {
+        return c.json({ error: 'error' }, 500)
+      }
+      return c.json({ data: [{ id: 1 }, { id: 2 }] })
+    })
+    .get('/might-error-mixed-json-text', (c) => {
+      if (Math.random() > 0.5) {
+        return c.text('500 Internal Server Error', 500)
+      }
+      return c.json({ message: 'Success' })
+    })
+    .get('/200-explicit', (c) => c.text('OK', 200))
+    .get('/404', (c) => c.text('404 Not Found', 404))
     .get('/500', (c) => c.text('500 Internal Server Error', 500))
     .get('/raw', (c) => {
       c.header('content-type', '')
@@ -174,6 +187,21 @@ describe('parseResponse', async () => {
     http.get('http://localhost/json', () => {
       return HttpResponse.json({ message: 'hi' })
     }),
+    http.get('http://localhost/might-error-json', () => {
+      if (Math.random() > 0.5) {
+        return HttpResponse.json({ error: 'error' }, { status: 500 })
+      }
+      return HttpResponse.json({ data: [{ id: 1 }, { id: 2 }] })
+    }),
+    http.get('http://localhost/might-error-mixed-json-text', () => {
+      if (Math.random() > 0.5) {
+        return HttpResponse.text('500 Internal Server Error', { status: 500 })
+      }
+      return HttpResponse.json({ message: 'Success' })
+    }),
+    http.get('http://localhost/200-explicit', () => {
+      return HttpResponse.text('OK', { status: 200 })
+    }),
     http.get('http://localhost/404', () => {
       return HttpResponse.text('404 Not Found', { status: 404 })
     }),
@@ -195,7 +223,7 @@ describe('parseResponse', async () => {
       })
     }),
     http.get('http://localhost/rawBuffer', () => {
-      return HttpResponse.arrayBuffer(new TextEncoder().encode('hono'), {
+      return HttpResponse.arrayBuffer(new TextEncoder().encode('hono').buffer, {
         headers: {
           'content-type': 'x/custom-type',
         },
@@ -218,6 +246,11 @@ describe('parseResponse', async () => {
       expect(result).toBe('hi')
       type _verify = Expect<Equal<typeof result, 'hi'>>
     }),
+    it('should auto parse text response - explicit 200', async () => {
+      const result = await parseResponse(client['200-explicit'].$get())
+      expect(result).toBe('OK')
+      type _verify = Expect<Equal<typeof result, 'OK'>>
+    }),
     it('should auto parse the json response - async fetch', async () => {
       const result = await parseResponse(client.json.$get())
       expect(result).toEqual({ message: 'hi' })
@@ -259,5 +292,29 @@ describe('parseResponse', async () => {
         parseResponse(client['noRoute'].$get())
       ).rejects.toThrowErrorMatchingInlineSnapshot('[TypeError: fetch failed]')
     }),
+    it('(type-only) should bypass error responses in the result type inference - simple 404', async () => {
+      type ResultType = Awaited<
+        ReturnType<typeof parseResponse<Awaited<ReturnType<(typeof client)['404']['$get']>>>>
+      >
+      type _verify = Expect<Equal<Awaited<ResultType>, undefined>>
+    }),
+    it('(type-only) should bypass error responses in the result type inference - conditional - json', async () => {
+      type ResultType = Awaited<
+        ReturnType<
+          typeof parseResponse<Awaited<ReturnType<(typeof client)['might-error-json']['$get']>>>
+        >
+      >
+      type _verify = Expect<Equal<ResultType, { data: { id: number }[] }>>
+    }),
+    it('(type-only) should bypass error responses in the result type inference - conditional - mixed json/text', async () => {
+      type ResultType = Awaited<
+        ReturnType<
+          typeof parseResponse<
+            Awaited<ReturnType<(typeof client)['might-error-mixed-json-text']['$get']>>
+          >
+        >
+      >
+      type _verify = Expect<Equal<ResultType, { message: string }>>
+    }),
   ])
 })

src/client/utils.ts

@@ -1,5 +1,10 @@
+import type {
+  ClientErrorStatusCode,
+  ContentfulStatusCode,
+  ServerErrorStatusCode,
+} from '../utils/http-status'
 import { fetchRP, DetailedError } from './fetch-result-please'
-import type { ClientResponse, ObjectType } from './types'
+import type { ClientResponse, FilterClientResponseByStatusCode, ObjectType } from './types'
 
 export { DetailedError }
 
@@ -87,13 +92,23 @@ export function deepMerge<T>(target: T, source: Record<string, unknown>): T {
 export async function parseResponse<T extends ClientResponse<any>>(
   fetchRes: T | Promise<T>
 ): Promise<
-  T extends ClientResponse<infer RT, infer _, infer RF>
+  FilterClientResponseByStatusCode<
+    T,
+    Exclude<ContentfulStatusCode, ClientErrorStatusCode | ServerErrorStatusCode> // Filter out the error responses
+  > extends never
+    ? // Filtered responses does not include any contentful responses, exit with undefined
+      undefined
+    : // Filtered responses includes contentful responses, proceed to infer the type
+    FilterClientResponseByStatusCode<
+        T,
+        Exclude<ContentfulStatusCode, ClientErrorStatusCode | ServerErrorStatusCode>
+      > extends ClientResponse<infer RT, infer _, infer RF>
     ? RF extends 'json'
       ? RT
       : RT extends string
       ? RT
       : string
-    : never
+    : undefined
 > {
   return fetchRP(fetchRes)
 }