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

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

@@ -1,7 +1,7 @@
 import { from, of } from 'rxjs';
 import type { Observable } from 'rxjs';
 import { last, mergeScan } from 'rxjs/operators';
-import { IProcessOperators, ProcessOperator } from './types';
+import type { IProcessOperators, ProcessOperator } from './types';
 
 /**
  * ProcessOperators class manages a collection of process operators
@@ -11,100 +11,100 @@ import { IProcessOperators, ProcessOperator } from './types';
  * @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>>;
+  /**
+   * 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 collection of process operators.
-     * @returns The record of process operators.
-     */
-    get operators(): Record<string, ProcessOperator<T>> {
-        return this._operators;
-    }
+  /**
+   * Accessor for the collection of process operators.
+   * @returns The record of process operators.
+   */
+  get operators(): Record<string, ProcessOperator<T>> {
+    return this._operators;
+  }
 
-    /**
-     * Constructs a new instance of the ProcessOperators class.
-     * @param operators - An optional object containing process operators.
-     *                    It can be either an instance of IProcessOperators<T> or a record of string keys and ProcessOperator<T> values.
-     */
-    constructor(operators?: IProcessOperators<T> | Record<string, ProcessOperator<T>>) {
-        if (operators && 'operators' in operators) {
-            this._operators = { ...operators.operators };
-        } else {
-            this._operators = operators ?? {};
-        }
+  /**
+   * Constructs a new instance of the ProcessOperators class.
+   * @param operators - An optional object containing process operators.
+   *                    It can be either an instance of IProcessOperators<T> or a record of string keys and ProcessOperator<T> values.
+   */
+  constructor(operators?: IProcessOperators<T> | Record<string, ProcessOperator<T>>) {
+    if (operators && 'operators' in operators) {
+      this._operators = { ...operators.operators };
+    } else {
+      this._operators = operators ?? {};
     }
+  }
 
-    /**
-     * Adds a new operator to the collection.
-     * @param key The key under which the operator is stored.
-     * @param operator The operator to be added.
-     * @returns The instance of ProcessOperators for chaining.
-     * @throws Error if an operator with the same key already exists.
-     */
-    add(key: string, operator: ProcessOperator<T>): ProcessOperators<T> {
-        if (Object.keys(this._operators).includes(key))
-            throw Error(`Operator [${key}] already defined`);
-        return this.set(key, operator);
-    }
+  /**
+   * Adds a new operator to the collection.
+   * @param key The key under which the operator is stored.
+   * @param operator The operator to be added.
+   * @returns The instance of ProcessOperators for chaining.
+   * @throws Error if an operator with the same key already exists.
+   */
+  add(key: string, operator: ProcessOperator<T>): ProcessOperators<T> {
+    if (Object.keys(this._operators).includes(key))
+      throw Error(`Operator [${key}] already defined`);
+    return this.set(key, operator);
+  }
 
-    /**
-     * Sets or updates an operator in the collection.
-     * @param key The key under which the operator is stored.
-     * @param operator The operator to be set.
-     * @returns The instance of ProcessOperators for chaining.
-     */
-    set(key: string, operator: ProcessOperator<T>): ProcessOperators<T> {
-        this._operators[key] = operator;
-        return this;
-    }
+  /**
+   * Sets or updates an operator in the collection.
+   * @param key The key under which the operator is stored.
+   * @param operator The operator to be set.
+   * @returns The instance of ProcessOperators for chaining.
+   */
+  set(key: string, operator: ProcessOperator<T>): ProcessOperators<T> {
+    this._operators[key] = operator;
+    return this;
+  }
 
-    /**
-     * Removes an operator from the collection by its key.
-     *
-     * @param key - The key of the operator to remove.
-     * @returns The current instance of `ProcessOperators` for method chaining.
-     */
-    remove(key: string): ProcessOperators<T> {
-        delete this._operators[key];
-        return this;
-    }
+  /**
+   * Removes an operator from the collection by its key.
+   *
+   * @param key - The key of the operator to remove.
+   * @returns The current instance of `ProcessOperators` for method chaining.
+   */
+  remove(key: string): ProcessOperators<T> {
+    delete this._operators[key];
+    return this;
+  }
 
-    /**
-     * Retrieves an operator from the collection by its key.
-     * @param key The key of the operator to retrieve.
-     * @returns The retrieved operator.
-     */
-    get(key: string): ProcessOperator<T> {
-        return this._operators[key];
-    }
+  /**
+   * Retrieves an operator from the collection by its key.
+   * @param key The key of the operator to retrieve.
+   * @returns The retrieved operator.
+   */
+  get(key: string): ProcessOperator<T> {
+    return this._operators[key];
+  }
 
-    /**
-     * Processes an input request through the chain of operators.
-     * @param request The request to be processed.
-     * @returns An Observable of the processed request.
-     */
-    process(request: T): Observable<T> {
-        const operators = Object.values(this._operators);
-        /** if no operators registered, just return the observable value */
-        if (!operators.length) {
-            return of(request);
-        }
-        return from(Object.values(this._operators)).pipe(
-            mergeScan(
-                // resolve current operator and return result or previous if void
-                (value, operator) => Promise.resolve(operator(value)).then((x) => x ?? value),
-                // initial value
-                request,
-                // only allow concurrency of one operator
-                1,
-            ),
-            // output result of last operator
-            last(),
-        );
+  /**
+   * Processes an input request through the chain of operators.
+   * @param request The request to be processed.
+   * @returns An Observable of the processed request.
+   */
+  process(request: T): Observable<T> {
+    const operators = Object.values(this._operators);
+    /** if no operators registered, just return the observable value */
+    if (!operators.length) {
+      return of(request);
     }
+    return from(Object.values(this._operators)).pipe(
+      mergeScan(
+        // resolve current operator and return result or previous if void
+        (value, operator) => Promise.resolve(operator(value)).then((x) => x ?? value),
+        // initial value
+        request,
+        // only allow concurrency of one operator
+        1,
+      ),
+      // output result of last operator
+      last(),
+    );
+  }
 }

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

@@ -9,11 +9,11 @@ import type { ProcessOperator } from './types';
  * @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) => {
-        const headers = new Headers(request.headers);
-        headers.append(key, value);
-        return { ...request, headers };
-    };
+  <T extends FetchRequest = FetchRequest>(key: string, value: string): ProcessOperator<T> =>
+  (request) => {
+    const headers = new Headers(request.headers);
+    headers.append(key, value);
+    return { ...request, headers };
+  };
 
 export default requestOperatorHeader;

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

@@ -1,4 +1,4 @@
-import { z } from 'zod';
+import type { z } from 'zod';
 import type { ProcessOperator } from './types';
 import type { FetchRequest } from '../client/types';
 import { fetchRequestSchema } from './fetch-request.schema';
@@ -17,34 +17,34 @@ import { fetchRequestSchema } from './fetch-request.schema';
  * @throws Will log an error message if the request validation fails.
  */
 export const requestValidationOperator =
-    <T extends FetchRequest>(options?: {
-        /**
-         * When enabled, the function will return the parsed result.
-         * This means that if the request object passes validation,
-         * the parsed and potentially transformed request object will be returned.
-         * If this option is not enabled, the function will not return anything
-         * even if the request object is valid.
-         */
-        parse?: boolean;
-        /**
-         * When set to true, the validation will be strict, meaning that any additional properties
-         * not defined in the schema will cause the validation to fail. If set to false or omitted,
-         * additional properties will be allowed and passed through without causing validation errors.
-         *
-         * @note this option is only applicable when the `parse` option is enabled.
-         */
-        strict?: boolean;
-    }): ProcessOperator<T> =>
-    (request) => {
-        const { strict, parse } = options ?? {};
-        const schema = strict ? fetchRequestSchema : fetchRequestSchema.passthrough();
-        try {
-            const result = schema.parse(request) as T;
-            return parse ? result : void 0;
-        } catch (error) {
-            if (parse) {
-                throw error;
-            }
-            console.error('Invalid request options', (error as z.ZodError).message);
-        }
-    };
+  <T extends FetchRequest>(options?: {
+    /**
+     * When enabled, the function will return the parsed result.
+     * This means that if the request object passes validation,
+     * the parsed and potentially transformed request object will be returned.
+     * If this option is not enabled, the function will not return anything
+     * even if the request object is valid.
+     */
+    parse?: boolean;
+    /**
+     * When set to true, the validation will be strict, meaning that any additional properties
+     * not defined in the schema will cause the validation to fail. If set to false or omitted,
+     * additional properties will be allowed and passed through without causing validation errors.
+     *
+     * @note this option is only applicable when the `parse` option is enabled.
+     */
+    strict?: boolean;
+  }): ProcessOperator<T> =>
+  (request) => {
+    const { strict, parse } = options ?? {};
+    const schema = strict ? fetchRequestSchema : fetchRequestSchema.passthrough();
+    try {
+      const result = schema.parse(request) as T;
+      return parse ? result : void 0;
+    } catch (error) {
+      if (parse) {
+        throw error;
+      }
+      console.error('Invalid request options', (error as z.ZodError).message);
+    }
+  };

package/src/lib/operators/types.ts

@@ -18,48 +18,48 @@ export type ProcessOperator<T, R = T> = (request: T) => R | void | Promise<R | v
  * @template T The type of the request being processed.
  */
 export interface IProcessOperators<T> {
-    /**
-     * Gets the operators registered in the collection.
-     */
-    get operators(): Record<string, ProcessOperator<T>>;
+  /**
+   * Gets the operators registered in the collection.
+   */
+  get operators(): Record<string, ProcessOperator<T>>;
 
-    /**
-     * Adds a new operator to the collection.
-     * @param key The key to identify the operator.
-     * @param operator The process operator to add.
-     * @returns The updated collection of process operators.
-     * @throws An error if the operator is already defined.
-     */
-    add(key: string, operator: ProcessOperator<T>): IProcessOperators<T>;
+  /**
+   * Adds a new operator to the collection.
+   * @param key The key to identify the operator.
+   * @param operator The process operator to add.
+   * @returns The updated collection of process operators.
+   * @throws An error if the operator is already defined.
+   */
+  add(key: string, operator: ProcessOperator<T>): IProcessOperators<T>;
 
-    /**
-     * Adds or sets a process operator in the collection.
-     * @param key The key to identify the operator.
-     * @param operator The process operator to add or set.
-     * @returns The updated collection of process operators.
-     */
-    set(key: string, operator: ProcessOperator<T>): IProcessOperators<T>;
+  /**
+   * Adds or sets a process operator in the collection.
+   * @param key The key to identify the operator.
+   * @param operator The process operator to add or set.
+   * @returns The updated collection of process operators.
+   */
+  set(key: string, operator: ProcessOperator<T>): IProcessOperators<T>;
 
-    /**
-     * Removes a process operator from the collection.
-     * @param key The key of the operator to remove.
-     * @returns The updated collection of process operators.
-     */
-    remove(key: string): IProcessOperators<T>;
+  /**
+   * Removes a process operator from the collection.
+   * @param key The key of the operator to remove.
+   * @returns The updated collection of process operators.
+   */
+  remove(key: string): IProcessOperators<T>;
 
-    /**
-     * Gets a process operator from the collection.
-     * @param key The key of the operator to retrieve.
-     * @returns The process operator associated with the key, or undefined if the key is invalid.
-     */
-    get(key: string): ProcessOperator<T>;
+  /**
+   * Gets a process operator from the collection.
+   * @param key The key of the operator to retrieve.
+   * @returns The process operator associated with the key, or undefined if the key is invalid.
+   */
+  get(key: string): ProcessOperator<T>;
 
-    /**
-     * Processes the registered process operators.
-     * @param request The request to process.
-     * @returns An observable that emits the processed request.
-     */
-    process(request: T): Observable<T>;
+  /**
+   * Processes the registered process operators.
+   * @param request The request to process.
+   * @returns An observable that emits the processed request.
+   */
+  process(request: T): Observable<T>;
 }
 
 /**
@@ -69,13 +69,13 @@ export interface IProcessOperators<T> {
  * @template T - The type of the request being processed. Defaults to `FetchRequest`.
  */
 export interface IHttpRequestHandler<T extends FetchRequest = FetchRequest>
-    extends IProcessOperators<T> {
-    /**
-     * Set header that will apply on all requests done by consumer @see {HttpClient}
-     * @param key - name of header
-     * @param value  - header value
-     */
-    setHeader(key: string, value: string): IHttpRequestHandler<T>;
+  extends IProcessOperators<T> {
+  /**
+   * Set header that will apply on all requests done by consumer @see {HttpClient}
+   * @param key - name of header
+   * @param value  - header value
+   */
+  setHeader(key: string, value: string): IHttpRequestHandler<T>;
 }
 
 /**

package/src/lib/selectors/blob-selector.ts

@@ -8,34 +8,34 @@ import type { ResponseSelector, BlobResult } from '../client/types';
  * @throws {Error} If the response is not successful or if there is an error parsing the response.
  */
 export const blobSelector: ResponseSelector = async <TResponse extends Response = Response>(
-    response: TResponse,
+  response: TResponse,
 ): Promise<BlobResult> => {
-    if (!response.ok) {
-        // Throw an error if the network response is not successful
-        throw new Error('network response was not OK');
-    }
+  if (!response.ok) {
+    // Throw an error if the network response is not successful
+    throw new Error('network response was not OK');
+  }
 
-    // Status code 204 indicates no content, so throw an error
-    if (response.status === 204) {
-        throw new Error('no content');
-    }
+  // Status code 204 indicates no content, so throw an error
+  if (response.status === 204) {
+    throw new Error('no content');
+  }
 
-    // Extract the filename from the 'content-disposition' header
-    const filename = response.headers
-        .get('content-disposition')
-        ?.split(';')
-        .find((n) => n.includes('filename='))
-        ?.replace('filename=', '')
-        ?.trim();
+  // Extract the filename from the 'content-disposition' header
+  const filename = response.headers
+    .get('content-disposition')
+    ?.split(';')
+    .find((n) => n.includes('filename='))
+    ?.replace('filename=', '')
+    ?.trim();
 
-    try {
-        // Convert the response to a Blob and return the filename and Blob
-        const blob = await response.blob();
-        return { filename, blob };
-    } catch (err) {
-        // Throw an error if there's a problem parsing the response
-        throw Error('failed to parse response');
-    }
+  try {
+    // Convert the response to a Blob and return the filename and Blob
+    const blob = await response.blob();
+    return { filename, blob };
+  } catch (err) {
+    // Throw an error if there's a problem parsing the response
+    throw Error('failed to parse response');
+  }
 };
 
 export default blobSelector;

package/src/lib/selectors/json-selector.ts

@@ -16,37 +16,37 @@ import { HttpJsonResponseError } from '../../errors';
  * @returns A promise that resolves with the parsed JSON data, or rejects with an `HttpJsonResponseError`.
  */
 export const jsonSelector: ResponseSelector = async <
-    TType = unknown,
-    TResponse extends Response = Response,
+  TType = unknown,
+  TResponse extends Response = Response,
 >(
-    response: TResponse,
+  response: TResponse,
 ): Promise<TType> => {
-    /** Status code 204 indicates no content in the response */
-    if (response.status === 204) {
-        return Promise.resolve() as Promise<TType>;
-    }
-
-    try {
-        // Parse the response JSON data
-        const data = await response.json();
+  /** Status code 204 indicates no content in the response */
+  if (response.status === 204) {
+    return Promise.resolve() as Promise<TType>;
+  }
 
-        // Check if the response was successful
-        if (!response.ok) {
-            // Throw an error with the response details
-            throw new HttpJsonResponseError('network response was not OK', response, { data });
-        }
+  try {
+    // Parse the response JSON data
+    const data = await response.json();
 
-        // Return the parsed data
-        return data;
-    } catch (cause) {
-        // If the cause is an HttpJsonResponseError, rethrow it
-        if (cause instanceof HttpJsonResponseError) {
-            throw cause;
-        }
+    // Check if the response was successful
+    if (!response.ok) {
+      // Throw an error with the response details
+      throw new HttpJsonResponseError('network response was not OK', response, { data });
+    }
 
-        // Otherwise, throw a new HttpJsonResponseError with the parsing error
-        throw new HttpJsonResponseError('failed to parse response', response, { cause });
+    // Return the parsed data
+    return data;
+  } catch (cause) {
+    // If the cause is an HttpJsonResponseError, rethrow it
+    if (cause instanceof HttpJsonResponseError) {
+      throw cause;
     }
+
+    // Otherwise, throw a new HttpJsonResponseError with the parsing error
+    throw new HttpJsonResponseError('failed to parse response', response, { cause });
+  }
 };
 
 export default jsonSelector;