Actually fix the issue

Author: illright

packages/openapi-fetch/src/index.d.ts

@@ -1,6 +1,7 @@
 import type {
   ErrorResponse,
   FilterKeys,
+  GetValueWithDefault,
   HasRequiredKeys,
   HttpMethod,
   MediaType,
@@ -114,15 +115,15 @@ export type FetchOptions<T> = RequestOptions<T> &
 export type FetchResponse<T, O, Media extends MediaType> =
   | {
       data: ParseAsResponse<
-        FilterKeys<SuccessResponse<ResponseObjectMap<T>>, Media>,
+      GetValueWithDefault<SuccessResponse<ResponseObjectMap<T>>, Media, Record<string, never>>,
         O
       >;
       error?: never;
       response: Response;
     }
   | {
       data?: never;
-      error: FilterKeys<ErrorResponse<ResponseObjectMap<T>>, Media>;
+      error: GetValueWithDefault<ErrorResponse<ResponseObjectMap<T>>, Media, Record<string, never>>;
       response: Response;
     };
 

packages/openapi-fetch/test/fixtures/api.d.ts

@@ -24,6 +24,7 @@ export interface paths {
       };
       responses: {
         200: components["responses"]["AllPostsGet"];
+        401: components["responses"]["EmptyError"];
         500: components["responses"]["Error"];
       };
     };
@@ -457,6 +458,10 @@ export interface components {
         "text/html": string;
       };
     };
+    EmptyError: {
+      content: {
+      };
+    };
     Error: {
       content: {
         "application/json": {

packages/openapi-fetch/test/fixtures/api.yaml

@@ -28,6 +28,8 @@ paths:
       responses:
         200:
           $ref: '#/components/responses/AllPostsGet'
+        401:
+          $ref: '#/components/responses/EmptyError'
         500:
           $ref: '#/components/responses/Error'
     put:
@@ -623,6 +625,8 @@ components:
         text/html:
           schema:
             type: string
+    EmptyError:
+      content: {}
     Error:
       content:
         application/json:

packages/openapi-fetch/test/index.test-d.ts

@@ -1,66 +1,24 @@
 import { test, expectTypeOf } from "vitest";
 
 import createClient from "../src/index.js";
+import type { paths } from "./fixtures/api.js";
 
-interface paths {
-  "/": {
-    get: operations["GetObjects"];
-  };
-}
-
-interface operations {
-  GetObjects: {
-    parameters: {};
-    responses: {
-      200: components["responses"]["MultipleObjectsResponse"];
-      401: components["responses"]["Unauthorized"];
-      422: components["responses"]["GenericError"];
-    };
-  };
-}
+const { GET } = createClient<paths>();
 
-interface components {
-  schemas: {
-    Object: {
-      id: string;
-      name: string;
-    };
-    GenericErrorModel: {
-      errors: {
-        body: string[];
-      };
-    };
-  };
-  responses: {
-    MultipleObjectsResponse: {
-      content: {
-        "application/json": {
-          objects: components["schemas"]["Object"][];
-        };
-      };
-    };
-    /** @description Unauthorized */
-    Unauthorized: {
-      content: {};
-    };
-    /** @description Unexpected error */
-    GenericError: {
-      content: {
-        "application/json": components["schemas"]["GenericErrorModel"];
-      };
-    };
-  };
+interface Blogpost {
+  title: string;
+  body: string;
+  publish_date?: number | undefined;
 }
 
-const { GET } = createClient<paths>();
-
 test("the error type works properly", async () => {
-  const value = await GET("/");
+  const value = await GET("/blogposts");
 
   if (value.data) {
-    expectTypeOf(value.data).toEqualTypeOf({ objects: [{ id: "", name: "" }] });
+    expectTypeOf(value.data).toEqualTypeOf<Array<Blogpost>>();
   } else {
     expectTypeOf(value.data).toBeUndefined();
-    expectTypeOf(value.error).toEqualTypeOf({ errors: [""] });
+    expectTypeOf(value.error).extract<{ code: number }>().toEqualTypeOf<{ code: number; message: string }>();
+    expectTypeOf(value.error).exclude<{ code: number }>().toEqualTypeOf<Record<string, never>>();
   }
 });

packages/openapi-typescript-helpers/index.d.ts

@@ -88,6 +88,9 @@ export type RequestBodyJSON<PathMethod> = JSONLike<
 
 /** Find first match of multiple keys */
 export type FilterKeys<Obj, Matchers> = Obj[keyof Obj & Matchers];
+/** Get the type of a value of an input object with a given key. If the key is not found, return a default type. Works with unions of objects too. */
+export type GetValueWithDefault<Obj, KeyPattern, Default> = Obj extends any ? (FilterKeys<Obj, KeyPattern> extends never ? Default : FilterKeys<Obj, KeyPattern>) : never;
+
 /** Return any `[string]/[string]` media type (important because openapi-fetch allows any content response, not just JSON-like) */
 export type MediaType = `${string}/${string}`;
 /** Return any media type containing "json" (works for "application/json", "application/vnd.api+json", "application/vnd.oai.openapi+json") */