@hey-api/openapi-ts 0.80.10 → 0.80.12

package/dist/clients/angular/client.ts

@@ -1,14 +1,26 @@
 import type { HttpResponse } from '@angular/common/http';
-import { HttpClient, HttpEventType, HttpRequest } from '@angular/common/http';
+import {
+  HttpClient,
+  HttpErrorResponse,
+  HttpEventType,
+  HttpRequest,
+} from '@angular/common/http';
 import {
   assertInInjectionContext,
   inject,
   provideAppInitializer,
+  runInInjectionContext,
 } from '@angular/core';
 import { firstValueFrom } from 'rxjs';
 import { filter } from 'rxjs/operators';
 
-import type { Client, Config, ResolvedRequestOptions } from './types';
+import type {
+  Client,
+  Config,
+  RequestOptions,
+  ResolvedRequestOptions,
+  ResponseStyle,
+} from './types';
 import {
   buildUrl,
   createConfig,
@@ -42,20 +54,59 @@ export const createClient = (config: Config = {}): Client => {
     ResolvedRequestOptions
   >();
 
-  const request: Client['request'] = async (options) => {
+  const requestOptions = <
+    ThrowOnError extends boolean = false,
+    TResponseStyle extends ResponseStyle = 'fields',
+  >(
+    options: RequestOptions<TResponseStyle, ThrowOnError>,
+  ) => {
     const opts = {
       ..._config,
       ...options,
       headers: mergeHeaders(_config.headers, options.headers),
       httpClient: options.httpClient ?? _config.httpClient,
-      serializedBody: undefined,
+      method: 'GET',
+      serializedBody: options.body as any,
     };
 
     if (!opts.httpClient) {
-      assertInInjectionContext(request);
-      opts.httpClient = inject(HttpClient);
+      if (opts.injector) {
+        opts.httpClient = runInInjectionContext(opts.injector, () =>
+          inject(HttpClient),
+        );
+      } else {
+        assertInInjectionContext(requestOptions);
+        opts.httpClient = inject(HttpClient);
+      }
+    }
+
+    if (opts.body && opts.bodySerializer) {
+      opts.serializedBody = opts.bodySerializer(opts.body);
+    }
+
+    // remove Content-Type header if body is empty to avoid sending invalid requests
+    if (opts.serializedBody === undefined || opts.serializedBody === '') {
+      opts.headers.delete('Content-Type');
     }
 
+    const url = buildUrl(opts as any);
+
+    const req = new HttpRequest<unknown>(
+      opts.method,
+      url,
+      opts.serializedBody || null,
+      {
+        redirect: 'follow',
+        ...opts,
+      },
+    );
+
+    return { opts, req };
+  };
+
+  const request: Client['request'] = async (options) => {
+    const { opts, req: initialReq } = requestOptions(options);
+
     if (opts.security) {
       await setAuthParams({
         ...opts,
@@ -67,26 +118,11 @@ export const createClient = (config: Config = {}): Client => {
       await opts.requestValidator(opts);
     }
 
-    if (opts.body && opts.bodySerializer) {
-      opts.serializedBody = opts.bodySerializer(opts.body);
-    }
-
-    // remove Content-Type header if body is empty to avoid sending invalid requests
-    if (opts.serializedBody === undefined || opts.serializedBody === '') {
-      opts.headers.delete('Content-Type');
-    }
-
-    const url = buildUrl(opts);
-
-    let req = new HttpRequest<unknown>(opts.method, url, {
-      redirect: 'follow',
-      ...opts,
-      body: opts.serializedBody,
-    });
+    let req = initialReq;
 
     for (const fn of interceptors.request._fns) {
       if (fn) {
-        req = await fn(req, opts);
+        req = await fn(req, opts as any);
       }
     }
 
@@ -98,46 +134,56 @@ export const createClient = (config: Config = {}): Client => {
 
     try {
       response = await firstValueFrom(
-        opts.httpClient
-          .request(req)
+        opts
+          .httpClient!.request(req)
           .pipe(filter((event) => event.type === HttpEventType.Response)),
       );
 
       for (const fn of interceptors.response._fns) {
         if (fn) {
-          response = await fn(response, req, opts);
+          response = await fn(response, req, opts as any);
         }
       }
 
-      let bodyResponse = response.body as Record<string, unknown>;
+      let bodyResponse: any = response.body;
 
       if (opts.responseValidator) {
         await opts.responseValidator(bodyResponse);
       }
 
       if (opts.responseTransformer) {
-        bodyResponse = (await opts.responseTransformer(bodyResponse)) as Record<
-          string,
-          unknown
-        >;
+        bodyResponse = await opts.responseTransformer(bodyResponse);
       }
 
-      return (
-        opts.responseStyle === 'data'
-          ? bodyResponse
-          : { data: bodyResponse, ...result }
-      ) as any;
+      return opts.responseStyle === 'data'
+        ? bodyResponse
+        : { data: bodyResponse, ...result };
     } catch (error) {
+      if (error instanceof HttpErrorResponse) {
+        response = error;
+      }
+
+      let finalError = error instanceof HttpErrorResponse ? error.error : error;
+
       for (const fn of interceptors.error._fns) {
         if (fn) {
-          (await fn(error, response!, req, opts)) as string;
+          finalError = (await fn(
+            finalError,
+            response as HttpResponse<unknown>,
+            req,
+            opts as any,
+          )) as string;
         }
       }
 
+      if (opts.throwOnError) {
+        throw finalError;
+      }
+
       return opts.responseStyle === 'data'
         ? undefined
         : {
-            error,
+            error: finalError,
             ...result,
           };
     }
@@ -156,6 +202,19 @@ export const createClient = (config: Config = {}): Client => {
     post: (options) => request({ ...options, method: 'POST' }),
     put: (options) => request({ ...options, method: 'PUT' }),
     request,
+    requestOptions: (options) => {
+      if (options.security) {
+        throw new Error('Security is not supported in requestOptions');
+      }
+
+      if (options.requestValidator) {
+        throw new Error(
+          'Request validation is not supported in requestOptions',
+        );
+      }
+
+      return requestOptions(options).req;
+    },
     setConfig,
     trace: (options) => request({ ...options, method: 'TRACE' }),
   };

package/dist/clients/angular/types.ts

@@ -1,8 +1,11 @@
 import type {
   HttpClient,
+  HttpErrorResponse,
+  HttpHeaders,
   HttpRequest,
   HttpResponse,
 } from '@angular/common/http';
+import type { Injector } from '@angular/core';
 
 import type { Auth } from '../core/auth';
 import type {
@@ -15,11 +18,29 @@ export type ResponseStyle = 'data' | 'fields';
 
 export interface Config<T extends ClientOptions = ClientOptions>
   extends Omit<RequestInit, 'body' | 'headers' | 'method'>,
-    CoreConfig {
+    Omit<CoreConfig, 'headers'> {
   /**
    * Base URL for all requests made by this client.
    */
   baseUrl?: T['baseUrl'];
+  /**
+   * An object containing any HTTP headers that you want to pre-populate your
+   * `HttpHeaders` object with.
+   *
+   * {@link https://angular.dev/api/common/http/HttpHeaders#constructor See more}
+   */
+  headers?:
+    | HttpHeaders
+    | Record<
+        string,
+        | string
+        | number
+        | boolean
+        | (string | number | boolean)[]
+        | null
+        | undefined
+        | unknown
+      >;
   /**
    * The HTTP client to use for making requests.
    */
@@ -30,6 +51,13 @@ export interface Config<T extends ClientOptions = ClientOptions>
    * @default 'fields'
    */
   responseStyle?: ResponseStyle;
+
+  /**
+   * Throw an error instead of returning it in the response?
+   *
+   * @default false
+   */
+  throwOnError?: T['throwOnError'];
 }
 
 export interface RequestOptions<
@@ -46,6 +74,10 @@ export interface RequestOptions<
    * {@link https://developer.mozilla.org/docs/Web/API/fetch#body}
    */
   body?: unknown;
+  /**
+   * Optional custom injector for dependency resolution if you don't implicitly or explicitly provide one.
+   */
+  injector?: Injector;
   path?: Record<string, unknown>;
   query?: Record<string, unknown>;
   /**
@@ -68,45 +100,41 @@ export type RequestResult<
   TError = unknown,
   ThrowOnError extends boolean = boolean,
   TResponseStyle extends ResponseStyle = 'fields',
-> = ThrowOnError extends true
-  ? Promise<
-      TResponseStyle extends 'data'
-        ? TData extends Record<string, unknown>
-          ? TData[keyof TData]
-          : TData
-        : {
-            data: TData extends Record<string, unknown>
-              ? TData[keyof TData]
-              : TData;
-            request: Request;
-            response: Response;
-          }
-    >
-  : Promise<
-      TResponseStyle extends 'data'
-        ?
-            | (TData extends Record<string, unknown>
+> = Promise<
+  ThrowOnError extends true
+    ? TResponseStyle extends 'data'
+      ? TData extends Record<string, unknown>
+        ? TData[keyof TData]
+        : TData
+      : {
+          data: TData extends Record<string, unknown>
+            ? TData[keyof TData]
+            : TData;
+          request: HttpRequest<unknown>;
+          response: HttpResponse<TData>;
+        }
+    : TResponseStyle extends 'data'
+      ?
+          | (TData extends Record<string, unknown> ? TData[keyof TData] : TData)
+          | undefined
+      :
+          | {
+              data: TData extends Record<string, unknown>
                 ? TData[keyof TData]
-                : TData)
-            | undefined
-        : (
-            | {
-                data: TData extends Record<string, unknown>
-                  ? TData[keyof TData]
-                  : TData;
-                error: undefined;
-              }
-            | {
-                data: undefined;
-                error: TError extends Record<string, unknown>
-                  ? TError[keyof TError]
-                  : TError;
-              }
-          ) & {
-            request: Request;
-            response: Response;
-          }
-    >;
+                : TData;
+              error: undefined;
+              request: HttpRequest<unknown>;
+              response: HttpResponse<TData>;
+            }
+          | {
+              data: undefined;
+              error: TError[keyof TError];
+              request: HttpRequest<unknown>;
+              response: HttpErrorResponse & {
+                error: TError[keyof TError] | null;
+              };
+            }
+>;
 
 export interface ClientOptions {
   baseUrl?: string;
@@ -133,6 +161,13 @@ type RequestFn = <
     Pick<Required<RequestOptions<TResponseStyle, ThrowOnError>>, 'method'>,
 ) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
 
+type RequestOptionsFn = <
+  ThrowOnError extends boolean = false,
+  TResponseStyle extends ResponseStyle = 'fields',
+>(
+  options: RequestOptions<TResponseStyle, ThrowOnError>,
+) => HttpRequest<unknown>;
+
 type BuildUrlFn = <
   TData extends {
     body?: unknown;
@@ -151,6 +186,8 @@ export type Client = CoreClient<RequestFn, Config, MethodFn, BuildUrlFn> & {
     unknown,
     ResolvedRequestOptions
   >;
+
+  requestOptions: RequestOptionsFn;
 };
 
 /**

package/dist/clients/angular/utils.ts

@@ -1,9 +1,10 @@
+import { HttpHeaders } from '@angular/common/http';
+
 import { getAuthToken } from '../core/auth';
 import type {
   QuerySerializer,
   QuerySerializerOptions,
 } from '../core/bodySerializer';
-import { jsonBodySerializer } from '../core/bodySerializer';
 import {
   serializeArrayParam,
   serializeObjectParam,
@@ -186,14 +187,13 @@ export const getParseAs = (
   return;
 };
 
-export const setAuthParams = async ({
-  security,
-  ...options
-}: Pick<Required<RequestOptions>, 'security'> &
-  Pick<RequestOptions, 'auth' | 'query'> & {
-    headers: Headers;
-  }) => {
-  for (const auth of security) {
+export const setAuthParams = async (
+  options: Pick<Required<RequestOptions>, 'security'> &
+    Pick<RequestOptions, 'auth' | 'query'> & {
+      headers: HttpHeaders;
+    },
+) => {
+  for (const auth of options.security) {
     const token = await getAuthToken(auth, options.auth);
 
     if (!token) {
@@ -210,11 +210,11 @@ export const setAuthParams = async ({
         options.query[name] = token;
         break;
       case 'cookie':
-        options.headers.append('Cookie', `${name}=${token}`);
+        options.headers = options.headers.append('Cookie', `${name}=${token}`);
         break;
       case 'header':
       default:
-        options.headers.set(name, token);
+        options.headers = options.headers.set(name, token);
         break;
     }
 
@@ -275,33 +275,47 @@ export const mergeConfigs = (a: Config, b: Config): Config => {
 
 export const mergeHeaders = (
   ...headers: Array<Required<Config>['headers'] | undefined>
-): Headers => {
-  const mergedHeaders = new Headers();
+): HttpHeaders => {
+  let mergedHeaders = new HttpHeaders();
+
   for (const header of headers) {
     if (!header || typeof header !== 'object') {
       continue;
     }
 
-    const iterator =
-      header instanceof Headers ? header.entries() : Object.entries(header);
-
-    for (const [key, value] of iterator) {
-      if (value === null) {
-        mergedHeaders.delete(key);
-      } else if (Array.isArray(value)) {
-        for (const v of value) {
-          mergedHeaders.append(key, v as string);
+    if (header instanceof HttpHeaders) {
+      // Merge HttpHeaders instance
+      header.keys().forEach((key) => {
+        const values = header.getAll(key);
+        if (values) {
+          values.forEach((value) => {
+            mergedHeaders = mergedHeaders.append(key, value);
+          });
+        }
+      });
+    } else {
+      // Merge plain object headers
+      for (const [key, value] of Object.entries(header)) {
+        if (value === null) {
+          mergedHeaders = mergedHeaders.delete(key);
+        } else if (Array.isArray(value)) {
+          for (const v of value) {
+            mergedHeaders = mergedHeaders.append(key, v as string);
+          }
+        } else if (value !== undefined) {
+          // assume object headers are meant to be JSON stringified, i.e. their
+          // content value in OpenAPI specification is 'application/json'
+          mergedHeaders = mergedHeaders.set(
+            key,
+            typeof value === 'object'
+              ? JSON.stringify(value)
+              : (value as string),
+          );
         }
-      } else if (value !== undefined) {
-        // assume object headers are meant to be JSON stringified, i.e. their
-        // content value in OpenAPI specification is 'application/json'
-        mergedHeaders.set(
-          key,
-          typeof value === 'object' ? JSON.stringify(value) : (value as string),
-        );
       }
     }
   }
+
   return mergedHeaders;
 };
 
@@ -409,9 +423,7 @@ const defaultHeaders = {
 export const createConfig = <T extends ClientOptions = ClientOptions>(
   override: Config<Omit<ClientOptions, keyof T> & T> = {},
 ): Config<Omit<ClientOptions, keyof T> & T> => ({
-  ...jsonBodySerializer,
   headers: defaultHeaders,
-  // parseAs: 'auto',
   querySerializer: defaultQuerySerializer,
   ...override,
 });