feat(api): enhance client creation with ClientOptions type for better type safety

fix(api): handle HTTPPayloadError in PetDetail component for improved error handling
chore(tests): update generator tests to check for ClientOptions type in generated client code
fix(core): add beforeError hook to ApiClient for better error handling
fix(core): improve type definitions for ClientOptions and HTTPPayloadError
chore(tests): mock HTTPError in tests for consistent error handling
chore(tsconfig): refine exclude patterns to prevent unnecessary files from being included

Author: brentkirkland

examples/hooks/src/api/client.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { createClient as createRuntimeClient } from "@zoddy/core";
+import { createClient as createRuntimeClient, type ClientOptions } from "@zoddy/core";
 
 export const Order = z.object({
   id: z.number().int().optional(),
@@ -834,6 +834,6 @@ export const operations = {
 
 export type Operations = typeof operations;
 
-export function createClient(baseUrl: string, options?: { headers?: Record<string, string> }) {
+export function createClient(baseUrl: string, options?: ClientOptions) {
   return createRuntimeClient(baseUrl, operations, options);
 }

examples/hooks/src/components/PetDetail.tsx

@@ -1,4 +1,4 @@
-import type { ParamsById, QueriesById } from "@zoddy/core";
+import { HTTPPayloadError, type ParamsById, type QueriesById } from "@zoddy/core";
 import type { operations } from "../api/client";
 import { hooks } from "../api/hooks";
 
@@ -15,16 +15,25 @@ export const PetDetail = ({
     isRefetching,
     refetch,
     error,
-  } = hooks.useGetPetById({
-    params,
-    queries,
-  });
+  } = hooks.useGetPetById(
+    {
+      params,
+      queries,
+    },
+    {
+      retry: false,
+    }
+  );
 
   if (isPending) {
     return <div>Loading...</div>;
   }
 
   if (error) {
+    if (error instanceof HTTPPayloadError) {
+      return <div>Error: {JSON.stringify(error.payload)}</div>;
+    }
+    console.error(error);
     return <div>Error: {error.message}</div>;
   }
 

examples/hooks/src/components/UpdatePet.tsx

@@ -25,9 +25,6 @@ export const UpdatePetForm = ({
       console.log("Invalidating getPetById", hooks.getKey("getPetById", { params }));
       queryClient.invalidateQueries({ queryKey: hooks.getKey("getPetById", { params }) });
     },
-    onError: (error) => {
-      console.error("Error updating pet:", error);
-    },
   });
 
   const handleSubmit = (e: React.FormEvent) => {

packages/cli/src/generator.ts

@@ -20,13 +20,13 @@ export async function generateClient(oas: OpenAPIV3.Document): Promise<string> {
   const schemaCode = generateSchemaCode(schemas);
   const operationsCode = generateOperationsCode(operations);
   const code = `import { z } from 'zod';
-import { createClient as createRuntimeClient } from '@zoddy/core';
+import { createClient as createRuntimeClient, type ClientOptions } from '@zoddy/core';
 
 ${schemaCode}
 
 ${operationsCode}
 
-export function createClient(baseUrl: string, options?: { headers?: Record<string, string> }) {
+export function createClient(baseUrl: string, options?: ClientOptions) {
   return createRuntimeClient(baseUrl, operations, options);
 }
 `;

packages/cli/tests/generator.test.ts

@@ -34,8 +34,10 @@ describe("zoddy generator", () => {
     it("should generate client code with correct imports", () => {
       expect(clientCode).toContain('import { z } from "zod"');
       expect(clientCode).toContain(
-        'import { createClient as createRuntimeClient } from "@zoddy/core"'
+        'createClient as createRuntimeClient'
       );
+      expect(clientCode).toContain('type ClientOptions')
+      expect(clientCode).toContain('@zoddy/core')
     });
 
     it("should generate schema exports", () => {

packages/core/src/index.ts

@@ -1,12 +1,29 @@
-import ky, { type Hooks } from "ky";
+import ky, {
+  type Hooks,
+  type Options,
+  type NormalizedOptions,
+  type BeforeErrorHook,
+  HTTPError,
+} from "ky";
 import type { ZodError, ZodType } from "zod";
 
-export interface ClientOptions {
+// Ky types
+export type { Hooks, Options };
+
+export class HTTPPayloadError extends HTTPError {
+  payload: any;
+  constructor(response: Response, request: Request, options: NormalizedOptions, payload: any) {
+    super(response, request, options);
+    this.payload = payload;
+  }
+}
+
+export { HTTPError };
+
+export interface ClientOptions extends Options {
   baseUrl: string;
-  headers?: Record<string, string>;
   validate?: boolean;
-  hooks?: Hooks;
-  validationHelpers?: ValidationHelpers;
+  disableErrorParsing?: boolean;
 }
 
 export interface OperationParameter {
@@ -413,38 +430,60 @@ export class ApiClient {
   private validationHelpers?: ValidationHelpers;
 
   constructor(baseUrl: string, operations: Operations, options?: Omit<ClientOptions, "baseUrl">) {
+    const { validate, disableErrorParsing, ...kyOptions } = options ?? {};
     this.operations = operations;
 
-    const shouldValidate = options?.validate !== false;
+    const shouldValidate = validate !== false;
+
+    const beforeError: BeforeErrorHook = async (error) => {
+      const { response, request, options } = error;
+      try {
+        const newError = new HTTPPayloadError(response, request, options, await response.json());
+        return newError;
+      } catch (e) {
+        return error;
+      }
+    };
 
     if (!shouldValidate) {
       this.ky = ky.create({
         prefixUrl: baseUrl,
-        ...options,
+        ...kyOptions,
+        hooks: {
+          ...kyOptions.hooks,
+          beforeError: [
+            ...(disableErrorParsing ? [beforeError] : []),
+            ...(kyOptions.hooks?.beforeError ?? []),
+          ],
+        },
       });
       return;
     }
 
-    this.validationHelpers = options?.validationHelpers ?? createValidationHelpers();
+    this.validationHelpers = createValidationHelpers();
     const hooks = createKyValidationHooks(this.validationHelpers);
 
     this.ky = ky.create({
       prefixUrl: baseUrl,
-      ...(options?.headers && { headers: options.headers }),
+      ...kyOptions,
       hooks: {
+        beforeError: [
+          ...(disableErrorParsing ? [beforeError] : []),
+          ...(kyOptions.hooks?.beforeError ?? []),
+        ],
         beforeRequest: [
           (request, options) => {
             const operation = (options as any).operation as Operation;
             return hooks.beforeRequest?.(request, options, operation) ?? request;
           },
-          ...(options?.hooks?.beforeRequest ?? []),
+          ...(kyOptions?.hooks?.beforeRequest ?? []),
         ],
         afterResponse: [
           (request, options, response) => {
             const operation = (options as any).operation as Operation;
             return hooks.afterResponse?.(request, options, response, operation) ?? response;
           },
-          ...(options?.hooks?.afterResponse ?? []),
+          ...(kyOptions?.hooks?.afterResponse ?? []),
         ],
       },
     });
@@ -497,7 +536,7 @@ export class ApiClient {
       }
     }
 
-    const requestOptions: any = {
+    const requestOptions: Record<string, any> = {
       method: operation.method.toUpperCase(),
       headers,
       searchParams,

packages/core/tests/api-client.test.ts

@@ -3,7 +3,18 @@ import { z } from "zod";
 import { ApiClient, type Operations, createClient } from "../src/index";
 
 // Mock ky for testing
-vi.mock("ky", () => {
+vi.mock("ky", async () => {
+  // Create a mock HTTPError class
+  class MockHTTPError extends Error {
+    constructor(
+      public response: Response,
+      public request: Request,
+      public options: any
+    ) {
+      super("HTTP Error");
+    }
+  }
+
   const mockResponse = {
     json: vi.fn(),
     text: vi.fn(),
@@ -19,6 +30,7 @@ vi.mock("ky", () => {
 
   return {
     default: mockKy,
+    HTTPError: MockHTTPError,
   };
 });
 
@@ -129,6 +141,7 @@ describe("ApiClient", () => {
         hooks: {
           beforeRequest: expect.any(Array),
           afterResponse: expect.any(Array),
+          beforeError: expect.any(Array),
         },
       });
     });

packages/core/tests/integration.test.ts

@@ -10,6 +10,17 @@ import {
 
 // Mock ky for integration testing
 vi.mock("ky", () => {
+  // Create a mock HTTPError class
+  class MockHTTPError extends Error {
+    constructor(
+      public response: Response,
+      public request: Request,
+      public options: any
+    ) {
+      super("HTTP Error");
+    }
+  }
+
   let currentHooks: any = null;
 
   const mockKy = vi.fn().mockImplementation(async () => {
@@ -60,6 +71,7 @@ vi.mock("ky", () => {
 
   return {
     default: mockKy,
+    HTTPError: MockHTTPError,
   };
 });
 

tsconfig.json

@@ -33,5 +33,5 @@
     "incremental": true
   },
   "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist", "**/*.test.ts", "**/*.spec.ts"]
+  "exclude": ["node_modules", "**/node_modules/**", "dist", "**/*.test.ts", "**/*.spec.ts"]
 }