@equinor/fusion-framework-module-http 6.2.1 → 6.2.3

package/src/lib/client/types.ts

@@ -16,7 +16,7 @@ export type StreamResponse<T> = Observable<T>;
  * @returns An `ObservableInput` of type `T`.
  */
 export type ResponseSelector<TResult = unknown, TResponse = Response> = (
-    response: TResponse,
+  response: TResponse,
 ) => ObservableInput<TResult>;
 
 /**
@@ -25,8 +25,8 @@ export type ResponseSelector<TResult = unknown, TResponse = Response> = (
  * @property {string} path - The path of the request.
  */
 export type FetchRequest = RequestInit & {
-    uri: string;
-    path: string;
+  uri: string;
+  path: string;
 };
 
 /**
@@ -35,7 +35,7 @@ export type FetchRequest = RequestInit & {
  * @property {object | string | null} [body] - The request body, which can be an object, a string, or null.
  */
 export type JsonRequest<TRequest extends FetchRequest = FetchRequest> = Omit<TRequest, 'body'> & {
-    body?: object | string | null;
+  body?: object | string | null;
 };
 
 /**
@@ -52,7 +52,7 @@ export type BlobResult = { filename?: string; blob: Blob };
  * @property {() => Promise<T>} json - A method to parse the response body as JSON and return the data as type T.
  */
 export type FetchResponse<T = unknown> = Response & {
-    json(): Promise<T>;
+  json(): Promise<T>;
 };
 
 /**
@@ -62,12 +62,12 @@ export type FetchResponse<T = unknown> = Response & {
  * @template TResponse - The type of the fetch response.
  */
 export type FetchRequestInit<
-    TReturn = unknown,
-    TRequest = FetchRequest,
-    TResponse = FetchResponse<TReturn>,
+  TReturn = unknown,
+  TRequest = FetchRequest,
+  TResponse = FetchResponse<TReturn>,
 > = Omit<TRequest, 'uri' | 'path'> & {
-    /** response selector function */
-    selector?: ResponseSelector<TReturn, TResponse>;
+  /** response selector function */
+  selector?: ResponseSelector<TReturn, TResponse>;
 };
 
 /**
@@ -77,10 +77,12 @@ export type FetchRequestInit<
  * @template TRequest - The type of the fetch request.
  * @template TResponse - The type of the fetch response.
  */
-export type ClientRequestInit<T extends IHttpClient, TReturn = unknown> =
-    T extends IHttpClient<infer TRequest, infer TResponse>
-        ? FetchRequestInit<TReturn, TRequest, TResponse>
-        : never;
+export type ClientRequestInit<T extends IHttpClient, TReturn = unknown> = T extends IHttpClient<
+  infer TRequest,
+  infer TResponse
+>
+  ? FetchRequestInit<TReturn, TRequest, TResponse>
+  : never;
 
 /**
  * Represents the available execution methods for an HTTP client.
@@ -94,8 +96,8 @@ export type ExecutionMethod = 'fetch' | 'fetch$' | 'json' | 'json$';
  * @template TClient - The type of the `IHttpClient` instance.
  */
 export type ExecutionMethodParameters<
-    TMethod extends ExecutionMethod = 'fetch',
-    TClient extends IHttpClient = IHttpClient,
+  TMethod extends ExecutionMethod = 'fetch',
+  TClient extends IHttpClient = IHttpClient,
 > = Parameters<TClient[TMethod]>;
 
 /**
@@ -105,8 +107,8 @@ export type ExecutionMethodParameters<
  * @template TClient - The type of the `IHttpClient` instance.
  */
 export type ExecutionResponse<
-    TMethod extends ExecutionMethod = 'fetch',
-    TClient extends IHttpClient = IHttpClient,
+  TMethod extends ExecutionMethod = 'fetch',
+  TClient extends IHttpClient = IHttpClient,
 > = ReturnType<TClient[TMethod]>;
 
 /**
@@ -114,131 +116,131 @@ export type ExecutionResponse<
  * @template TResponse request arguments @see {@link https://developer.mozilla.org/en-US/docs/Web/API/response|response}
  */
 export interface IHttpClient<TRequest extends FetchRequest = FetchRequest, TResponse = Response> {
-    uri: string;
-    /**
-     * A pre-processor for requests made by the `IHttpClient` interface.
-     * This handler can be used to modify the request before it is sent, such as adding headers, authentication, or other transformations.
-     */
-    readonly requestHandler: IHttpRequestHandler<TRequest>;
-
-    /**
-     * A post-processor for responses received by the `IHttpClient` interface.
-     * This handler can be used to transform the response data after it is received, such as parsing JSON, handling errors, or other transformations.
-     */
-    readonly responseHandler: IHttpResponseHandler<TResponse>;
-
-    /**
-     * Observable stream of requests made by the `IHttpClient` interface.
-     * This stream can be used to observe and potentially modify the requests before they are sent.
-     */
-    readonly request$: Observable<TRequest>;
-
-    /**
-     * Observable stream of responses received by the `IHttpClient` interface.
-     * This stream can be used to observe and potentially handle the responses after they are received.
-     */
-    readonly response$: Observable<TResponse>;
-
-    /**
-     * Fetch a resource as an observable stream.
-     * This method simplifies the execution of a request and returns an observable stream of the response.
-     * The request will not be executed until the observable is subscribed to.
-     *
-     * @template T - The expected response type.
-     * @param path - The path to fetch the resource from.
-     * @param init - Optional request initialization options.
-     * @returns An observable stream of the response.
-     *
-     * @see {@link https://rxjs.dev/api/fetch/fromFetch|RxJS fromFetch}
-     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch|fetch}
-     */
-    fetch$<T = TResponse>(
-        path: string,
-        init?: FetchRequestInit<T, TRequest, TResponse>,
-    ): StreamResponse<T>;
-
-    /**
-     * Fetch a resource as a promise.
-     *
-     * @template T - The expected response type.
-     * @param path - The path to fetch the resource from.
-     * @param init - Optional request initialization options.
-     * @returns A promise that resolves to the fetched resource.
-     *
-     * @see {@link IHttpClient.fetch$}
-     */
-    fetch<T = TResponse>(path: string, init?: FetchRequestInit<T, TRequest, TResponse>): Promise<T>;
-
-    /** @deprecated use {@link IHttpClient.fetch} */
-    fetchAsync<T = TResponse>(
-        path: string,
-        args?: FetchRequestInit<T, TRequest, TResponse>,
-    ): Promise<T>;
-
-    /**
-     * Fetches a resource as an observable stream.
-     * This method simplifies the execution of a request and returns an observable stream of the response.
-     * The request will not be executed until the observable is subscribed to.
-     *
-     * @template T - The expected response type.
-     * @param path - The path to fetch the resource from.
-     * @param init - Optional request initialization options, including the request body, headers, and response type.
-     * @returns An observable stream of the fetched resource.
-     *
-     * @see {@link IHttpClient.fetch$}
-     */
-    json$<T = unknown>(
-        path: string,
-        init?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
-    ): StreamResponse<T>;
-
-    /**
-     * Fetches a resource as a promise and returns the response as a JSON object.
-     *
-     * @template T - The expected response type.
-     * @param path - The path to fetch the resource from.
-     * @param init - Optional request initialization options, including the request body, headers, and response type.
-     * @returns A promise that resolves to the fetched resource as a JSON object.
-     *
-     * @see {@link IHttpClient.fetch} for fetching resources as an observable stream.
-     */
-    json<T = unknown>(
-        path: string,
-        init?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
-    ): Promise<T>;
-
-    /** @deprecated */
-    jsonAsync<T = unknown>(
-        path: string,
-        args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
-    ): Promise<T>;
-
-    /**
-     * Fetches a blob resource from the specified path and returns a Promise that resolves to the fetched blob data.
-     *
-     * @param path - The path to fetch the blob from.
-     * @param args - Optional arguments for the fetch request, including the request body, headers, and response type.
-     * @returns A Promise that resolves to the fetched blob data.
-     */
-    blob<T = BlobResult>(
-        path: string,
-        args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
-    ): Promise<T>;
-
-    /**
-     * Fetches a blob from the specified path and returns a stream response.
-     *
-     * @param path - The path to fetch the blob from.
-     * @param args - Optional arguments for the fetch request, including the request body, headers, and response type.
-     * @returns A stream response containing the fetched blob.
-     */
-    blob$<T = BlobResult>(
-        path: string,
-        args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
-    ): StreamResponse<T>;
-
-    /**
-     * Abort all ongoing requests for the current client.
-     */
-    abort(): void;
+  uri: string;
+  /**
+   * A pre-processor for requests made by the `IHttpClient` interface.
+   * This handler can be used to modify the request before it is sent, such as adding headers, authentication, or other transformations.
+   */
+  readonly requestHandler: IHttpRequestHandler<TRequest>;
+
+  /**
+   * A post-processor for responses received by the `IHttpClient` interface.
+   * This handler can be used to transform the response data after it is received, such as parsing JSON, handling errors, or other transformations.
+   */
+  readonly responseHandler: IHttpResponseHandler<TResponse>;
+
+  /**
+   * Observable stream of requests made by the `IHttpClient` interface.
+   * This stream can be used to observe and potentially modify the requests before they are sent.
+   */
+  readonly request$: Observable<TRequest>;
+
+  /**
+   * Observable stream of responses received by the `IHttpClient` interface.
+   * This stream can be used to observe and potentially handle the responses after they are received.
+   */
+  readonly response$: Observable<TResponse>;
+
+  /**
+   * Fetch a resource as an observable stream.
+   * This method simplifies the execution of a request and returns an observable stream of the response.
+   * The request will not be executed until the observable is subscribed to.
+   *
+   * @template T - The expected response type.
+   * @param path - The path to fetch the resource from.
+   * @param init - Optional request initialization options.
+   * @returns An observable stream of the response.
+   *
+   * @see {@link https://rxjs.dev/api/fetch/fromFetch|RxJS fromFetch}
+   * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch|fetch}
+   */
+  fetch$<T = TResponse>(
+    path: string,
+    init?: FetchRequestInit<T, TRequest, TResponse>,
+  ): StreamResponse<T>;
+
+  /**
+   * Fetch a resource as a promise.
+   *
+   * @template T - The expected response type.
+   * @param path - The path to fetch the resource from.
+   * @param init - Optional request initialization options.
+   * @returns A promise that resolves to the fetched resource.
+   *
+   * @see {@link IHttpClient.fetch$}
+   */
+  fetch<T = TResponse>(path: string, init?: FetchRequestInit<T, TRequest, TResponse>): Promise<T>;
+
+  /** @deprecated use {@link IHttpClient.fetch} */
+  fetchAsync<T = TResponse>(
+    path: string,
+    args?: FetchRequestInit<T, TRequest, TResponse>,
+  ): Promise<T>;
+
+  /**
+   * Fetches a resource as an observable stream.
+   * This method simplifies the execution of a request and returns an observable stream of the response.
+   * The request will not be executed until the observable is subscribed to.
+   *
+   * @template T - The expected response type.
+   * @param path - The path to fetch the resource from.
+   * @param init - Optional request initialization options, including the request body, headers, and response type.
+   * @returns An observable stream of the fetched resource.
+   *
+   * @see {@link IHttpClient.fetch$}
+   */
+  json$<T = unknown>(
+    path: string,
+    init?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
+  ): StreamResponse<T>;
+
+  /**
+   * Fetches a resource as a promise and returns the response as a JSON object.
+   *
+   * @template T - The expected response type.
+   * @param path - The path to fetch the resource from.
+   * @param init - Optional request initialization options, including the request body, headers, and response type.
+   * @returns A promise that resolves to the fetched resource as a JSON object.
+   *
+   * @see {@link IHttpClient.fetch} for fetching resources as an observable stream.
+   */
+  json<T = unknown>(
+    path: string,
+    init?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
+  ): Promise<T>;
+
+  /** @deprecated */
+  jsonAsync<T = unknown>(
+    path: string,
+    args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
+  ): Promise<T>;
+
+  /**
+   * Fetches a blob resource from the specified path and returns a Promise that resolves to the fetched blob data.
+   *
+   * @param path - The path to fetch the blob from.
+   * @param args - Optional arguments for the fetch request, including the request body, headers, and response type.
+   * @returns A Promise that resolves to the fetched blob data.
+   */
+  blob<T = BlobResult>(
+    path: string,
+    args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
+  ): Promise<T>;
+
+  /**
+   * Fetches a blob from the specified path and returns a stream response.
+   *
+   * @param path - The path to fetch the blob from.
+   * @param args - Optional arguments for the fetch request, including the request body, headers, and response type.
+   * @returns A stream response containing the fetched blob.
+   */
+  blob$<T = BlobResult>(
+    path: string,
+    args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
+  ): StreamResponse<T>;
+
+  /**
+   * Abort all ongoing requests for the current client.
+   */
+  abort(): void;
 }

package/src/lib/operators/capitalize-request-method.operator.ts

@@ -8,15 +8,17 @@ import type { ProcessOperator } from './types';
  * @returns A new request object with the HTTP method in uppercase.
  */
 export const capitalizeRequestMethodOperator =
-    <T extends RequestInit>(options?: { silent?: boolean }): ProcessOperator<T> =>
-    (request): T => {
-        const { error, success, data } = requestMethodCasing().safeParse(request.method);
+  <T extends RequestInit>(options?: { silent?: boolean }): ProcessOperator<T> =>
+  (request): T => {
+    const { error, success, data } = requestMethodCasing().safeParse(request.method);
 
-        request.method = success ? data : request.method?.toUpperCase();
+    request.method = success ? data : request.method?.toUpperCase();
 
-        if (error && !options?.silent) {
-            error.errors.forEach((e) => console.warn(e.message));
-        }
+    if (error && !options?.silent) {
+      for (const e of error.errors) {
+        console.warn(e.message);
+      }
+    }
 
-        return request;
-    };
+    return request;
+  };

package/src/lib/operators/fetch-request.schema.ts

@@ -6,19 +6,19 @@ import { z } from 'zod';
  * @link https://www.rfc-editor.org/rfc/rfc7231#section-4.1
  */
 export const requestMethodCasing = (): z.ZodType<string> => {
-    return z.custom<string>(
-        (value?: string) => value === value?.toUpperCase(),
-        (value: string) => ({
-            code: z.ZodIssueCode.custom,
-            validation: 'uppercase',
-            path: ['method'],
-            message: [
-                `Provided HTTP method '${value}' must be in uppercase.`,
-                'See RFC 7231 Section 4.1 for more information',
-                'https://www.rfc-editor.org/rfc/rfc7231#section-4.1',
-            ].join(' '),
-        }),
-    );
+  return z.custom<string>(
+    (value?: string) => value === value?.toUpperCase(),
+    (value: string) => ({
+      code: z.ZodIssueCode.custom,
+      validation: 'uppercase',
+      path: ['method'],
+      message: [
+        `Provided HTTP method '${value}' must be in uppercase.`,
+        'See RFC 7231 Section 4.1 for more information',
+        'https://www.rfc-editor.org/rfc/rfc7231#section-4.1',
+      ].join(' '),
+    }),
+  );
 };
 
 /**
@@ -34,22 +34,19 @@ export const requestMethodCasing = (): z.ZodType<string> => {
  * @link https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html
  */
 export const requestMethodVerb = () => {
-    return z.enum(
-        ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD', 'CONNECT', 'TRACE'],
-        {
-            errorMap: (error) => {
-                const { received, options } = error as z.ZodInvalidEnumValueIssue;
-                return {
-                    message: [
-                        'Invalid request method.',
-                        `Expected '${options.join(' | ')}', but received '${received}'.`,
-                        'See RFC 2615 Section 9 for more information',
-                        'https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html',
-                    ].join(' '),
-                };
-            },
-        },
-    );
+  return z.enum(['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD', 'CONNECT', 'TRACE'], {
+    errorMap: (error) => {
+      const { received, options } = error as z.ZodInvalidEnumValueIssue;
+      return {
+        message: [
+          'Invalid request method.',
+          `Expected '${options.join(' | ')}', but received '${received}'.`,
+          'See RFC 2615 Section 9 for more information',
+          'https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html',
+        ].join(' '),
+      };
+    },
+  });
 };
 
 export const requestMethod = () => requestMethodCasing().pipe(requestMethodVerb());
@@ -62,48 +59,48 @@ export const requestMethod = () => requestMethodCasing().pipe(requestMethodVerb(
  * This schema is used to ensure that the request options conform to the expected structure and types.
  */
 export const requestInitSchema = z.object({
-    attributionReporting: z
-        .object({
-            eventSourceEligible: z.boolean().optional(),
-            triggerEligible: z.boolean().optional(),
-        })
-        .optional(),
-    body: z
-        .union([
-            z.string(),
-            z.instanceof(Blob),
-            z.instanceof(ArrayBuffer),
-            z.instanceof(FormData),
-            z.instanceof(URLSearchParams),
-            z.instanceof(ReadableStream),
-        ])
-        .optional(),
-    browsingTopics: z.boolean().optional(),
-    cache: z
-        .enum(['default', 'no-store', 'reload', 'no-cache', 'force-cache', 'only-if-cached'])
-        .optional(),
-    credentials: z.enum(['omit', 'same-origin', 'include']).optional(),
-    headers: z.record(z.string(), z.string()).optional().or(z.instanceof(Headers)),
-    integrity: z.string().optional(),
-    keepalive: z.boolean().optional(),
-    method: requestMethod().optional(),
-    mode: z.enum(['same-origin', 'cors', 'no-cors', 'navigate', 'websocket']).optional(),
-    priority: z.enum(['low', 'high', 'auto']).optional(),
-    redirect: z.enum(['follow', 'error', 'manual']).optional(),
-    referrer: z.string().optional(),
-    referrerPolicy: z
-        .enum([
-            'no-referrer',
-            'no-referrer-when-downgrade',
-            'origin',
-            'origin-when-cross-origin',
-            'same-origin',
-            'strict-origin',
-            'strict-origin-when-cross-origin',
-            'unsafe-url',
-        ])
-        .optional(),
-    signal: z.instanceof(AbortSignal).optional(),
+  attributionReporting: z
+    .object({
+      eventSourceEligible: z.boolean().optional(),
+      triggerEligible: z.boolean().optional(),
+    })
+    .optional(),
+  body: z
+    .union([
+      z.string(),
+      z.instanceof(Blob),
+      z.instanceof(ArrayBuffer),
+      z.instanceof(FormData),
+      z.instanceof(URLSearchParams),
+      z.instanceof(ReadableStream),
+    ])
+    .optional(),
+  browsingTopics: z.boolean().optional(),
+  cache: z
+    .enum(['default', 'no-store', 'reload', 'no-cache', 'force-cache', 'only-if-cached'])
+    .optional(),
+  credentials: z.enum(['omit', 'same-origin', 'include']).optional(),
+  headers: z.record(z.string(), z.string()).optional().or(z.instanceof(Headers)),
+  integrity: z.string().optional(),
+  keepalive: z.boolean().optional(),
+  method: requestMethod().optional(),
+  mode: z.enum(['same-origin', 'cors', 'no-cors', 'navigate', 'websocket']).optional(),
+  priority: z.enum(['low', 'high', 'auto']).optional(),
+  redirect: z.enum(['follow', 'error', 'manual']).optional(),
+  referrer: z.string().optional(),
+  referrerPolicy: z
+    .enum([
+      'no-referrer',
+      'no-referrer-when-downgrade',
+      'origin',
+      'origin-when-cross-origin',
+      'same-origin',
+      'strict-origin',
+      'strict-origin-when-cross-origin',
+      'unsafe-url',
+    ])
+    .optional(),
+  signal: z.instanceof(AbortSignal).optional(),
 });
 
 /**
@@ -114,6 +111,6 @@ export const requestInitSchema = z.object({
  * - `path`: An optional string representing the path of the request.
  */
 export const fetchRequestSchema = requestInitSchema.extend({
-    uri: z.string(),
-    path: z.string().optional(),
+  uri: z.string(),
+  path: z.string().optional(),
 });

package/src/lib/operators/http-request-handler.ts

@@ -13,17 +13,17 @@ import type { FetchRequest } from '../client';
  * @template T - The type of the fetch request, which extends `FetchRequest`.
  */
 export class HttpRequestHandler<T extends FetchRequest = FetchRequest> extends ProcessOperators<T> {
-    /**
-     * Sets a header that will apply to all requests made by the `HttpClient`.
-     *
-     * @param key - The name of the header to set.
-     * @param value - The value of the header to set.
-     * @returns The current `HttpRequestHandler` instance, allowing for method chaining.
-     */
-    setHeader(key: string, value: string): HttpRequestHandler<T> {
-        const operator = requestOperatorHeader<T>(key, value);
-        return this.set('header-' + key, operator) as HttpRequestHandler<T>;
-    }
+  /**
+   * Sets a header that will apply to all requests made by the `HttpClient`.
+   *
+   * @param key - The name of the header to set.
+   * @param value - The value of the header to set.
+   * @returns The current `HttpRequestHandler` instance, allowing for method chaining.
+   */
+  setHeader(key: string, value: string): HttpRequestHandler<T> {
+    const operator = requestOperatorHeader<T>(key, value);
+    return this.set('header-' + key, operator) as HttpRequestHandler<T>;
+  }
 }
 
 export default HttpRequestHandler;