fix: inference based on error status code

Author: astahmer

packages/typed-openapi/src/generator.ts

@@ -316,19 +316,31 @@ export type Endpoint<TConfig extends DefaultEndpoint = DefaultEndpoint> = {
 export type Fetcher = (method: Method, url: string, parameters?: EndpointParameters | undefined) => Promise<Response>;
 
 // Error handling types
-export type ApiResponse<TSuccess, TErrors extends Record<string, unknown> = {}> =
+export type ApiResponse<TSuccess, TErrors extends Record<string | number, unknown> = {}> =
   | {
       ok: true;
       status: number;
       data: TSuccess;
     }
-  | {
-      [K in keyof TErrors]: {
-        ok: false;
-        status: K extends \`\${infer StatusCode extends number}\` ? StatusCode : never;
-        error: TErrors[K];
-      };
-    }[keyof TErrors];
+  | (keyof TErrors extends never
+      ? never
+      : {
+          [K in keyof TErrors]: K extends string
+            ? K extends \`\${infer StatusCode extends number}\`
+              ? {
+                  ok: false;
+                  status: StatusCode;
+                  error: TErrors[K];
+                }
+              : never
+            : K extends number
+              ? {
+                  ok: false;
+                  status: K;
+                  error: TErrors[K];
+                }
+              : never;
+        }[keyof TErrors]);
 
 export type SafeApiResponse<TEndpoint> = TEndpoint extends { response: infer TSuccess; responses: infer TResponses }
   ? TResponses extends Record<string, unknown>
@@ -379,34 +391,32 @@ export class ApiClient {
       ...params: MaybeOptionalArg<${match(ctx.runtime)
         .with("zod", "yup", () => infer(`TEndpoint["parameters"]`))
         .with("arktype", "io-ts", "typebox", "valibot", () => infer(`TEndpoint`) + `["parameters"]`)
-        .otherwise(() => `TEndpoint["parameters"]`)}>
+        .otherwise(() => `TEndpoint["parameters"]`)} & { withResponse?: false }>
     ): Promise<${match(ctx.runtime)
       .with("zod", "yup", () => infer(`TEndpoint["response"]`))
       .with("arktype", "io-ts", "typebox", "valibot", () => infer(`TEndpoint`) + `["response"]`)
       .otherwise(() => `TEndpoint["response"]`)}>;
 
     ${method}<Path extends keyof ${capitalizedMethod}Endpoints, TEndpoint extends ${capitalizedMethod}Endpoints[Path]>(
       path: Path,
-      options: { withResponse: true },
       ...params: MaybeOptionalArg<${match(ctx.runtime)
         .with("zod", "yup", () => infer(`TEndpoint["parameters"]`))
         .with("arktype", "io-ts", "typebox", "valibot", () => infer(`TEndpoint`) + `["parameters"]`)
-        .otherwise(() => `TEndpoint["parameters"]`)}>
+        .otherwise(() => `TEndpoint["parameters"]`)} & { withResponse: true }>
     ): Promise<SafeApiResponse<TEndpoint>>;
 
     ${method}<Path extends keyof ${capitalizedMethod}Endpoints, TEndpoint extends ${capitalizedMethod}Endpoints[Path]>(
       path: Path,
-      optionsOrParams?: { withResponse?: boolean } | ${match(ctx.runtime)
-        .with("zod", "yup", () => infer(`TEndpoint["parameters"]`))
-        .with("arktype", "io-ts", "typebox", "valibot", () => infer(`TEndpoint`) + `["parameters"]`)
-        .otherwise(() => `TEndpoint["parameters"]`)},
-      ...params: any[]
+      ...params: MaybeOptionalArg<any>
     ): Promise<any> {
-      const hasWithResponse = optionsOrParams && typeof optionsOrParams === 'object' && 'withResponse' in optionsOrParams;
-      const requestParams = hasWithResponse ? params[0] : optionsOrParams;
+      const requestParams = params[0];
+      const withResponse = requestParams?.withResponse;
 
-      if (hasWithResponse && optionsOrParams.withResponse) {
-        return this.fetcher("${method}", this.baseUrl + path, requestParams)
+      // Remove withResponse from params before passing to fetcher
+      const { withResponse: _, ...fetchParams } = requestParams || {};
+
+      if (withResponse) {
+        return this.fetcher("${method}", this.baseUrl + path, Object.keys(fetchParams).length ? fetchParams : undefined)
           .then(async (response) => {
             const data = await this.parseResponse(response);
             if (response.ok) {
@@ -476,7 +486,7 @@ export function createApiClient(fetcher: Fetcher, baseUrl?: string) {
  api.put("/users/:id", { path: { id: 1 }, body: { name: "John" } }).then((user) => console.log(user));
 
  // With error handling
- const result = await api.get("/users/{id}", { withResponse: true }, { path: { id: "123" } });
+ const result = await api.get("/users/{id}", { path: { id: "123" }, withResponse: true });
  if (result.ok) {
    console.log(result.data);
  } else {