@hey-api/openapi-ts 0.96.1 → 0.97.1

package/dist/clients/ky/client.ts

@@ -1,10 +1,10 @@
-import type { HTTPError, Options as KyOptions } from 'ky';
-import ky from 'ky';
+import type { KyResponse, Options as KyOptions } from 'ky';
+import ky, { isHTTPError } from 'ky';
 
 import { createSseClient } from '../core/serverSentEvents';
 import type { HttpMethod } from '../core/types';
 import { getValidRequestBody } from '../core/utils';
-import type { Client, Config, RequestOptions, ResolvedRequestOptions, RetryOptions } from './types';
+import type { Client, Config, RequestOptions, ResolvedRequestOptions } from './types';
 import type { Middleware } from './utils';
 import {
   buildUrl,
@@ -41,6 +41,11 @@ export const createClient = (config: Config = {}): Client => {
       ...options,
       headers: mergeHeaders(_config.headers, options.headers),
       ky: options.ky ?? _config.ky ?? ky,
+      // deep merge kyOptions to ensure base _config is being respected
+      kyOptions: {
+        ..._config.kyOptions,
+        ...options.kyOptions,
+      },
       serializedBody: undefined as string | undefined,
     };
 
@@ -95,7 +100,7 @@ export const createClient = (config: Config = {}): Client => {
 
     for (const fn of interceptorsMiddleware.error.fns) {
       if (fn) {
-        finalError = (await fn(error, response, request, opts)) as string;
+        finalError = (await fn(finalError, response, request, opts)) as string;
       }
     }
 
@@ -114,161 +119,192 @@ export const createClient = (config: Config = {}): Client => {
   };
 
   const request: Client['request'] = async (options) => {
-    const { opts, url } = await beforeRequest(options);
+    const throwOnError = options.throwOnError ?? _config.throwOnError;
+    const responseStyle = options.responseStyle ?? _config.responseStyle;
 
-    const kyInstance = opts.ky!;
-
-    const validBody = getValidRequestBody(opts);
-
-    const kyOptions: KyOptions = {
-      body: validBody as BodyInit,
-      cache: opts.cache,
-      credentials: opts.credentials,
-      headers: opts.headers,
-      integrity: opts.integrity,
-      keepalive: opts.keepalive,
-      method: opts.method as KyOptions['method'],
-      mode: opts.mode,
-      redirect: 'follow',
-      referrer: opts.referrer,
-      referrerPolicy: opts.referrerPolicy,
-      signal: opts.signal,
-      throwHttpErrors: opts.throwOnError ?? false,
-      timeout: opts.timeout,
-      ...opts.kyOptions,
-    };
+    let request: Request | undefined;
+    let response: KyResponse | undefined;
+    let errorInterceptorsInvoked = false;
 
-    if (opts.retry && typeof opts.retry === 'object') {
-      const retryOpts = opts.retry as RetryOptions;
-      kyOptions.retry = {
-        limit: retryOpts.limit ?? 2,
-        methods: retryOpts.methods as Array<
-          'get' | 'post' | 'put' | 'patch' | 'head' | 'delete' | 'options' | 'trace'
-        >,
-        statusCodes: retryOpts.statusCodes,
+    try {
+      const { opts, url } = await beforeRequest(options);
+
+      const kyInstance = opts.ky!;
+
+      const validBody = getValidRequestBody(opts);
+
+      const kyOptions: KyOptions = {
+        body: validBody as BodyInit,
+        ...(opts.cache !== undefined ? { cache: opts.cache } : {}),
+        ...(opts.credentials !== undefined ? { credentials: opts.credentials } : {}),
+        ...(opts.headers !== undefined ? { headers: opts.headers } : {}),
+        ...(opts.integrity !== undefined ? { integrity: opts.integrity } : {}),
+        ...(opts.keepalive !== undefined ? { keepalive: opts.keepalive } : {}),
+        ...(opts.method !== undefined ? { method: opts.method } : {}),
+        ...(opts.mode !== undefined ? { mode: opts.mode } : {}),
+        redirect: opts.redirect ?? 'follow',
+        ...(opts.referrer !== undefined ? { referrer: opts.referrer } : {}),
+        ...(opts.referrerPolicy !== undefined ? { referrerPolicy: opts.referrerPolicy } : {}),
+        ...(opts.signal !== undefined ? { signal: opts.signal } : {}),
+        throwHttpErrors: opts.throwOnError ?? false,
+        ...(opts.timeout !== undefined ? { timeout: opts.timeout } : {}),
+        ...opts.kyOptions,
+        retry: opts.retry ?? opts.kyOptions?.retry ?? 2,
       };
-    }
 
-    let request = new Request(url, {
-      body: kyOptions.body as BodyInit,
-      headers: kyOptions.headers as HeadersInit,
-      method: kyOptions.method,
-    });
+      request = new Request(url, {
+        body: kyOptions.body,
+        headers: kyOptions.headers as HeadersInit,
+        method: kyOptions.method,
+      });
 
-    for (const fn of interceptors.request.fns) {
-      if (fn) {
-        request = await fn(request, opts);
+      for (const fn of interceptors.request.fns) {
+        if (fn) {
+          request = await fn(request, opts);
+        }
       }
-    }
 
-    let response: Response;
+      try {
+        response = await kyInstance(request, kyOptions);
+      } catch (error) {
+        if (isHTTPError(error)) {
+          response = error.response;
 
-    try {
-      response = await kyInstance(request, kyOptions);
-    } catch (error) {
-      if (error && typeof error === 'object' && 'response' in error) {
-        const httpError = error as HTTPError;
-        response = httpError.response;
-
-        for (const fn of interceptors.response.fns) {
-          if (fn) {
-            response = await fn(response, request, opts);
+          for (const fn of interceptors.response.fns) {
+            if (fn) {
+              response = await fn(response, request, opts);
+            }
           }
+
+          // parseErrorResponse will run error interceptors, and re-throw when
+          // throwOnError is true, which bubbles already intercepted error to
+          // outer catch. With this flag, we can avoid outer catch running interceptors again
+          errorInterceptorsInvoked = true;
+          return parseErrorResponse(response, request, opts, interceptors);
         }
 
-        return parseErrorResponse(response, request, opts, interceptors);
+        throw error;
       }
 
-      throw error;
-    }
-
-    for (const fn of interceptors.response.fns) {
-      if (fn) {
-        response = await fn(response, request, opts);
+      for (const fn of interceptors.response.fns) {
+        if (fn) {
+          response = await fn(response, request, opts);
+        }
       }
-    }
 
-    const result = {
-      request,
-      response,
-    };
+      const result = {
+        request,
+        response,
+      };
 
-    if (response.ok) {
-      const parseAs =
-        (opts.parseAs === 'auto'
-          ? getParseAs(response.headers.get('Content-Type'))
-          : opts.parseAs) ?? 'json';
+      if (response.ok) {
+        const parseAs =
+          (opts.parseAs === 'auto'
+            ? getParseAs(response.headers.get('Content-Type'))
+            : opts.parseAs) ?? 'json';
+
+        if (response.status === 204 || response.headers.get('Content-Length') === '0') {
+          let emptyData: any;
+          switch (parseAs) {
+            case 'arrayBuffer':
+            case 'blob':
+            case 'text':
+              emptyData = await response[parseAs]();
+              break;
+            case 'formData':
+              emptyData = new FormData();
+              break;
+            case 'stream':
+              emptyData = response.body;
+              break;
+            case 'json':
+            default:
+              emptyData = {};
+              break;
+          }
+          return opts.responseStyle === 'data'
+            ? emptyData
+            : {
+                data: emptyData,
+                ...result,
+              };
+        }
 
-      if (response.status === 204 || response.headers.get('Content-Length') === '0') {
-        let emptyData: any;
+        let data: any;
         switch (parseAs) {
           case 'arrayBuffer':
           case 'blob':
+          case 'formData':
           case 'text':
-            emptyData = await response[parseAs]();
+            data = await response[parseAs]();
             break;
-          case 'formData':
-            emptyData = new FormData();
+          case 'json': {
+            // Some servers return 200 with no Content-Length and empty body.
+            // response.json() would throw; read as text and parse if non-empty.
+            const text = await response.text();
+            data = text ? JSON.parse(text) : {};
             break;
+          }
           case 'stream':
-            emptyData = response.body;
-            break;
-          case 'json':
-          default:
-            emptyData = {};
-            break;
+            return opts.responseStyle === 'data'
+              ? response.body
+              : {
+                  data: response.body,
+                  ...result,
+                };
         }
+
+        if (parseAs === 'json') {
+          if (opts.responseValidator) {
+            await opts.responseValidator(data);
+          }
+
+          if (opts.responseTransformer) {
+            data = await opts.responseTransformer(data);
+          }
+        }
+
         return opts.responseStyle === 'data'
-          ? emptyData
+          ? data
           : {
-              data: emptyData,
+              data,
               ...result,
             };
       }
 
-      let data: any;
-      switch (parseAs) {
-        case 'arrayBuffer':
-        case 'blob':
-        case 'formData':
-        case 'text':
-          data = await response[parseAs]();
-          break;
-        case 'json': {
-          // Some servers return 200 with no Content-Length and empty body.
-          // response.json() would throw; read as text and parse if non-empty.
-          const text = await response.text();
-          data = text ? JSON.parse(text) : {};
-          break;
-        }
-        case 'stream':
-          return opts.responseStyle === 'data'
-            ? response.body
-            : {
-                data: response.body,
-                ...result,
-              };
-      }
+      // parseErrorResponse will run error interceptors, and re-throw when
+      // throwOnError is true, which bubbles already intercepted error to
+      // outer catch. With this flag, we can avoid outer catch running interceptors again
+      errorInterceptorsInvoked = true;
+      return parseErrorResponse(response, request, opts, interceptors);
+    } catch (error) {
+      let finalError = error;
 
-      if (parseAs === 'json') {
-        if (opts.responseValidator) {
-          await opts.responseValidator(data);
+      // error may already be processed by parseErrorResponse, in this case
+      // we can skip running interceptors again
+      if (!errorInterceptorsInvoked) {
+        // run error interceptors for errors not already handled by parseErrorResponse
+        for (const fn of interceptors.error.fns) {
+          if (fn) {
+            finalError = await fn(finalError, response, request, options as ResolvedRequestOptions);
+          }
         }
 
-        if (opts.responseTransformer) {
-          data = await opts.responseTransformer(data);
-        }
+        finalError = finalError || ({} as string);
       }
 
-      return opts.responseStyle === 'data'
-        ? data
+      if (throwOnError) {
+        throw finalError;
+      }
+
+      return responseStyle === 'data'
+        ? undefined
         : {
-            data,
-            ...result,
+            error: finalError,
+            request,
+            response,
           };
     }
-
-    return parseErrorResponse(response, request, opts, interceptors);
   };
 
   const makeMethodFn = (method: Uppercase<HttpMethod>) => (options: RequestOptions) =>
@@ -280,7 +316,6 @@ export const createClient = (config: Config = {}): Client => {
       ...opts,
       body: opts.body as BodyInit | null | undefined,
       fetch: globalThis.fetch,
-      headers: opts.headers as unknown as Record<string, string>,
       method,
       onRequest: async (url, init) => {
         let request = new Request(url, init);

package/dist/clients/ky/index.ts

@@ -18,7 +18,6 @@ export type {
   RequestResult,
   ResolvedRequestOptions,
   ResponseStyle,
-  RetryOptions,
   TDataShape,
 } from './types';
 export { createConfig, mergeHeaders } from './utils';

package/dist/clients/ky/types.ts

@@ -11,30 +11,22 @@ import type { Middleware } from './utils';
 
 export type ResponseStyle = 'data' | 'fields';
 
-export interface RetryOptions {
-  /**
-   * Maximum number of retry attempts
-   *
-   * @default 2
-   */
-  limit?: number;
-  /**
-   * HTTP methods to retry
-   *
-   * @default ['get', 'put', 'head', 'delete', 'options', 'trace']
-   */
-  methods?: Array<'get' | 'post' | 'put' | 'delete' | 'patch' | 'head' | 'options' | 'trace'>;
-  /**
-   * HTTP status codes to retry
-   *
-   * @default [408, 413, 429, 500, 502, 503, 504]
-   */
-  statusCodes?: number[];
-}
-
 export interface Config<T extends ClientOptions = ClientOptions>
   extends
-    Omit<KyOptions, 'body' | 'headers' | 'method' | 'prefixUrl' | 'retry' | 'throwHttpErrors'>,
+    Pick<
+      KyOptions,
+      | 'cache'
+      | 'credentials'
+      | 'retry'
+      | 'signal'
+      | 'integrity'
+      | 'keepalive'
+      | 'mode'
+      | 'redirect'
+      | 'referrer'
+      | 'referrerPolicy'
+      | 'timeout'
+    >,
     CoreConfig {
   /**
    * Base URL for all requests made by this client.
@@ -43,6 +35,10 @@ export interface Config<T extends ClientOptions = ClientOptions>
   /**
    * Ky instance to use. You can use this option to provide a custom
    * ky instance.
+   *
+   * Note that the `prefixUrl` of your ky instance will be ignored, as we
+   * will always build the full URL and pass it to your ky instance. You
+   * should configure `baseUrl` instead.
    */
   ky?: typeof ky;
   /**
@@ -65,22 +61,12 @@ export interface Config<T extends ClientOptions = ClientOptions>
    * @default 'fields'
    */
   responseStyle?: ResponseStyle;
-  /**
-   * Retry configuration
-   */
-  retry?: RetryOptions;
   /**
    * Throw an error instead of returning it in the response?
    *
    * @default false
    */
   throwOnError?: T['throwOnError'];
-  /**
-   * Request timeout in milliseconds
-   *
-   * @default 10000
-   */
-  timeout?: number;
 }
 
 export interface RequestOptions<
@@ -157,8 +143,10 @@ export type RequestResult<
                 error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
               }
           ) & {
-            request: Request;
-            response: Response;
+            /** request may be undefined, because error may be from building the request object itself */
+            request?: Request;
+            /** response may be undefined due to a network error where no response object is produced */
+            response?: Response;
           }
     >;
 

package/dist/clients/ky/utils.ts

@@ -212,8 +212,10 @@ export const mergeHeaders = (
 
 type ErrInterceptor<Err, Res, Req, Options> = (
   error: Err,
-  response: Res,
-  request: Req,
+  /** response may be undefined due to a network error where no response object is produced */
+  response: Res | undefined,
+  /** request may be undefined, because error may be from building the request object itself */
+  request: Req | undefined,
   options: Options,
 ) => Err | Promise<Err>;