openapi-typesafe-fetch 1.0.0-rc.11 → 1.0.0-rc.12

package/CHANGELOG.md

@@ -2,6 +2,21 @@
 
 This package is a fork of `openapi-fetch`. The entries above `0.17.0` are releases of openapi-typesafe-fetch; `0.17.0` and the entries below it are the upstream history up to the fork point (upstream commit `d46a319a`), with `openapi-fetch` versions.
 
+## 1.0.0-rc.12
+
+### Patch Changes
+
+- [#136](https://github.com/openapi-typesafe/openapi-typesafe/pull/136) [`68ce29a`](https://github.com/openapi-typesafe/openapi-typesafe/commit/68ce29ad4b8f8490d38990af62bbc830b54df015) Thanks [@fedorello](https://github.com/fedorello)! - A wrapper generic in the path that sets `parseAs`, such as
+  `client.GET(path, { ...init, parseAs: "text" })` or an `init` typed
+  `FetchOptions<…> & { parseAs: "text" }`, types `data` as the body of that `parseAs` again
+  (`string` for `"text"`), as openapi-fetch does. Before, it was the text or any JSON body of the
+  paths, so assigning it to `string | undefined` failed. Each member of a union of options now
+  types its own data: `{ parseAs: ParseAs } | undefined` gives every body, as in openapi-fetch.
+
+- [#136](https://github.com/openapi-typesafe/openapi-typesafe/pull/136) [`68ce29a`](https://github.com/openapi-typesafe/openapi-typesafe/commit/68ce29ad4b8f8490d38990af62bbc830b54df015) Thanks [@fedorello](https://github.com/fedorello)! - `SuccessResponseJSON` and `ErrorResponseJSON` of a union of operations are the union of each
+  operation's JSON bodies again. Before, only the status codes the operations share counted, so
+  `ErrorResponseJSON<OpA | OpB>` could gain a `string` that neither operation has alone.
+
 ## 1.0.0-rc.11
 
 ### Patch Changes

package/dist/helpers.d.cts

@@ -307,15 +307,23 @@ type JSONMediaType = JSONMediaPattern | JSONMediaRange;
  * parameters, which do not count.
  */
 type IsJSONMediaType<Key> = Key extends string ? IsJSONMediaPattern<Key> extends true ? true : MediaSubtype<Lowercase<Key>> extends "*" ? true : false : false;
-/** Return first JSON-like 2XX response from a path + HTTP method */
-type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = SuccessResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>>;
-/** Return JSON-like 1XX, 3XX, 4XX, 5XX and `default` responses from a path + HTTP method */
-type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = ErrorResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>>;
-/**
- * The media types of the responses `T` that may hold JSON (`IsJSONMediaType`), for the JSON
- * helpers to pick by: their keys, as `JSONMediaType` cannot leave out a `json` in parameters. A
- * content map with an index signature has no such key, so it gives `JSONMediaType`, which picks
- * the schema of its signature.
+/**
+ * Return first JSON-like 2XX response from a path + HTTP method; for a union of operations, the
+ * union of each one's.
+ */
+type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = PathMethod extends unknown ? SuccessResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>> : never;
+/**
+ * Return JSON-like 1XX, 3XX, 4XX, 5XX and `default` responses from a path + HTTP method; for a
+ * union of operations, the union of each one's.
+ */
+type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = PathMethod extends unknown ? ErrorResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>> : never;
+/**
+ * The media types of the responses `T` (of one operation) that may hold JSON (`IsJSONMediaType`),
+ * for the JSON helpers to pick by: their keys, as `JSONMediaType` cannot leave out a `json` in
+ * parameters. A content map with an index signature has no such key, so it gives
+ * `JSONMediaType`, which picks the schema of its signature. The helpers pick per operation: the
+ * keys of a union of response maps are only the status codes they share, so the media types of
+ * the other statuses were lost, and the media types of one operation could pick in another.
  */
 type JSONMediaKeys<T> = {
     [Status in keyof T]: T[Status] extends {

package/dist/helpers.d.mts

@@ -307,15 +307,23 @@ type JSONMediaType = JSONMediaPattern | JSONMediaRange;
  * parameters, which do not count.
  */
 type IsJSONMediaType<Key> = Key extends string ? IsJSONMediaPattern<Key> extends true ? true : MediaSubtype<Lowercase<Key>> extends "*" ? true : false : false;
-/** Return first JSON-like 2XX response from a path + HTTP method */
-type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = SuccessResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>>;
-/** Return JSON-like 1XX, 3XX, 4XX, 5XX and `default` responses from a path + HTTP method */
-type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = ErrorResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>>;
-/**
- * The media types of the responses `T` that may hold JSON (`IsJSONMediaType`), for the JSON
- * helpers to pick by: their keys, as `JSONMediaType` cannot leave out a `json` in parameters. A
- * content map with an index signature has no such key, so it gives `JSONMediaType`, which picks
- * the schema of its signature.
+/**
+ * Return first JSON-like 2XX response from a path + HTTP method; for a union of operations, the
+ * union of each one's.
+ */
+type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = PathMethod extends unknown ? SuccessResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>> : never;
+/**
+ * Return JSON-like 1XX, 3XX, 4XX, 5XX and `default` responses from a path + HTTP method; for a
+ * union of operations, the union of each one's.
+ */
+type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = PathMethod extends unknown ? ErrorResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>> : never;
+/**
+ * The media types of the responses `T` (of one operation) that may hold JSON (`IsJSONMediaType`),
+ * for the JSON helpers to pick by: their keys, as `JSONMediaType` cannot leave out a `json` in
+ * parameters. A content map with an index signature has no such key, so it gives
+ * `JSONMediaType`, which picks the schema of its signature. The helpers pick per operation: the
+ * keys of a union of response maps are only the status codes they share, so the media types of
+ * the other statuses were lost, and the media types of one operation could pick in another.
  */
 type JSONMediaKeys<T> = {
     [Status in keyof T]: T[Status] extends {

package/dist/helpers.d.ts

@@ -307,15 +307,23 @@ type JSONMediaType = JSONMediaPattern | JSONMediaRange;
  * parameters, which do not count.
  */
 type IsJSONMediaType<Key> = Key extends string ? IsJSONMediaPattern<Key> extends true ? true : MediaSubtype<Lowercase<Key>> extends "*" ? true : false : false;
-/** Return first JSON-like 2XX response from a path + HTTP method */
-type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = SuccessResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>>;
-/** Return JSON-like 1XX, 3XX, 4XX, 5XX and `default` responses from a path + HTTP method */
-type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = ErrorResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>>;
-/**
- * The media types of the responses `T` that may hold JSON (`IsJSONMediaType`), for the JSON
- * helpers to pick by: their keys, as `JSONMediaType` cannot leave out a `json` in parameters. A
- * content map with an index signature has no such key, so it gives `JSONMediaType`, which picks
- * the schema of its signature.
+/**
+ * Return first JSON-like 2XX response from a path + HTTP method; for a union of operations, the
+ * union of each one's.
+ */
+type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = PathMethod extends unknown ? SuccessResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>> : never;
+/**
+ * Return JSON-like 1XX, 3XX, 4XX, 5XX and `default` responses from a path + HTTP method; for a
+ * union of operations, the union of each one's.
+ */
+type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = PathMethod extends unknown ? ErrorResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>> : never;
+/**
+ * The media types of the responses `T` (of one operation) that may hold JSON (`IsJSONMediaType`),
+ * for the JSON helpers to pick by: their keys, as `JSONMediaType` cannot leave out a `json` in
+ * parameters. A content map with an index signature has no such key, so it gives
+ * `JSONMediaType`, which picks the schema of its signature. The helpers pick per operation: the
+ * keys of a union of response maps are only the status codes they share, so the media types of
+ * the other statuses were lost, and the media types of one operation could pick in another.
  */
 type JSONMediaKeys<T> = {
     [Status in keyof T]: T[Status] extends {

package/dist/index.d.cts

@@ -133,13 +133,26 @@ type ParseAs = keyof BodyType;
  * its body, and `undefined` or a left-out `parseAs` is the default `"json"`, as at runtime: a
  * wrapper that passes on `parseAs?: "text"` gets `string | T`, not `T` only. Options without
  * `parseAs`, or whose `parseAs` may be any value (the declared init type, as for a call without
- * options), give `T`, as in openapi-fetch. No `infer`: TypeScript relates a type to a deferred
- * conditional type through both of its branches only when it infers nothing, and generic hooks
- * return the data of a call as this type.
+ * options), give `T`, as in openapi-fetch; each member of a union of options gives its own data.
+ * No `infer`: TypeScript relates a type to a deferred conditional type through both of its
+ * branches only when it infers nothing, and generic hooks return the data of a call as this type.
+ * It distributes over `Options`, as openapi-fetch's does, so the options of a generic call (a
+ * wrapper's `FetchOptions` of a generic path with `parseAs: "text"`) give the data of their
+ * constraint: TypeScript reads a deferred distributive type through its check type's constraint.
  */
-type ParseAsResponse<T, Options> = [MissingParseAsValues<Options>] extends [never]
-  ? T
-  : BodyType<T>[ParseAsValue<ParseAsValues<Options>>];
+type ParseAsResponse<T, Options> = Options extends unknown
+  ? BodyType<T>[ParseAsKey<Options>]
+  : never;
+
+/**
+ * The key of `BodyType` that the options `Options` read the body with. A conditional type of its
+ * own, inside the index: one in the branch of `ParseAsResponse` that picked `T` would be read
+ * through both of its branches while TypeScript reads the constraint above, as `never` fits any
+ * check type, so a generic `parseAs: "text"` gave the JSON body too.
+ */
+type ParseAsKey<Options> = [MissingParseAsValues<Options>] extends [never]
+  ? "json"
+  : ParseAsValue<ParseAsValues<Options>>;
 
 /**
  * The `parseAs` values that `Options` may have; `undefined` when it may be left out. One
@@ -160,8 +173,8 @@ type ParseAsValues<Options> = Options extends unknown
   : never;
 
 /**
- * The `parseAs` values that `Options` cannot have, as `ParseAsValues` reads them. It does not
- * distribute: a union of options cannot have a value only when none of its members can.
+ * The `parseAs` values that the options `Options` (one member of a union) cannot have, as
+ * `ParseAsValues` reads them.
  */
 type MissingParseAsValues<Options> =
   | ([Options] extends [RequiredParseAs] ? undefined : never)

package/dist/index.d.mts

@@ -133,13 +133,26 @@ type ParseAs = keyof BodyType;
  * its body, and `undefined` or a left-out `parseAs` is the default `"json"`, as at runtime: a
  * wrapper that passes on `parseAs?: "text"` gets `string | T`, not `T` only. Options without
  * `parseAs`, or whose `parseAs` may be any value (the declared init type, as for a call without
- * options), give `T`, as in openapi-fetch. No `infer`: TypeScript relates a type to a deferred
- * conditional type through both of its branches only when it infers nothing, and generic hooks
- * return the data of a call as this type.
+ * options), give `T`, as in openapi-fetch; each member of a union of options gives its own data.
+ * No `infer`: TypeScript relates a type to a deferred conditional type through both of its
+ * branches only when it infers nothing, and generic hooks return the data of a call as this type.
+ * It distributes over `Options`, as openapi-fetch's does, so the options of a generic call (a
+ * wrapper's `FetchOptions` of a generic path with `parseAs: "text"`) give the data of their
+ * constraint: TypeScript reads a deferred distributive type through its check type's constraint.
  */
-type ParseAsResponse<T, Options> = [MissingParseAsValues<Options>] extends [never]
-  ? T
-  : BodyType<T>[ParseAsValue<ParseAsValues<Options>>];
+type ParseAsResponse<T, Options> = Options extends unknown
+  ? BodyType<T>[ParseAsKey<Options>]
+  : never;
+
+/**
+ * The key of `BodyType` that the options `Options` read the body with. A conditional type of its
+ * own, inside the index: one in the branch of `ParseAsResponse` that picked `T` would be read
+ * through both of its branches while TypeScript reads the constraint above, as `never` fits any
+ * check type, so a generic `parseAs: "text"` gave the JSON body too.
+ */
+type ParseAsKey<Options> = [MissingParseAsValues<Options>] extends [never]
+  ? "json"
+  : ParseAsValue<ParseAsValues<Options>>;
 
 /**
  * The `parseAs` values that `Options` may have; `undefined` when it may be left out. One
@@ -160,8 +173,8 @@ type ParseAsValues<Options> = Options extends unknown
   : never;
 
 /**
- * The `parseAs` values that `Options` cannot have, as `ParseAsValues` reads them. It does not
- * distribute: a union of options cannot have a value only when none of its members can.
+ * The `parseAs` values that the options `Options` (one member of a union) cannot have, as
+ * `ParseAsValues` reads them.
  */
 type MissingParseAsValues<Options> =
   | ([Options] extends [RequiredParseAs] ? undefined : never)

package/dist/index.d.ts

@@ -133,13 +133,26 @@ type ParseAs = keyof BodyType;
  * its body, and `undefined` or a left-out `parseAs` is the default `"json"`, as at runtime: a
  * wrapper that passes on `parseAs?: "text"` gets `string | T`, not `T` only. Options without
  * `parseAs`, or whose `parseAs` may be any value (the declared init type, as for a call without
- * options), give `T`, as in openapi-fetch. No `infer`: TypeScript relates a type to a deferred
- * conditional type through both of its branches only when it infers nothing, and generic hooks
- * return the data of a call as this type.
+ * options), give `T`, as in openapi-fetch; each member of a union of options gives its own data.
+ * No `infer`: TypeScript relates a type to a deferred conditional type through both of its
+ * branches only when it infers nothing, and generic hooks return the data of a call as this type.
+ * It distributes over `Options`, as openapi-fetch's does, so the options of a generic call (a
+ * wrapper's `FetchOptions` of a generic path with `parseAs: "text"`) give the data of their
+ * constraint: TypeScript reads a deferred distributive type through its check type's constraint.
  */
-type ParseAsResponse<T, Options> = [MissingParseAsValues<Options>] extends [never]
-  ? T
-  : BodyType<T>[ParseAsValue<ParseAsValues<Options>>];
+type ParseAsResponse<T, Options> = Options extends unknown
+  ? BodyType<T>[ParseAsKey<Options>]
+  : never;
+
+/**
+ * The key of `BodyType` that the options `Options` read the body with. A conditional type of its
+ * own, inside the index: one in the branch of `ParseAsResponse` that picked `T` would be read
+ * through both of its branches while TypeScript reads the constraint above, as `never` fits any
+ * check type, so a generic `parseAs: "text"` gave the JSON body too.
+ */
+type ParseAsKey<Options> = [MissingParseAsValues<Options>] extends [never]
+  ? "json"
+  : ParseAsValue<ParseAsValues<Options>>;
 
 /**
  * The `parseAs` values that `Options` may have; `undefined` when it may be left out. One
@@ -160,8 +173,8 @@ type ParseAsValues<Options> = Options extends unknown
   : never;
 
 /**
- * The `parseAs` values that `Options` cannot have, as `ParseAsValues` reads them. It does not
- * distribute: a union of options cannot have a value only when none of its members can.
+ * The `parseAs` values that the options `Options` (one member of a union) cannot have, as
+ * `ParseAsValues` reads them.
  */
 type MissingParseAsValues<Options> =
   | ([Options] extends [RequiredParseAs] ? undefined : never)

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "openapi-typesafe-fetch",
   "description": "Fast, type-safe fetch client for your OpenAPI schema. About 10.5 kB minified, 4 kB gzipped. Works with React, Vue, Svelte, or vanilla JS.",
-  "version": "1.0.0-rc.11",
+  "version": "1.0.0-rc.12",
   "author": {
     "name": "Fedor Chishchin",
     "url": "https://github.com/fedorello"
@@ -67,7 +67,7 @@
     "express": "5.3.0",
     "feature-fetch": "0.1.2",
     "node-forge": "1.4.3",
-    "openapi-typesafe": "^1.0.0-rc.11",
+    "openapi-typesafe": "^1.0.0-rc.12",
     "openapi-typescript-fetch": "2.2.1",
     "typescript": "^6.0.3",
     "undici": "7.30.2",

package/src/helpers.ts

@@ -454,25 +454,33 @@ type IsJSONMediaType<Key> = Key extends string
       : false
   : false;
 
-/** Return first JSON-like 2XX response from a path + HTTP method */
+/**
+ * Return first JSON-like 2XX response from a path + HTTP method; for a union of operations, the
+ * union of each one's.
+ */
 // biome-ignore lint/suspicious/noExplicitAny: unknown rejects the generated interfaces
-export type SuccessResponseJSON<PathMethod extends Record<string | number, any>> = SuccessResponse<
-  ResponseObjectMap<PathMethod>,
-  JSONMediaKeys<ResponseObjectMap<PathMethod>>
->;
+export type SuccessResponseJSON<PathMethod extends Record<string | number, any>> =
+  PathMethod extends unknown
+    ? SuccessResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>>
+    : never;
 
-/** Return JSON-like 1XX, 3XX, 4XX, 5XX and `default` responses from a path + HTTP method */
+/**
+ * Return JSON-like 1XX, 3XX, 4XX, 5XX and `default` responses from a path + HTTP method; for a
+ * union of operations, the union of each one's.
+ */
 // biome-ignore lint/suspicious/noExplicitAny: unknown rejects the generated interfaces
-export type ErrorResponseJSON<PathMethod extends Record<string | number, any>> = ErrorResponse<
-  ResponseObjectMap<PathMethod>,
-  JSONMediaKeys<ResponseObjectMap<PathMethod>>
->;
+export type ErrorResponseJSON<PathMethod extends Record<string | number, any>> =
+  PathMethod extends unknown
+    ? ErrorResponse<ResponseObjectMap<PathMethod>, JSONMediaKeys<ResponseObjectMap<PathMethod>>>
+    : never;
 
 /**
- * The media types of the responses `T` that may hold JSON (`IsJSONMediaType`), for the JSON
- * helpers to pick by: their keys, as `JSONMediaType` cannot leave out a `json` in parameters. A
- * content map with an index signature has no such key, so it gives `JSONMediaType`, which picks
- * the schema of its signature.
+ * The media types of the responses `T` (of one operation) that may hold JSON (`IsJSONMediaType`),
+ * for the JSON helpers to pick by: their keys, as `JSONMediaType` cannot leave out a `json` in
+ * parameters. A content map with an index signature has no such key, so it gives
+ * `JSONMediaType`, which picks the schema of its signature. The helpers pick per operation: the
+ * keys of a union of response maps are only the status codes they share, so the media types of
+ * the other statuses were lost, and the media types of one operation could pick in another.
  */
 type JSONMediaKeys<T> = {
   [Status in keyof T]: T[Status] extends { content: infer Content }

package/src/index.d.ts

@@ -143,13 +143,26 @@ export type ParseAs = keyof BodyType;
  * its body, and `undefined` or a left-out `parseAs` is the default `"json"`, as at runtime: a
  * wrapper that passes on `parseAs?: "text"` gets `string | T`, not `T` only. Options without
  * `parseAs`, or whose `parseAs` may be any value (the declared init type, as for a call without
- * options), give `T`, as in openapi-fetch. No `infer`: TypeScript relates a type to a deferred
- * conditional type through both of its branches only when it infers nothing, and generic hooks
- * return the data of a call as this type.
+ * options), give `T`, as in openapi-fetch; each member of a union of options gives its own data.
+ * No `infer`: TypeScript relates a type to a deferred conditional type through both of its
+ * branches only when it infers nothing, and generic hooks return the data of a call as this type.
+ * It distributes over `Options`, as openapi-fetch's does, so the options of a generic call (a
+ * wrapper's `FetchOptions` of a generic path with `parseAs: "text"`) give the data of their
+ * constraint: TypeScript reads a deferred distributive type through its check type's constraint.
  */
-export type ParseAsResponse<T, Options> = [MissingParseAsValues<Options>] extends [never]
-  ? T
-  : BodyType<T>[ParseAsValue<ParseAsValues<Options>>];
+export type ParseAsResponse<T, Options> = Options extends unknown
+  ? BodyType<T>[ParseAsKey<Options>]
+  : never;
+
+/**
+ * The key of `BodyType` that the options `Options` read the body with. A conditional type of its
+ * own, inside the index: one in the branch of `ParseAsResponse` that picked `T` would be read
+ * through both of its branches while TypeScript reads the constraint above, as `never` fits any
+ * check type, so a generic `parseAs: "text"` gave the JSON body too.
+ */
+type ParseAsKey<Options> = [MissingParseAsValues<Options>] extends [never]
+  ? "json"
+  : ParseAsValue<ParseAsValues<Options>>;
 
 /**
  * The `parseAs` values that `Options` may have; `undefined` when it may be left out. One
@@ -170,8 +183,8 @@ type ParseAsValues<Options> = Options extends unknown
   : never;
 
 /**
- * The `parseAs` values that `Options` cannot have, as `ParseAsValues` reads them. It does not
- * distribute: a union of options cannot have a value only when none of its members can.
+ * The `parseAs` values that the options `Options` (one member of a union) cannot have, as
+ * `ParseAsValues` reads them.
  */
 type MissingParseAsValues<Options> =
   | ([Options] extends [RequiredParseAs] ? undefined : never)