Merge pull request #2710 from hey-api/copilot/fix-a01977c0-ddcf-4172-81f2-12f0dff81913

Author: mrlubos

.changeset/breezy-dodos-jog.md

@@ -0,0 +1,5 @@
+---
+"@hey-api/openapi-ts": patch
+---
+
+fix(client-ofetch): add missing credentials property support

examples/openapi-ts-ofetch/src/client/client.gen.ts

@@ -1,12 +1,12 @@
 // This file is auto-generated by @hey-api/openapi-ts
 
 import {
-  type ClientOptions as DefaultClientOptions,
+  type ClientOptions,
   type Config,
   createClient,
   createConfig,
 } from './client';
-import type { ClientOptions } from './types.gen';
+import type { ClientOptions as ClientOptions2 } from './types.gen';
 
 /**
  * The `createClientConfig()` function will be called on client initialization
@@ -16,13 +16,12 @@ import type { ClientOptions } from './types.gen';
  * `setConfig()`. This is useful for example if you're using Next.js
  * to ensure your client always has the correct values.
  */
-export type CreateClientConfig<T extends DefaultClientOptions = ClientOptions> =
-  (
-    override?: Config<DefaultClientOptions & T>,
-  ) => Config<Required<DefaultClientOptions> & T>;
+export type CreateClientConfig<T extends ClientOptions = ClientOptions2> = (
+  override?: Config<ClientOptions & T>,
+) => Config<Required<ClientOptions> & T>;
 
 export const client = createClient(
-  createConfig<ClientOptions>({
+  createConfig<ClientOptions2>({
     baseUrl: 'https://petstore3.swagger.io/api/v3',
   }),
 );

examples/openapi-ts-ofetch/src/client/client/client.gen.ts

@@ -28,7 +28,7 @@ import {
 } from './utils.gen';
 
 type ReqInit = Omit<RequestInit, 'body' | 'headers'> & {
-  body?: any;
+  body?: BodyInit | null | undefined;
   headers: ReturnType<typeof mergeHeaders>;
 };
 
@@ -49,7 +49,8 @@ export const createClient = (config: Config = {}): Client => {
     ResolvedRequestOptions
   >();
 
-  const beforeRequest = async (options: RequestOptions) => {
+  // precompute serialized / network body
+  const resolveOptions = async (options: RequestOptions) => {
     const opts = {
       ..._config,
       ...options,
@@ -72,12 +73,44 @@ export const createClient = (config: Config = {}): Client => {
       opts.serializedBody = opts.bodySerializer(opts.body);
     }
 
-    // remove Content-Type header if body is empty to avoid sending invalid requests
+    // remove Content-Type if body is empty to avoid invalid requests
     if (opts.body === undefined || opts.serializedBody === '') {
       opts.headers.delete('Content-Type');
     }
 
-    // Precompute network body for retries and consistent handling
+    // if a raw body is provided (no serializer), adjust Content-Type only when it
+    // equals the default JSON value to better match the concrete body type
+    if (
+      opts.body !== undefined &&
+      opts.bodySerializer === null &&
+      (opts.headers.get('Content-Type') || '').toLowerCase() ===
+        'application/json'
+    ) {
+      const b: unknown = opts.body;
+      if (typeof FormData !== 'undefined' && b instanceof FormData) {
+        // let the runtime set the multipart boundary
+        opts.headers.delete('Content-Type');
+      } else if (
+        typeof URLSearchParams !== 'undefined' &&
+        b instanceof URLSearchParams
+      ) {
+        // standard urlencoded content type (+ charset)
+        opts.headers.set(
+          'Content-Type',
+          'application/x-www-form-urlencoded;charset=UTF-8',
+        );
+      } else if (typeof Blob !== 'undefined' && b instanceof Blob) {
+        const t = b.type?.trim();
+        if (t) {
+          opts.headers.set('Content-Type', t);
+        } else {
+          // unknown blob type: avoid sending a misleading JSON header
+          opts.headers.delete('Content-Type');
+        }
+      }
+    }
+
+    // precompute network body (stability for retries and interceptors)
     const networkBody = getValidRequestBody(opts) as
       | RequestInit['body']
       | null
@@ -88,20 +121,52 @@ export const createClient = (config: Config = {}): Client => {
     return { networkBody, opts, url };
   };
 
+  // apply request interceptors and mirror header/method/signal back to opts
+  const applyRequestInterceptors = async (
+    request: Request,
+    opts: ResolvedRequestOptions,
+  ) => {
+    for (const fn of interceptors.request.fns) {
+      if (fn) {
+        request = await fn(request, opts);
+      }
+    }
+    // reflect interceptor changes into opts used by the network layer
+    opts.headers = request.headers;
+    opts.method = request.method as Uppercase<HttpMethod>;
+    // ignore request.body changes to avoid turning serialized bodies into streams
+    // body comes only from getValidRequestBody(options)
+    // reflect signal if present
+    opts.signal = (request as any).signal as AbortSignal | undefined;
+    return request;
+  };
+
+  // build ofetch options with stable retry logic based on body repeatability
+  const buildNetworkOptions = (
+    opts: ResolvedRequestOptions,
+    body: BodyInit | null | undefined,
+    responseType: OfetchResponseType | undefined,
+  ) => {
+    const effectiveRetry = isRepeatableBody(body)
+      ? (opts.retry as any)
+      : (0 as any);
+    return buildOfetchOptions(opts, body, responseType, effectiveRetry);
+  };
+
   const request: Client['request'] = async (options) => {
     const {
       networkBody: initialNetworkBody,
       opts,
       url,
-    } = await beforeRequest(options as any);
-    // Compute response type mapping once
+    } = await resolveOptions(options as any);
+    // map parseAs -> ofetch responseType once per request
     const ofetchResponseType: OfetchResponseType | undefined =
       mapParseAsToResponseType(opts.parseAs, opts.responseType);
 
     const $ofetch = opts.ofetch ?? ofetch;
 
-    // Always create Request pre-network (align with client-fetch)
-    let networkBody = initialNetworkBody;
+    // create Request before network to run middleware consistently
+    const networkBody = initialNetworkBody;
     const requestInit: ReqInit = {
       body: networkBody,
       headers: opts.headers as Headers,
@@ -111,37 +176,14 @@ export const createClient = (config: Config = {}): Client => {
     };
     let request = new Request(url, requestInit);
 
-    for (const fn of interceptors.request.fns) {
-      if (fn) {
-        request = await fn(request, opts);
-      }
-    }
-
-    // Reflect any interceptor changes into opts used for network and downstream
-    opts.headers = request.headers;
-    opts.method = request.method as Uppercase<HttpMethod>;
-    // Attempt to reflect possible signal/body changes (safely)
-
-    const reqBody = (request as any).body as unknown;
-    let effectiveRetry = opts.retry;
-    if (reqBody !== undefined && reqBody !== null) {
-      if (isRepeatableBody(reqBody)) {
-        networkBody = reqBody as BodyInit;
-      } else {
-        networkBody = reqBody as BodyInit;
-        // Disable retries for non-repeatable bodies
-        effectiveRetry = 0 as any;
-      }
-    }
-
-    opts.signal = (request as any).signal as AbortSignal | undefined;
+    request = await applyRequestInterceptors(request, opts);
     const finalUrl = request.url;
 
-    // Build ofetch options and perform the request
-    const responseOptions = buildOfetchOptions(
+    // build ofetch options and perform the request (.raw keeps the Response)
+    const responseOptions = buildNetworkOptions(
       opts as ResolvedRequestOptions,
-      networkBody ?? undefined,
-      effectiveRetry as any,
+      networkBody,
+      ofetchResponseType,
     );
 
     let response = await $ofetch.raw(finalUrl, responseOptions);
@@ -167,7 +209,7 @@ export const createClient = (config: Config = {}): Client => {
       }
     }
 
-    // Ensure error is never undefined after interceptors
+    // ensure error is never undefined after interceptors
     finalError = (finalError as any) || ({} as string);
 
     if (opts.throwOnError) {
@@ -183,21 +225,17 @@ export const createClient = (config: Config = {}): Client => {
 
   const makeSseFn =
     (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
-      const { networkBody, opts, url } = await beforeRequest(options);
+      const { networkBody, opts, url } = await resolveOptions(options);
       const optsForSse: any = { ...opts };
-      delete optsForSse.body;
+      delete optsForSse.body; // body is provided via serializedBody below
       return createSseClient({
         ...optsForSse,
         fetch: opts.fetch,
         headers: opts.headers as Headers,
         method,
         onRequest: async (url, init) => {
           let request = new Request(url, init);
-          for (const fn of interceptors.request.fns) {
-            if (fn) {
-              request = await fn(request, opts);
-            }
-          }
+          request = await applyRequestInterceptors(request, opts);
           return request;
         },
         serializedBody: networkBody as BodyInit | null | undefined,

examples/openapi-ts-ofetch/src/client/client/types.gen.ts

@@ -22,15 +22,31 @@ export type ResponseStyle = 'data' | 'fields';
 export interface Config<T extends ClientOptions = ClientOptions>
   extends Omit<RequestInit, 'body' | 'headers' | 'method'>,
     CoreConfig {
+  /**
+   * HTTP(S) agent configuration (Node.js only). Passed through to ofetch.
+   */
   agent?: OfetchOptions['agent'];
   /**
    * Base URL for all requests made by this client.
    */
   baseUrl?: T['baseUrl'];
-  /** Node-only proxy/agent options */
+  /**
+   * Node-only proxy/agent options.
+   */
   dispatcher?: OfetchOptions['dispatcher'];
-  /** Optional fetch instance used for SSE streaming */
+  /**
+   * Fetch API implementation. Used for SSE streaming. You can use this option
+   * to provide a custom fetch instance.
+   *
+   * @default globalThis.fetch
+   */
   fetch?: typeof fetch;
+  /**
+   * Controls the native ofetch behaviour that throws `FetchError` when
+   * `response.ok === false`. We default to suppressing it to match the fetch
+   * client semantics and let `throwOnError` drive the outcome.
+   */
+  ignoreResponseError?: OfetchOptions['ignoreResponseError'];
   // No custom fetch option: provide custom instance via `ofetch` instead
   /**
    * Please don't use the Fetch client for Next.js applications. The `next`
@@ -44,10 +60,23 @@ export interface Config<T extends ClientOptions = ClientOptions>
    * be used for requests instead of the default `ofetch` export.
    */
   ofetch?: typeof ofetch;
-  /** ofetch interceptors and runtime options */
+  /**
+   * ofetch hook called before a request is sent.
+   */
   onRequest?: OfetchOptions['onRequest'];
+  /**
+   * ofetch hook called when a request fails before receiving a response
+   * (e.g., network errors or aborted requests).
+   */
   onRequestError?: OfetchOptions['onRequestError'];
+  /**
+   * ofetch hook called after a successful response is received and parsed.
+   */
   onResponse?: OfetchOptions['onResponse'];
+  /**
+   * ofetch hook called when the response indicates an error (non-ok status)
+   * or when response parsing fails.
+   */
   onResponseError?: OfetchOptions['onResponseError'];
   /**
    * Return the response data parsed in a specified format. By default, `auto`
@@ -82,7 +111,13 @@ export interface Config<T extends ClientOptions = ClientOptions>
    * Automatically retry failed requests.
    */
   retry?: OfetchOptions['retry'];
+  /**
+   * Delay (in ms) between retry attempts.
+   */
   retryDelay?: OfetchOptions['retryDelay'];
+  /**
+   * HTTP status codes that should trigger a retry.
+   */
   retryStatusCodes?: OfetchOptions['retryStatusCodes'];
   /**
    * Throw an error instead of returning it in the response?

examples/openapi-ts-ofetch/src/client/client/utils.gen.ts

@@ -316,34 +316,34 @@ export const wrapErrorReturn = <E>(
 export const buildOfetchOptions = (
   opts: ResolvedRequestOptions,
   body: BodyInit | null | undefined,
+  responseType: OfetchResponseType | undefined,
   retryOverride?: OfetchOptions['retry'],
-): OfetchOptions => {
-  const responseType = mapParseAsToResponseType(
-    opts.parseAs,
-    opts.responseType,
-  );
-  return {
+): OfetchOptions =>
+  ({
     agent: opts.agent as OfetchOptions['agent'],
-    body: body as any,
+    body,
+    credentials: opts.credentials as OfetchOptions['credentials'],
     dispatcher: opts.dispatcher as OfetchOptions['dispatcher'],
     headers: opts.headers as Headers,
+    ignoreResponseError:
+      (opts.ignoreResponseError as OfetchOptions['ignoreResponseError']) ??
+      true,
     method: opts.method,
     onRequest: opts.onRequest as OfetchOptions['onRequest'],
     onRequestError: opts.onRequestError as OfetchOptions['onRequestError'],
     onResponse: opts.onResponse as OfetchOptions['onResponse'],
     onResponseError: opts.onResponseError as OfetchOptions['onResponseError'],
     parseResponse: opts.parseResponse as OfetchOptions['parseResponse'],
-    query: undefined, // URL already includes query
+    // URL already includes query
+    query: undefined,
     responseType,
-    retry: (retryOverride ??
-      (opts.retry as OfetchOptions['retry'])) as OfetchOptions['retry'],
+    retry: retryOverride ?? (opts.retry as OfetchOptions['retry']),
     retryDelay: opts.retryDelay as OfetchOptions['retryDelay'],
     retryStatusCodes:
       opts.retryStatusCodes as OfetchOptions['retryStatusCodes'],
     signal: opts.signal,
     timeout: opts.timeout as number | undefined,
-  } as OfetchOptions;
-};
+  }) as OfetchOptions;
 
 /**
  * Parse a successful response, handling empty bodies and stream cases.
@@ -382,17 +382,27 @@ export const parseSuccess = async (
     }
   }
 
-  // Prefer ofetch-populated data
+  // Prefer ofetch-populated data unless we explicitly need raw `formData`
   let data: unknown = (response as any)._data;
-  if (typeof data === 'undefined') {
+  if (inferredParseAs === 'formData' || typeof data === 'undefined') {
     switch (inferredParseAs) {
       case 'arrayBuffer':
       case 'blob':
       case 'formData':
-      case 'json':
       case 'text':
         data = await (response as any)[inferredParseAs]();
         break;
+      case 'json': {
+        // Some servers return 200 with no Content-Length and empty body.
+        // response.json() would throw; detect empty via clone().text() first.
+        const txt = await response.clone().text();
+        if (!txt) {
+          data = {};
+        } else {
+          data = await (response as any).json();
+        }
+        break;
+      }
       case 'stream':
         return response.body;
     }
@@ -526,6 +536,7 @@ export const createConfig = <T extends ClientOptions = ClientOptions>(
 ): Config<Omit<ClientOptions, keyof T> & T> => ({
   ...jsonBodySerializer,
   headers: defaultHeaders,
+  ignoreResponseError: true,
   parseAs: 'auto',
   querySerializer: defaultQuerySerializer,
   ...override,