@equinor/fusion-framework-module-http 8.1.0-next.0 → 8.1.1

package/src/configurator.ts

@@ -1,249 +0,0 @@
-import {
-  capitalizeRequestMethodOperator,
-  requestValidationOperator,
-  HttpMiddlewareHandler,
-  HttpRequestHandler,
-} from './lib/operators';
-
-import type { FetchRequest, IHttpClient } from './lib/client';
-import type {
-  HttpMiddleware,
-  IHttpMiddlewareHandler,
-  IHttpRequestHandler,
-  IHttpResponseHandler,
-} from './lib/operators';
-
-/**
- * Represents the options for constructing an `IHttpClient` instance.
- *
- * @template TInit - The type of the initial request object used by the `IHttpClient` instance.
- * @template TResponse - The type of the response object used by the `IHttpClient` instance.
- * @property {IHttpRequestHandler<TInit>} requestHandler - The request handler to be used by the `IHttpClient` instance.
- * @property {IHttpResponseHandler<TResponse>} [responseHandler] - The response handler to be used by the `IHttpClient` instance.
- */
-interface HttpClientConstructorOptions<TInit extends FetchRequest, TResponse = Response> {
-  requestHandler: IHttpRequestHandler<TInit>;
-  responseHandler?: IHttpResponseHandler<TResponse>;
-}
-
-/**
- * Represents a constructor for an `IHttpClient` instance.
- *
- * @template TClient - The type of the `IHttpClient` instance to be constructed.
- * @param uri - The base URI for the `IHttpClient` instance.
- * @param options - The options for constructing the `IHttpClient` instance, including the request handler.
- * @returns A new instance of the `TClient` type.
- */
-interface HttpClientConstructor<TClient extends IHttpClient> {
-  new (
-    uri: string,
-    options: HttpClientConstructorOptions<
-      HttpClientRequestInitType<TClient>,
-      HttpClientResponseType<TClient>
-    >,
-  ): TClient;
-}
-
-/**
- * Configures how the provider creates a named `IHttpClient` instance.
- *
- * Use these options to define a base URL, MSAL scopes, shared request or response handlers,
- * a custom client constructor, or per-instance setup through `onCreate`.
- *
- * @template TClient - The client type created from this configuration.
- */
-export interface HttpClientOptions<TClient extends IHttpClient = IHttpClient> {
-  /** The base URI for the `IHttpClient` instance. */
-  baseUri?: string;
-
-  /** The default scopes to be used by the `IHttpClient` instance. */
-  defaultScopes?: string[];
-
-  /** The constructor for the `TClient` type. */
-  ctor?: HttpClientConstructor<TClient>;
-
-  /** A callback function that is called when a new `TClient` instance is created. */
-  onCreate?: (client: TClient) => void;
-
-  /** The request handler to be used by the `IHttpClient` instance. */
-  requestHandler?: IHttpRequestHandler<HttpClientRequestInitType<TClient>>;
-
-  /** The response handler to be used by the `IHttpClient` instance. */
-  responseHandler?: IHttpResponseHandler<HttpClientResponseType<TClient>>;
-
-  /**
-   * Middleware wrapping the network call, overriding {@link HttpClientConfigurator.addMiddleware}
-   * for this client only. Rarely needed — most middleware belongs on the configurator so it
-   * applies to every client, and still runs the same way against a mocked client in tests.
-   */
-  middlewareHandler?: IHttpMiddlewareHandler;
-}
-
-/**
- * Utility type that extracts the request init type from an `IHttpClient` implementation.
- * This is useful for ensuring type safety when configuring an `IHttpClient` instance.
- *
- * @template T - The type of the `IHttpClient` implementation.
- * @returns The request init type for the `IHttpClient` implementation.
- */
-export type HttpClientRequestInitType<T extends IHttpClient> =
-  T extends IHttpClient<infer U> ? U : never;
-
-/**
- * Utility type that extracts the response type from an `IHttpClient` implementation.
- * This is useful for ensuring type safety when configuring response handlers for an `IHttpClient` instance.
- *
- * @template T - The type of the `IHttpClient` implementation.
- * @returns The response type for the `IHttpClient` implementation.
- */
-export type HttpClientResponseType<T extends IHttpClient> =
-  T extends IHttpClient<infer _TRequest, infer TResponse> ? TResponse : never;
-
-/**
- * Registers and looks up named HTTP client configurations for the HTTP module.
- *
- * Each named configuration can later be turned into a fresh client instance by the provider.
- *
- * @template TClient - The base client type the provider creates.
- */
-export interface IHttpClientConfigurator<TClient extends IHttpClient = IHttpClient> {
-  readonly clients: Record<string, HttpClientOptions<TClient>>;
-  readonly defaultHttpClientCtor: HttpClientConstructor<TClient>;
-  readonly defaultHttpRequestHandler: IHttpRequestHandler<HttpClientRequestInitType<TClient>>;
-  readonly defaultHttpMiddlewareHandler: IHttpMiddlewareHandler;
-
-  /**
-   * Registers middleware wrapping the network call for every client this configurator builds —
-   * retries, caching, telemetry, circuit breaking. Register it wherever the app configures its
-   * real HTTP clients; because it wraps `_performFetch` rather than replacing it, the same
-   * registration still runs, unaltered, against a mocked client in tests.
-   * @param middleware - The middleware to register.
-   * @returns The configurator so registrations can be chained.
-   * @example
-   * ```ts
-   * configurator.http.addMiddleware(async (uri, init, next) => {
-   *   const response = await next(uri, init);
-   *   return response.ok ? response : next(uri, init);
-   * });
-   * ```
-   */
-  addMiddleware(middleware: HttpMiddleware): IHttpClientConfigurator<TClient>;
-
-  /**
-   * Registers or updates a named client configuration.
-   * @param name - The client key used later with `createClient(name)`.
-   * @param args - The configuration used when creating a client instance.
-   * @returns The configurator so registrations can be chained.
-   * @example
-   * ```ts
-   * configurator.http.configureClient('catalog', {
-   *   baseUri: 'https://api.example.com',
-   *   defaultScopes: ['api://catalog-api/.default'],
-   * });
-   * ```
-   */
-  configureClient<T extends TClient>(
-    name: string,
-    args: HttpClientOptions<T>,
-  ): IHttpClientConfigurator<TClient>;
-
-  /**
-   * Registers a named client with only a base URI.
-   * @param name - The client key used later with `createClient(name)`.
-   * @param uri - The base endpoint for the client.
-   * @returns The configurator so registrations can be chained.
-   */
-  configureClient(name: string, uri: string): IHttpClientConfigurator<TClient>;
-
-  /**
-   * Registers a named client using only an `onCreate` callback.
-   * @param name - The client key used later with `createClient(name)`.
-   * @param onCreate - The callback that runs for every created client instance.
-   * @returns The configurator so registrations can be chained.
-   * @example
-   * ```ts
-   * configurator.http.configureClient('catalog', (client) => {
-   *   client.requestHandler.add('logger', (request) => console.log(request));
-   * });
-   * ```
-   */
-  configureClient<T extends TClient>(
-    name: string,
-    onCreate: (client: T) => void,
-  ): HttpClientConfigurator<TClient>;
-
-  /**
-   * Checks whether a named client configuration exists.
-   * @param name - The client key to check.
-   * @returns `true` when a configuration exists for the key.
-   */
-  hasClient(name: string): boolean;
-}
-
-/** @inheritdoc */
-export class HttpClientConfigurator<TClient extends IHttpClient>
-  implements IHttpClientConfigurator<TClient>
-{
-  /** Named client configurations keyed by client name. */
-  protected _clients: Record<string, HttpClientOptions<TClient>> = {};
-
-  /**
-   * Gets a shallow clone of all named client configurations.
-   *
-   * @returns A shallow clone of the named client configurations.
-   */
-  public get clients(): Record<string, HttpClientOptions<TClient>> {
-    return { ...this._clients };
-  }
-
-  /** Default constructor used when a client configuration does not provide `ctor`. */
-  readonly defaultHttpClientCtor: HttpClientConstructor<TClient>;
-
-  /** Default request handler pipeline cloned into each created client instance. */
-  readonly defaultHttpRequestHandler = new HttpRequestHandler<HttpClientRequestInitType<TClient>>({
-    // convert all request methods to uppercase
-    'capitalize-method': capitalizeRequestMethodOperator(),
-    // validate the request object
-    'request-validation': requestValidationOperator(),
-  });
-
-  /** Default middleware chain cloned into each created client instance. */
-  readonly defaultHttpMiddlewareHandler: IHttpMiddlewareHandler = new HttpMiddlewareHandler();
-
-  /**
-   * Creates a configurator with the default client constructor.
-   * @param client - The default client constructor used when `ctor` is not configured per client.
-   */
-  constructor(client: HttpClientConstructor<TClient>) {
-    this.defaultHttpClientCtor = client;
-  }
-
-  /** @inheritdoc */
-  hasClient(name: string): boolean {
-    return Object.keys(this._clients).includes(name);
-  }
-
-  /** @inheritdoc */
-  addMiddleware(middleware: HttpMiddleware): HttpClientConfigurator<TClient> {
-    this.defaultHttpMiddlewareHandler.use(middleware);
-    return this;
-  }
-
-  /** @inheritdoc */
-  configureClient<T extends TClient>(
-    name: string,
-    args: string | HttpClientOptions<T> | HttpClientOptions<T>['onCreate'],
-  ): HttpClientConfigurator<TClient> {
-    const argFn = typeof args === 'string' ? ({ baseUri: args } as HttpClientOptions<T>) : args;
-    const options = typeof argFn === 'function' ? { onCreate: argFn } : argFn;
-    // `options` is `HttpClientOptions<T>` (this call's generic), but `_clients` is keyed by the
-    // configurator's own `TClient` — callers are expected to keep the two in sync.
-    this._clients[name] = {
-      ...this._clients[name],
-      ...(options as unknown as HttpClientOptions<TClient>),
-    };
-    return this;
-  }
-}
-
-export default HttpClientConfigurator;

package/src/errors/ClientNotFoundException.ts

@@ -1,9 +0,0 @@
-/**
- * Thrown when `createClient(name)` is called with an unknown client key.
- *
- * This is only used when the provided string is neither a registered client name
- * nor an absolute `http:` or `https:` URL.
- */
-export class ClientNotFoundException extends Error {}
-
-export default ClientNotFoundException;

package/src/errors/HttpJsonResponseError.ts

@@ -1,32 +0,0 @@
-import { HttpResponseError } from './HttpResponseError.js';
-
-/**
- * Represents an error that occurs when handling a JSON response in an HTTP request.
- * Extends the base `HttpResponseError` class.
- *
- * @template TType - The type of the data associated with the error.
- * @template TResponse - The type of the HTTP response.
- */
-export class HttpJsonResponseError<
-  TType = unknown,
-  TResponse = Response,
-> extends HttpResponseError<TResponse> {
-  static Name = 'HttpJsonResponseError';
-  /** The parsed JSON data associated with the error response, if any. */
-  public readonly data?: TType;
-
-  /**
-   * Creates a new instance of `HttpJsonResponseError`.
-   *
-   * @param message - The error message.
-   * @param response - The HTTP response associated with the error.
-   * @param options - Additional options for the error, including the associated data.
-   */
-  constructor(message: string, response: TResponse, options?: ErrorOptions & { data?: TType }) {
-    super(message, response, options);
-    this.name = HttpJsonResponseError.Name;
-    this.data = options?.data;
-  }
-}
-
-export default HttpJsonResponseError;

package/src/errors/HttpResponseError.ts

@@ -1,21 +0,0 @@
-/**
- * Represents an error that occurs when handling an HTTP response.
- * @template TResponse The type of the HTTP response.
- */
-export class HttpResponseError<TResponse = Response> extends Error {
-  static Name = 'HttpResponseError';
-  /**
-   * @param message - The error message.
-   * @param response - The HTTP response associated with the error.
-   * @param options - Additional error options.
-   */
-  constructor(
-    message: string,
-    public readonly response: TResponse,
-    options?: ErrorOptions,
-  ) {
-    super(message, options);
-  }
-}
-
-export default HttpResponseError;

package/src/errors/ServerSentEventResponseError.ts

@@ -1,30 +0,0 @@
-import { HttpResponseError } from './HttpResponseError.js';
-
-/**
- * Represents an error that occurs when handling a server-sent event (SSE) HTTP response.
- *
- * @template TType - The type of additional data associated with the error.
- * @template TResponse - The type of the HTTP response object.
- *
- * @extends HttpResponseError<TResponse>
- */
-export class ServerSentEventResponseError<
-  TType = unknown,
-  TResponse = Response,
-> extends HttpResponseError<TResponse> {
-  static Name = 'ServerSentEventResponseError';
-
-  /**
-   * Creates a new instance of the error.
-   *
-   * @param message - The error message describing the cause of the error.
-   * @param response - The HTTP response associated with the error.
-   * @param options - Optional error options, which may include additional data of type `TType`.
-   */
-  constructor(message: string, response: TResponse, options?: ErrorOptions & { data?: TType }) {
-    super(message, response, options);
-    this.name = ServerSentEventResponseError.Name;
-  }
-}
-
-export default ServerSentEventResponseError;

package/src/errors/index.ts

@@ -1,4 +0,0 @@
-export * from './HttpResponseError.js';
-export * from './HttpJsonResponseError.js';
-export * from './ServerSentEventResponseError.js';
-export * from './ClientNotFoundException.js';

package/src/index.ts

@@ -1,15 +0,0 @@
-/**
- * [[include:module-http/README.MD]]
- * @module
- */
-
-export * from './configurator';
-export * from './provider';
-export * from './module';
-
-export * as Errors from './errors/index.js';
-export * from './errors/index.js';
-
-export type { IHttpClient, FetchResponse } from './lib/client';
-
-export { default } from './module';

package/src/lib/client/client-msal.ts

@@ -1,80 +0,0 @@
-import type { Observable } from 'rxjs';
-import type { FetchRequestInit, FetchRequest, FetchResponse } from '.';
-import { HttpClient } from './client';
-
-/**
- * Extends the `FetchRequest` type with an optional `scopes` property, which is an array of strings representing the scopes to be used for the request.
- * This type is used to represent a request that requires authentication using the MSAL (Microsoft Authentication Library) library.
- */
-type MsalFetchRequest = FetchRequest & { scopes?: string[] };
-
-/**
- * Extends the `FetchRequestInit` type with an optional `scopes` property, which is an array of strings representing the scopes to be used for the request.
- * This type is used to represent a request that requires authentication using the MSAL (Microsoft Authentication Library) library.
- *
- * @template TReturn - The type of the response object. Defaults to `unknown`.
- * @template TRequest - The type of the request object. Defaults to `FetchRequest`.
- * @template TResponse - The type of the response object. Defaults to `Response`.
- */
-type MsalFetchRequestInit<
-  TReturn = unknown,
-  TRequest = FetchRequest,
-  TResponse = FetchResponse,
-> = FetchRequestInit<TReturn, TRequest, TResponse> & Pick<MsalFetchRequest, 'scopes'>;
-
-/**
- * Extends the `HttpClient` class to provide MSAL (Microsoft Authentication Library) authentication support.
- *
- * The `HttpClientMsal` class is responsible for handling requests that require authentication using the MSAL library.
- * It extends the `HttpClient` class and adds the following functionality:
- *
- * - `defaultScopes`: An array of strings representing the default scopes to be used for all requests, unless overridden in the request object.
- * - `fetch$`: Overrides the `fetch$` method of the `HttpClient` class to add MSAL authentication support. It takes an optional `MsalFetchRequestInit` object, which can include the `scopes` property to specify the scopes to be used for the request.
- *   - If `scopes` is provided in the `MsalFetchRequestInit` object, it will be used in addition to the `defaultScopes`.
- *   - If `scopes` is not provided, only the `defaultScopes` will be used.
- *
- * @template TRequest - The type of the request object. Defaults to `MsalFetchRequest`.
- * @template TResponse - The type of the response object. Defaults to `FetchResponse`.
- */
-export class HttpClientMsal<
-  TRequest extends MsalFetchRequest = MsalFetchRequest,
-  TResponse extends FetchResponse = FetchResponse,
-> extends HttpClient<TRequest, TResponse> {
-  /**
-   * An array of default scopes to be used for all requests, unless overridden in the request object.
-   * This property is used by the `HttpClientMsal` class to add MSAL authentication support to requests.
-   */
-  public defaultScopes: string[] = [];
-
-  /**
-   * Fetches a resource from the specified path, with optional MSAL authentication scopes.
-   *
-   * This method extends the `HttpClient.fetch$` method to add support for MSAL authentication.
-   * If `init.scopes` is provided, it will be used in addition to the `defaultScopes` defined in the `HttpClientMsal` class.
-   * If `init.scopes` is not provided, only the `defaultScopes` will be used for the request.
-   *
-   * @overrides HttpClient.fetch$
-   *
-   * @template T - The expected response type.
-   * @param path - The path to the resource to fetch.
-   * @param init - An optional `MsalFetchRequestInit` object that can include the `scopes` property.
-   * @returns An `Observable` that emits the fetched resource.
-   */
-  public fetch$<T = TResponse>(
-    path: string,
-    init?: MsalFetchRequestInit<T, TRequest, TResponse>,
-  ): Observable<T> {
-    /**
-     * Merges the default scopes defined in the `HttpClientMsal` class with the scopes provided in the `init` parameter, if any.
-     * This ensures that the request includes the necessary scopes for MSAL authentication.
-     */
-    const args = {
-      ...init,
-      scopes: this.defaultScopes.concat(init?.scopes || []),
-    } as FetchRequestInit<T, TRequest, TResponse>;
-
-    return super._fetch$(path, args);
-  }
-}
-
-export default HttpClientMsal;