@hey-api/openapi-ts 0.96.1 → 0.97.0

package/dist/clients/next/client.ts

@@ -72,131 +72,138 @@ export const createClient = (config: Config = {}): Client => {
 
   // @ts-expect-error
   const request: Client['request'] = async (options) => {
-    const { opts, url } = await beforeRequest(options);
+    const throwOnError = options.throwOnError ?? _config.throwOnError;
+
+    let response: Response | undefined;
+
+    try {
+      const { opts, url } = await beforeRequest(options);
 
-    for (const fn of interceptors.request.fns) {
-      if (fn) {
-        await fn(opts);
+      for (const fn of interceptors.request.fns) {
+        if (fn) {
+          await fn(opts);
+        }
       }
-    }
 
-    // fetch must be assigned here, otherwise it would throw the error:
-    // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
-    const _fetch = opts.fetch!;
-    const requestInit: ReqInit = {
-      ...opts,
-      body: getValidRequestBody(opts),
-    };
+      // fetch must be assigned here, otherwise it would throw the error:
+      // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+      const _fetch = opts.fetch!;
+      const requestInit: ReqInit = {
+        ...opts,
+        body: getValidRequestBody(opts),
+      };
 
-    let response = await _fetch(url, requestInit);
+      response = await _fetch(url, requestInit);
 
-    for (const fn of interceptors.response.fns) {
-      if (fn) {
-        response = await fn(response, opts);
+      for (const fn of interceptors.response.fns) {
+        if (fn) {
+          response = await fn(response, opts);
+        }
       }
-    }
 
-    const result = {
-      response,
-    };
+      const result = {
+        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 {
+            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 {
+              data: response.body,
+              ...result,
+            };
         }
+
+        if (parseAs === 'json') {
+          if (opts.responseValidator) {
+            await opts.responseValidator(data);
+          }
+
+          if (opts.responseTransformer) {
+            data = await opts.responseTransformer(data);
+          }
+        }
+
         return {
-          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 {
-            data: response.body,
-            ...result,
-          };
+      const textError = await response.text();
+      let jsonError: unknown;
+
+      try {
+        jsonError = JSON.parse(textError);
+      } catch {
+        // noop
       }
 
-      if (parseAs === 'json') {
-        if (opts.responseValidator) {
-          await opts.responseValidator(data);
-        }
+      throw jsonError ?? textError;
+    } catch (error) {
+      let finalError = error;
 
-        if (opts.responseTransformer) {
-          data = await opts.responseTransformer(data);
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError = await fn(finalError, response, options as ResolvedRequestOptions);
         }
       }
 
-      return {
-        data,
-        ...result,
-      };
-    }
+      finalError = finalError || {};
 
-    const textError = await response.text();
-    let jsonError: unknown;
-
-    try {
-      jsonError = JSON.parse(textError);
-    } catch {
-      // noop
-    }
-
-    const error = jsonError ?? textError;
-    let finalError = error;
-
-    for (const fn of interceptors.error.fns) {
-      if (fn) {
-        finalError = (await fn(error, response, opts)) as string;
+      if (throwOnError) {
+        throw finalError;
       }
-    }
 
-    finalError = finalError || ({} as string);
-
-    if (opts.throwOnError) {
-      throw finalError;
+      return {
+        error: finalError,
+        response,
+      };
     }
-
-    return {
-      error: finalError,
-      ...result,
-    };
   };
 
   const makeMethodFn = (method: Uppercase<HttpMethod>) => (options: RequestOptions) =>
@@ -207,18 +214,13 @@ export const createClient = (config: Config = {}): Client => {
     return createSseClient({
       ...opts,
       body: opts.body as BodyInit | null | undefined,
-      headers: opts.headers as unknown as Record<string, string>,
       method,
       onRequest: async (url, init) => {
         let request = new Request(url, init);
-        const requestInit = {
-          ...init,
-          method: init.method as Config['method'],
-          url,
-        };
+        const requestInit = { ...init, url };
         for (const fn of interceptors.request.fns) {
           if (fn) {
-            await fn(requestInit as unknown as ResolvedRequestOptions);
+            await fn(requestInit as ResolvedRequestOptions);
             request = new Request(requestInit.url, requestInit);
           }
         }

package/dist/clients/next/types.ts

@@ -97,7 +97,8 @@ export type RequestResult<
             error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
           }
       ) & {
-        response: Response;
+        /** response may be undefined due to a network error where no response object is produced */
+        response?: Response;
       }
     >;
 

package/dist/clients/next/utils.ts

@@ -325,7 +325,8 @@ export const mergeHeaders = (
 
 type ErrInterceptor<Err, Res, Options> = (
   error: Err,
-  response: Res,
+  /** response may be undefined due to a network error where no response object is produced */
+  response: Res | undefined,
   options: Options,
 ) => Err | Promise<Err>;
 

package/dist/clients/ofetch/client.ts

@@ -116,7 +116,7 @@ export const createClient = (config: Config = {}): Client => {
     // 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;
+    opts.signal = request.signal;
 
     // When body is FormData, remove Content-Type header to avoid boundary mismatch.
     // Note: We already delete Content-Type in resolveOptions for FormData, but the
@@ -138,92 +138,102 @@ export const createClient = (config: Config = {}): Client => {
     body: BodyInit | null | undefined,
     responseType: OfetchResponseType | undefined,
   ) => {
-    const effectiveRetry = isRepeatableBody(body) ? (opts.retry as any) : (0 as any);
+    const effectiveRetry = isRepeatableBody(body) ? opts.retry : 0;
     return buildOfetchOptions(opts, body, responseType, effectiveRetry);
   };
 
   const request: Client['request'] = async (options) => {
-    const { networkBody: initialNetworkBody, opts, url } = 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;
-
-    // create Request before network to run middleware consistently
-    const networkBody = initialNetworkBody;
-    const requestInit: ReqInit = {
-      body: networkBody,
-      headers: opts.headers as Headers,
-      method: opts.method,
-      redirect: 'follow',
-      signal: opts.signal,
-    };
-    let request = new Request(url, requestInit);
-
-    request = await applyRequestInterceptors(request, opts, networkBody);
-    const finalUrl = request.url;
-
-    // build ofetch options and perform the request (.raw keeps the Response)
-    const responseOptions = buildNetworkOptions(
-      opts as ResolvedRequestOptions,
-      networkBody,
-      ofetchResponseType,
-    );
+    const throwOnError = options.throwOnError ?? _config.throwOnError;
+    const responseStyle = options.responseStyle ?? _config.responseStyle;
+
+    let request: Request | undefined;
+    let response: Awaited<ReturnType<typeof ofetch.raw>> | undefined;
+
+    try {
+      const {
+        networkBody: initialNetworkBody,
+        opts,
+        url,
+      } = await resolveOptions(options as RequestOptions);
+      // map parseAs -> ofetch responseType once per request
+      const ofetchResponseType: OfetchResponseType | undefined = mapParseAsToResponseType(
+        opts.parseAs,
+        opts.responseType,
+      );
+
+      const $ofetch = opts.ofetch ?? ofetch;
+
+      // create Request before network to run middleware consistently
+      const networkBody = initialNetworkBody;
+      const requestInit: ReqInit = {
+        body: networkBody,
+        headers: opts.headers,
+        method: opts.method,
+        redirect: 'follow',
+        signal: opts.signal,
+      };
+      request = new Request(url, requestInit);
+
+      request = await applyRequestInterceptors(request, opts, networkBody);
+      const finalUrl = request.url;
+
+      // build ofetch options and perform the request (.raw keeps the Response)
+      const responseOptions = buildNetworkOptions(opts, networkBody, ofetchResponseType);
+
+      response = await $ofetch.raw(finalUrl, responseOptions);
+
+      for (const fn of interceptors.response.fns) {
+        if (fn) {
+          response = await fn(response, request, opts);
+        }
+      }
 
-    let response = await $ofetch.raw(finalUrl, responseOptions);
+      const result = { request, response };
 
-    for (const fn of interceptors.response.fns) {
-      if (fn) {
-        response = await fn(response, request, opts);
+      if (response.ok) {
+        const data = await parseSuccess(response, opts, ofetchResponseType);
+        return wrapDataReturn(data, result, opts.responseStyle);
       }
-    }
 
-    const result = { request, response };
+      throw await parseError(response);
+    } catch (error) {
+      let finalError = error;
 
-    if (response.ok) {
-      const data = await parseSuccess(response, opts, ofetchResponseType);
-      return wrapDataReturn(data, result, opts.responseStyle);
-    }
+      for (const fn of interceptors.error.fns) {
+        if (fn) {
+          finalError = await fn(finalError, response, request, options as ResolvedRequestOptions);
+        }
+      }
 
-    let finalError = await parseError(response);
+      // ensure error is never undefined after interceptors
+      finalError = finalError || ({} as string);
 
-    for (const fn of interceptors.error.fns) {
-      if (fn) {
-        finalError = await fn(finalError, response, request, opts);
+      if (throwOnError) {
+        throw finalError;
       }
-    }
-
-    // ensure error is never undefined after interceptors
-    finalError = (finalError as any) || ({} as string);
 
-    if (opts.throwOnError) {
-      throw finalError;
+      return wrapErrorReturn(finalError, { request, response }, responseStyle) as any;
     }
-
-    return wrapErrorReturn(finalError, result, opts.responseStyle) as any;
   };
 
   const makeMethodFn = (method: Uppercase<HttpMethod>) => (options: RequestOptions) =>
-    request({ ...options, method } as any);
+    request({ ...options, method });
 
   const makeSseFn = (method: Uppercase<HttpMethod>) => async (options: RequestOptions) => {
     const { networkBody, opts, url } = await resolveOptions(options);
-    const optsForSse: any = { ...opts };
+    const optsForSse = { ...opts };
     delete optsForSse.body; // body is provided via serializedBody below
     return createSseClient({
-      ...optsForSse,
+      ...(optsForSse as Omit<typeof opts, 'body'>),
       fetch: opts.fetch,
-      headers: opts.headers as Headers,
+      headers: opts.headers,
       method,
       onRequest: async (url, init) => {
         let request = new Request(url, init);
         request = await applyRequestInterceptors(request, opts, networkBody);
         return request;
       },
-      serializedBody: networkBody as BodyInit | null | undefined,
+      serializedBody: networkBody,
       signal: opts.signal,
       url,
     });

package/dist/clients/ofetch/types.ts

@@ -188,8 +188,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/ofetch/utils.ts

@@ -277,7 +277,7 @@ export const wrapDataReturn = <T>(
  */
 export const wrapErrorReturn = <E>(
   error: E,
-  result: { request: Request; response: Response },
+  result: { request: Request | undefined; response: Response | undefined },
   responseStyle: ResponseStyle | undefined,
 ):
   | undefined
@@ -405,8 +405,10 @@ export const parseError = async (response: Response): Promise<unknown> => {
 
 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>;