Fix type discrimination for non-overlapping content types (#1610)

* Add a failing type test for `openapi-fetch`

* Actually fix the issue

* Fix lint errors and add a changeset

Author: illright

.changeset/gold-worms-wave.md

@@ -0,0 +1,6 @@
+---
+"openapi-typescript-helpers": patch
+"openapi-fetch": patch
+---
+
+Fix data/error discrimination when there are empty-body errors

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

@@ -1,6 +1,7 @@
 import type {
   ErrorResponse,
   FilterKeys,
+  GetValueWithDefault,
   HasRequiredKeys,
   HttpMethod,
   MediaType,
@@ -114,15 +115,23 @@ 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

@@ -0,0 +1,30 @@
+import { test, expectTypeOf } from "vitest";
+
+import createClient from "../src/index.js";
+import type { paths } from "./fixtures/api.js";
+
+const { GET } = createClient<paths>();
+
+interface Blogpost {
+  title: string;
+  body: string;
+  publish_date?: number | undefined;
+}
+
+// This is a type test that will not be executed
+// eslint-disable-next-line vitest/expect-expect
+test("the error type works properly", async () => {
+  const value = await GET("/blogposts");
+
+  if (value.data) {
+    expectTypeOf(value.data).toEqualTypeOf<Array<Blogpost>>();
+  } else {
+    expectTypeOf(value.data).toBeUndefined();
+    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") */