Merge pull request #7 from softnetics/supakorn/feat/throw-on-error-option

feat: `throwOnError` options and test cases.

Author: saenyakorn

.changeset/silly-tips-fly.md

@@ -0,0 +1,5 @@
+---
+"@softnetics/hono-react-query": patch
+---
+
+add: `throwOnError` options and test cases.

package.json

@@ -23,6 +23,7 @@
     "format:check": "prettier --check .",
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
+    "test:watch": "vitest run --watch",
     "build": "tsup"
   },
   "peerDependencies": {

src/index.spec.tsx

@@ -1,4 +1,8 @@
-import type { UseMutationResult, UseQueryResult } from '@tanstack/react-query'
+import {
+  type DefinedInitialDataOptions,
+  type UseMutationResult,
+  type UseQueryResult,
+} from '@tanstack/react-query'
 import { Hono } from 'hono'
 import { describe, expect, expectTypeOf, it } from 'vitest'
 
@@ -12,6 +16,7 @@ const basicHonoApp = new Hono()
     if (!c.req.param('id')) {
       return c.json({ error: 'User ID is required' }, 400)
     }
+
     return c.json({ user: { id: 'id', name: 'John Doe' } }, 200)
   })
   .post('/users', async (c) => {
@@ -40,6 +45,86 @@ describe('createReactQueryClient', () => {
     expect(client.useOptimisticUpdateQuery).toBeDefined()
   })
 
+  it('Should contain Error in Data', () => {
+    const client = createReactQueryClient<BasicHonoApp>({
+      baseUrl: 'http://localhost:3000',
+    })
+
+    const queryOptions = client.queryOptions('/users/:id', '$get', {
+      input: {
+        param: { id: 'none' },
+      },
+      options: {
+        throwOnError: false,
+      },
+    })
+
+    type DataAndError =
+      typeof queryOptions extends DefinedInitialDataOptions<infer TDataAndError>
+        ? TDataAndError
+        : never
+
+    expectTypeOf<DataAndError>().toEqualTypeOf<
+      | {
+          data: {
+            user: {
+              id: string
+              name: string
+            }
+          }
+          status: 200
+          format: 'json'
+        }
+      | Error
+      | HonoResponseError<
+          {
+            error: string
+          },
+          400,
+          'json'
+        >
+    >()
+  })
+
+  it("Shouldn't contain Error in Data", () => {
+    const client = createReactQueryClient<BasicHonoApp>({
+      baseUrl: 'http://localhost:3000',
+    })
+
+    const queryOptions = client.queryOptions('/users/:id', '$get', {
+      input: {
+        param: { id: 'none' },
+      },
+    })
+
+    type Result =
+      typeof queryOptions extends DefinedInitialDataOptions<infer TData, infer TError>
+        ? { data: TData; error: TError }
+        : never
+
+    expectTypeOf<Result['data']>().toEqualTypeOf<{
+      data: {
+        user: {
+          id: string
+          name: string
+        }
+      }
+      status: 200
+      format: 'json'
+    }>()
+
+    expectTypeOf<Result['error']>().toEqualTypeOf<
+      | Error
+      | HonoResponseError<
+          {
+            error: string
+          },
+          400,
+          'json'
+        >
+    >()
+  })
+
   it('should create the query client with the correct types', () => {
     const client = createReactQueryClient<BasicHonoApp>({
       baseUrl: 'http://localhost:3000',

src/index.ts

@@ -55,7 +55,7 @@ function getter(obj: object, paths: string[]): any {
   }, obj)
 }
 
-async function responseParser(response: Response): Promise<any> {
+async function responseParser(response: Response, throwOnError?: boolean): Promise<any> {
   let data: any
   const contentType = response.headers.get('content-type')
   if (contentType?.includes('application/json')) {
@@ -78,6 +78,8 @@ async function responseParser(response: Response): Promise<any> {
 
   if (response.ok) {
     return res
+  } else if (!throwOnError) {
+    return new HonoResponseError(res)
   } else {
     throw new HonoResponseError(res)
   }
@@ -106,6 +108,8 @@ function queryOptionsFactory<T extends Record<string, any>>(
     const handler = getter(client, paths)
     const payload = (honoPayload as any)?.input ?? {}
 
+    const isThrowOnError = honoPayload.options?.throwOnError ?? true
+
     return queryOptions({
       queryKey: createQueryKey(
         method.toString(),
@@ -114,7 +118,7 @@ function queryOptionsFactory<T extends Record<string, any>>(
       ),
       queryFn: async () => {
         const response = await handler(payload, honoPayload.options)
-        return responseParser(response)
+        return responseParser(response, isThrowOnError)
       },
       ...hookOptions,
     }) as any

src/types.ts

@@ -1,4 +1,5 @@
 import type {
+  DefaultError,
   DefinedInitialDataOptions,
   DefinedUseQueryResult,
   InvalidateQueryFilters,
@@ -53,9 +54,11 @@ type ErrorResponse<T> =
       >
     : never
 
-export type HonoPayload<TInput> = undefined extends TInput
-  ? { options?: ClientRequestOptions }
-  : { input: TInput; options?: ClientRequestOptions }
+type HonoPayloadOptions = ClientRequestOptions & { throwOnError?: boolean }
+export type HonoPayload<
+  TInput,
+  TOptions extends HonoPayloadOptions | undefined = HonoPayloadOptions | undefined,
+> = undefined extends TInput ? { options?: TOptions } : { input: TInput; options?: TOptions }
 
 export type UseHonoQuery<TApp extends Record<string, any>> = <
   TPath extends keyof TApp,
@@ -128,20 +131,35 @@ export type HonoQueryOptions<TApp extends Record<string, any>> = <
     >,
     'queryKey' | 'queryFn'
   >,
+  TOptions extends HonoPayloadOptions | undefined = HonoPayloadOptions | undefined,
 >(
   path: TPath,
   method: TMethod,
-  honoPayload: HonoPayload<InferFunctionInput<TApp[TPath][TMethod]>>,
+  honoPayload: HonoPayload<InferFunctionInput<TApp[TPath][TMethod]>, TOptions>,
   queryOptions?: TQueryOptions
 ) => 'initialData' extends keyof TQueryOptions
-  ? DefinedInitialDataOptions<
-      SuccessResponse<InferFunctionReturn<TApp[TPath][TMethod]>>,
-      ErrorResponse<InferFunctionReturn<TApp[TPath][TMethod]>> | Error
-    >
-  : UndefinedInitialDataOptions<
-      SuccessResponse<InferFunctionReturn<TApp[TPath][TMethod]>>,
-      ErrorResponse<InferFunctionReturn<TApp[TPath][TMethod]>> | Error
-    >
+  ? TOptions extends { throwOnError: false }
+    ? DefinedInitialDataOptions<
+        | SuccessResponse<InferFunctionReturn<TApp[TPath][TMethod]>>
+        | ErrorResponse<InferFunctionReturn<TApp[TPath][TMethod]>>
+        | Error,
+        DefaultError
+      >
+    : DefinedInitialDataOptions<
+        SuccessResponse<InferFunctionReturn<TApp[TPath][TMethod]>>,
+        ErrorResponse<InferFunctionReturn<TApp[TPath][TMethod]>> | Error
+      >
+  : TOptions extends { throwOnError: false }
+    ? UndefinedInitialDataOptions<
+        | SuccessResponse<InferFunctionReturn<TApp[TPath][TMethod]>>
+        | ErrorResponse<InferFunctionReturn<TApp[TPath][TMethod]>>
+        | Error,
+        DefaultError
+      >
+    : UndefinedInitialDataOptions<
+        SuccessResponse<InferFunctionReturn<TApp[TPath][TMethod]>>,
+        ErrorResponse<InferFunctionReturn<TApp[TPath][TMethod]>> | Error
+      >
 
 export type HonoMutationOptions<TApp extends Record<string, any>> = <
   TPath extends keyof TApp,