@equinor/fusion-framework-module-http 5.2.3 → 6.0.1

package/src/lib/client/client.ts

@@ -8,15 +8,25 @@ import { blobSelector, jsonSelector } from '../selectors';
 import type { Observable, ObservableInput } from 'rxjs';
 import type { IHttpRequestHandler, IHttpResponseHandler } from '../operators';
 import type {
+    BlobResult,
     FetchRequest,
     FetchRequestInit,
     FetchResponse,
     IHttpClient,
     JsonRequest,
     StreamResponse,
-} from '.';
+} from './types';
+
 import { HttpResponseError } from '../../errors';
 
+/**
+ * Configuration options for creating an `HttpClient` instance.
+ *
+ * @template TRequest - The type of the request object. Defaults to `FetchRequest`.
+ * @template TResponse - The type of the response object. Defaults to `Response`.
+ * @property {IHttpRequestHandler<TRequest>} requestHandler - A handler for customizing the request before it is sent.
+ * @property {IHttpResponseHandler<TResponse>} responseHandler - A handler for customizing the response after it is received.
+ */
 export type HttpClientCreateOptions<
     TRequest extends FetchRequest = FetchRequest,
     TResponse = Response,
@@ -31,22 +41,46 @@ export class HttpClient<
     TResponse extends FetchResponse = FetchResponse,
 > implements IHttpClient<TRequest, TResponse>
 {
-    readonly requestHandler: IHttpRequestHandler<TRequest>;
+    /**
+     * A request handler that can be used to customize the request before it is sent.
+     * This property is part of the `HttpClientCreateOptions` configuration object used to create an `HttpClient` instance.
+     */
+    public readonly requestHandler: IHttpRequestHandler<TRequest>;
 
-    readonly responseHandler: IHttpResponseHandler<TResponse>;
+    /**
+     * A handler for customizing the response after it is received.
+     * This property is part of the `HttpClientCreateOptions` configuration object used to create an `HttpClient` instance.
+     */
+    public readonly responseHandler: IHttpResponseHandler<TResponse>;
 
-    /** stream of requests that are about to be executed  */
+    /**
+     * A stream of requests that are about to be executed.
+     * This property is used internally by the `HttpClient` class to manage the lifecycle of requests.
+     */
     protected _request$ = new Subject<TRequest>();
 
-    /** stream of request responses */
+    /**
+     * A stream of responses that have been received.
+     * This property is used internally by the `HttpClient` class to manage the lifecycle of responses.
+     */
     protected _response$ = new Subject<TResponse>();
 
+    /**
+     * A stream that is used to signal the abortion of requests.
+     * This property is used internally by the `HttpClient` class to manage the lifecycle of requests.
+     */
     protected _abort$ = new Subject<void>();
 
+    /**
+     * A stream of requests that are about to be executed.
+     */
     public get request$(): Observable<TRequest> {
         return this._request$.asObservable();
     }
 
+    /**
+     * A stream of responses that have been received.
+     */
     public get response$(): Observable<TResponse> {
         return this._response$.asObservable();
     }
@@ -60,11 +94,23 @@ export class HttpClient<
         this._init();
     }
 
-    /** internal abstract method, for overriding instead of overriding constructor */
+    /**
+     * Internal method called by child classes to perform initialization logic in the constructor.
+     * This method is intended to be overridden by child classes to add their own initialization logic.
+     * @protected
+     * @virtual
+     */
     protected _init(): void {
         // called by children for constructor setup
     }
 
+    /**
+     * Fetches data from the specified path and returns a stream response.
+     *
+     * @param path - The path to fetch data from.
+     * @param args - Optional request initialization options, including a custom selector function.
+     * @returns A stream response containing the fetched data.
+     */
     public fetch$<T = TResponse>(
         path: string,
         args?: FetchRequestInit<T, TRequest, TResponse>,
@@ -72,6 +118,13 @@ export class HttpClient<
         return this._fetch$(path, args);
     }
 
+    /**
+     * Fetches data from the specified path and returns a Promise containing the fetched data.
+     *
+     * @param path - The path to fetch data from.
+     * @param args - Optional request initialization options, including a custom selector function.
+     * @returns A Promise containing the fetched data.
+     */
     public fetch<T = TResponse>(
         path: string,
         args?: FetchRequestInit<T, TRequest, TResponse>,
@@ -87,6 +140,16 @@ export class HttpClient<
         return this.fetch(path, args);
     }
 
+    /**
+     * Fetches data from the specified path and returns a stream response containing the data in JSON format.
+     *
+     * @param path - The path to fetch the data from.
+     * @param args - Optional request initialization options, including a custom selector function and request body.
+     *   - `body`: The request body, which will be automatically serialized to JSON if it's an object.
+     *   - `selector`: A custom selector function to transform the response data. If not provided, the `jsonSelector` function will be used.
+     *   - `headers`: Additional headers to include in the request. The `Accept` and `Content-Type` headers will be automatically set to `application/json`.
+     * @returns A stream response containing the fetched data in JSON format.
+     */
     public json$<T = unknown>(
         path: string,
         args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
@@ -104,6 +167,16 @@ export class HttpClient<
         } as FetchRequestInit<T, TRequest, TResponse>);
     }
 
+    /**
+     * Fetches data from the specified path and returns a Promise containing the fetched data in JSON format.
+     *
+     * @param path - The path to fetch the data from.
+     * @param args - Optional request initialization options, including a custom selector function and request body.
+     *   - `body`: The request body, which will be automatically serialized to JSON if it's an object.
+     *   - `selector`: A custom selector function to transform the response data. If not provided, the `jsonSelector` function will be used.
+     *   - `headers`: Additional headers to include in the request. The `Accept` and `Content-Type` headers will be automatically set to `application/json`.
+     * @returns A Promise containing the fetched data in JSON format.
+     */
     public json<T = unknown>(
         path: string,
         args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
@@ -111,18 +184,41 @@ export class HttpClient<
         return firstValueFrom(this.json$<T>(path, args));
     }
 
-    public blob$(
+    /**
+     * Fetches a blob resource from the specified path and returns a stream response.
+     *
+     * @param path - The path to the blob resource.
+     * @param args - Optional request initialization options, including a custom selector function.
+     * @returns A stream response containing the fetched blob data.
+     */
+    public blob$<T = BlobResult>(
         path: string,
-        args?: FetchRequestInit<Blob, TRequest, TResponse>,
-    ): StreamResponse<Blob> {
+        args?: FetchRequestInit<T, TRequest, TResponse>,
+    ): StreamResponse<T> {
+        // Get the selector value from the provided args, or use the default blobSelector
         const selector = args?.selector ?? blobSelector;
-        return this.fetch$(path, {
+
+        // Create the FetchRequestInit object with the provided args and the selector
+        const init = {
             ...args,
             selector,
-        } as FetchRequestInit<Blob, TRequest, TResponse>);
+        } as FetchRequestInit<T, TRequest, TResponse>;
+
+        // Call the fetch$ method with the provided path and the constructed init object
+        return this.fetch$(path, init);
     }
 
-    public blob(path: string, args?: FetchRequestInit<Blob, TRequest, TResponse>): Promise<Blob> {
+    /**
+     * Fetches a blob from the specified path and returns a Promise that resolves to the blob result.
+     *
+     * @param path - The path to fetch the blob from.
+     * @param args - Optional arguments for the fetch request, including request body, headers, and response type.
+     * @returns A Promise that resolves to the blob result.
+     */
+    public blob<T = BlobResult>(
+        path: string,
+        args?: FetchRequestInit<T, TRequest, TResponse>,
+    ): Promise<T> {
         return firstValueFrom(this.blob$(path, args));
     }
 
@@ -134,6 +230,14 @@ export class HttpClient<
         return this.json(path, args);
     }
 
+    /**
+     * Executes an HTTP request using the specified method and path.
+     *
+     * @param method - The HTTP method to use for the request, such as 'fetch', 'json', or 'blob'.
+     * @param path - The path to the resource to fetch.
+     * @param init - Optional request initialization options, including request body, headers, and response type.
+     * @returns The result of the HTTP request, which will be of the same type as the return value of the specified method.
+     */
     public execute<T = TResponse, TMethod extends 'fetch' | 'fetch$' | 'json' | 'json$' = 'fetch'>(
         method: TMethod,
         path: string,
@@ -142,10 +246,30 @@ export class HttpClient<
         return this[method](path, init) as ReturnType<IHttpClient[TMethod]>;
     }
 
+    /**
+     * Aborts any ongoing HTTP requests made by this `IHttpClient` instance.
+     * This will trigger the `takeUntil` operator in the `_fetch$` method,
+     * causing any in-flight requests to be cancelled.
+     */
     public abort(): void {
         this._abort$.next();
     }
 
+    /**
+     * Fetches data from the specified path and returns an Observable that emits the response.
+     *
+     * @param path - The path to fetch the data from.
+     * @param args - Optional arguments for the fetch request, including a response selector function, request body, headers, and response type.
+     * @returns {Observable<T>} An Observable that emits the response data.
+     *
+     * This method handles the following steps:
+     * 1. Resolves the full URL by combining the base URI and the provided path.
+     * 2. Prepares the request by passing it through the `requestHandler.process()` method.
+     * 3. Executes the fetch request using the prepared request.
+     * 4. Prepares the response by passing it through the `responseHandler.process()` method.
+     * 5. Applies the optional response selector function to transform the response data.
+     * 6. Cancels the request if the `_abort$` observable emits.
+     */
     protected _fetch$<T = TResponse>(
         path: string,
         args?: FetchRequestInit<T, TRequest, TResponse>,
@@ -189,14 +313,39 @@ export class HttpClient<
         return response$ as unknown as Observable<T>;
     }
 
+    /**
+     * Prepares the request by passing it through the `requestHandler.process()` method.
+     * This method is an implementation detail of the `_fetch$()` method, and is not part of the public API.
+     * It takes a `TRequest` object as input, which represents the request data, and returns an `ObservableInput<TRequest>`,
+     * which can be used to further process the request before it is executed.
+     *
+     * @param init The request data to be processed.
+     * @returns An `ObservableInput<TRequest>` that represents the processed request.
+     */
     protected _prepareRequest(init: TRequest): ObservableInput<TRequest> {
         return this.requestHandler.process(init);
     }
 
+    /**
+     * Prepares the response by passing it through the `responseHandler.process()` method.
+     * This method is an implementation detail of the `_fetch$()` method, and is not part of the public API.
+     * It takes a `TResponse` object as input, which represents the response data, and returns an `ObservableInput<TResponse>`,
+     * which can be used to further process the response before it is returned.
+     *
+     * @param response The response data to be processed.
+     * @returns An `ObservableInput<TResponse>` that represents the processed response.
+     */
     protected _prepareResponse(response: TResponse): ObservableInput<TResponse> {
         return this.responseHandler.process(response);
     }
 
+    /**
+     * Resolves the full URL for a given path by combining it with the base URL.
+     * This is a protected method and is an implementation detail of the `HttpClient` class.
+     *
+     * @param path - The path to be resolved.
+     * @returns The full URL for the given path.
+     */
     protected _resolveUrl(path: string): string {
         const baseUrl = this.uri || window.location.origin;
         return new URL(path, baseUrl).href;

package/src/lib/client/types.ts

@@ -1,41 +1,109 @@
 import type { ObservableInput, Observable } from 'rxjs';
 import type { IHttpRequestHandler, IHttpResponseHandler } from '../operators/types';
 
+/**
+ * Represents a stream of response data.
+ * @template T - The type of the response data.
+ */
 export type StreamResponse<T> = Observable<T>;
 
+/**
+ * A function that takes a `Response` object and returns an `ObservableInput` of type `T`.
+ *
+ * @template TResult - The type of the data contained in the response.
+ * @template TResponse - The type of the response object.
+ * @param response - The `Response` object to be processed.
+ * @returns An `ObservableInput` of type `T`.
+ */
+export type ResponseSelector<TResult = unknown, TResponse = Response> = (
+    response: TResponse,
+) => ObservableInput<TResult>;
+
+/**
+ * Represents the parameters for a fetch request, including the URI and path.
+ * @property {string} uri - The URI of the request.
+ * @property {string} path - The path of the request.
+ */
 export type FetchRequest = RequestInit & {
     uri: string;
     path: string;
 };
 
+/**
+ * Represents a request with a JSON body.
+ * @template TRequest - The base request type, which extends `FetchRequest`.
+ * @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;
 };
 
+/**
+ * Represents the result of a blob operation, including the filename (if available) and the blob itself.
+ * @property {string} [filename] - The filename of the blob, if available.
+ * @property {Blob} blob - The blob data.
+ */
+export type BlobResult = { filename?: string; blob: Blob };
+
+/**
+ * Represents the response from a fetch request, including the response object and a JSON parsing method.
+ * @template T - The type of the response data.
+ * @property {Response} - The original Response object.
+ * @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>;
 };
 
+/**
+ * Represents the parameters for a fetch request, including the URI and path, as well as a selector function to transform the response.
+ * @template TReturn - The type of the transformed response data.
+ * @template TRequest - The type of the fetch request.
+ * @template TResponse - The type of the fetch response.
+ */
 export type FetchRequestInit<
     TReturn = unknown,
     TRequest = FetchRequest,
     TResponse = FetchResponse<TReturn>,
 > = Omit<TRequest, 'uri' | 'path'> & {
-    selector?: (response: TResponse) => ObservableInput<TReturn>;
+    /** response selector function */
+    selector?: ResponseSelector<TReturn, TResponse>;
 };
 
+/**
+ * Represents the parameters for a fetch request, including the URI and path, as well as a selector function to transform the response.
+ *
+ * @template TReturn - The type of the transformed response data.
+ * @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;
 
+/**
+ * Represents the available execution methods for an HTTP client.
+ */
 export type ExecutionMethod = 'fetch' | 'fetch$' | 'json' | 'json$';
 
+/**
+ * Represents the type of the parameters for the execution methods of an `IHttpClient` instance.
+ *
+ * @template TMethod - The execution method of the `IHttpClient` instance, e.g. 'fetch', 'json'.
+ * @template TClient - The type of the `IHttpClient` instance.
+ */
 export type ExecutionMethodParameters<
     TMethod extends ExecutionMethod = 'fetch',
     TClient extends IHttpClient = IHttpClient,
 > = Parameters<TClient[TMethod]>;
 
+/**
+ * Represents the type of the return value for the execution methods of an `IHttpClient` instance.
+ *
+ * @template TMethod - The execution method of the `IHttpClient` instance, e.g. 'fetch', 'json'.
+ * @template TClient - The type of the `IHttpClient` instance.
+ */
 export type ExecutionResponse<
     TMethod extends ExecutionMethod = 'fetch',
     TClient extends IHttpClient = IHttpClient,
@@ -47,50 +115,42 @@ export type ExecutionResponse<
  */
 export interface IHttpClient<TRequest extends FetchRequest = FetchRequest, TResponse = Response> {
     uri: string;
-    /** pre-processor of requests */
+    /**
+     * 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>;
-    /** post-processor of requests */
+
+    /**
+     * 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 request */
-    request$: Observable<TRequest>;
+    /**
+     * 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 */
-    response$: Observable<TResponse>;
+    /**
+     * 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>;
 
     /**
-     * Observable request.
-     * Simplifies execution of request and
-     * note: request will not be executed until subscribe!
+     * 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}
+     * @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}
-     * @example
-     * ```ts
-     * // Observer changes of a input field
-     * const client = modules.http.createClient('my-client');
-     * const input$ = fromEvent(document.getElementById('input'), 'input');
-     * input$.pipe(
-     *   // only call after no key input in .5s
-     *   debounceTime(500),
-     *   // extract value from event
-     *   map(x => x.currentTarget.value),
-     *   // only search when text longer than 2 characters
-     *   filter(x => x.length >=3),
-     *   // query api with input value
-     *   switchMap(x => client.fetch(`api/foo?q=${x}`).pipe(
-     *     // retry 2 times
-     *     retry(2)
-     *     // cancel request if new input
-     *     takeUntil(input$)
-     *   )),
-     *   // extract data from response
-     *   switchMap(x => x.json()),
-     *   // process error
-     *   catchError(x => of({error: e.message}))
-     * // write result to pre element
-     * ).subscribe(console.log);
-     * ```
      */
     fetch$<T = TResponse>(
         path: string,
@@ -98,46 +158,50 @@ export interface IHttpClient<TRequest extends FetchRequest = FetchRequest, TResp
     ): StreamResponse<T>;
 
     /**
-     * Fetch a resource as an promise
-     * @see {@link https://developer.mozilla.org/en-US/docs/Web/API/Fetch_API/Using_Fetch|fetch}
-     * @example
-     * ```ts
-     * let controller: AbortController;
-     * const client = window.Fusion.createClient('my-client');
-     * const input = document.getElementById('input');
-     * input.addEventlistener('input', (e) => {
-     *  try{
-     *    // if a controller is defined, request might be ongoing
-     *    controller && controller.abort();
-     *    // create a new abort controller
-     *    controller = new AbortController();
-     *    // query api with
-     *    const response = await client.fetch({
-     *      path: `api/foo?q=${e.currentTarget.value}`,
-     *      signal: controller.signal,
-     *    });
-     *    const json = await response.json();
-     *    result.innerText = JSON.stringify(json, null, 2)
-     *  } catch(err){
-     *    result.innerText = 'an error occurred'
-     *  } finally{
-     *    delete controller;
-     *  }
-     * });
-     * ```
+     * 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>,
@@ -149,18 +213,32 @@ export interface IHttpClient<TRequest extends FetchRequest = FetchRequest, TResp
         args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
     ): Promise<T>;
 
-    blob(
+    /**
+     * 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<Blob, JsonRequest<TRequest>, TResponse>,
-    ): Promise<Blob>;
+        args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
+    ): Promise<T>;
 
-    blob$(
+    /**
+     * 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<Blob, JsonRequest<TRequest>, TResponse>,
-    ): StreamResponse<Blob>;
+        args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
+    ): StreamResponse<T>;
 
     /**
-     * Abort all ongoing request for current client
+     * Abort all ongoing requests for the current client.
      */
     abort(): void;
 }

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

@@ -4,13 +4,21 @@ import { requestOperatorHeader } from './request-operator-header';
 import type { FetchRequest } from '../client';
 
 /**
- * Extends @see {ProcessOperators} for pre-processing requests.
+ * Extends the `ProcessOperators` class to handle HTTP requests.
+ *
+ * This class provides a method to set a header that will apply to all requests made by the `HttpClient`.
+ *
+ * @see {@link ProcessOperators}
+ *
+ * @template T - The type of the fetch request, which extends `FetchRequest`.
  */
 export class HttpRequestHandler<T extends FetchRequest = FetchRequest> extends ProcessOperators<T> {
     /**
-     * Set header that will apply on all requests done by consumer @see {HttpClient}
-     * @param key - name of header
-     * @param value  - header value
+     * 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);

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

@@ -1,5 +1,11 @@
 import { ProcessOperators } from './process-operators';
 
+/**
+ * The `HttpResponseHandler` class extends the `ProcessOperators` class and is responsible for handling HTTP responses.
+ * It provides a common interface for processing HTTP responses, allowing for consistent error handling and response transformation.
+ *
+ * @template T - The type of the HTTP response. Defaults to `Response`.
+ */
 export class HttpResponseHandler<T = Response> extends ProcessOperators<T> {}
 
 export default HttpResponseHandler;

package/src/lib/operators/process-operators.ts

@@ -6,15 +6,20 @@ import { IProcessOperators, ProcessOperator } from './types';
 /**
  * ProcessOperators class manages a collection of process operators
  * and provides methods to add, set, get, and process these operators.
+ * It implements the IProcessOperators interface for type T.
+ *
+ * @template T The type of data that the process operators work with
  */
 export class ProcessOperators<T> implements IProcessOperators<T> {
     /**
      * A record of process operators keyed by a string.
+     * This property is used to store and manage the collection of process operators
+     * that are used by the `ProcessOperators` class.
      */
     protected _operators: Record<string, ProcessOperator<T>>;
 
     /**
-     * Accessor for the operators.
+     * Accessor for the collection of process operators.
      * @returns The record of process operators.
      */
     get operators(): Record<string, ProcessOperator<T>> {

package/src/lib/operators/request-operator-header.ts

@@ -1,6 +1,13 @@
 import type { FetchRequest } from '../client';
 import type { ProcessOperator } from './types';
 
+/**
+ * Creates a process operator that adds a header to the request.
+ *
+ * @param key - The header key to add.
+ * @param value - The header value to add.
+ * @returns A process operator that adds the specified header to the request.
+ */
 export const requestOperatorHeader =
     <T extends FetchRequest = FetchRequest>(key: string, value: string): ProcessOperator<T> =>
     (request) => {