@equinor/fusion-framework-module-http 8.1.0 → 8.1.1

package/src/lib/client/client.ts

@@ -1,496 +0,0 @@
-import { finalize, firstValueFrom, of, Subject } from 'rxjs';
-import { switchMap, take, takeUntil, tap } from 'rxjs/operators';
-import { fromFetch } from 'rxjs/fetch';
-
-import { HttpMiddlewareHandler, HttpRequestHandler, HttpResponseHandler } from '../operators';
-import { blobSelector, jsonSelector } from '../selectors';
-
-import type { Observable, ObservableInput } from 'rxjs';
-import type {
-  IHttpMiddlewareHandler,
-  IHttpRequestHandler,
-  IHttpResponseHandler,
-} from '../operators';
-import type {
-  BlobResult,
-  FetchRequest,
-  FetchRequestInit,
-  FetchResponse,
-  IHttpClient,
-  JsonRequest,
-  StreamResponse,
-} from './types';
-
-import { HttpResponseError } from '../../errors/index.js';
-import {
-  createSseSelector,
-  type ServerSentEvent,
-  type SseSelectorOptions,
-} from '../selectors/create-sse-selector';
-
-/**
- * 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,
-> = {
-  requestHandler: IHttpRequestHandler<TRequest>;
-  responseHandler: IHttpResponseHandler<TResponse>;
-  middlewareHandler: IHttpMiddlewareHandler;
-};
-
-/** Base http client for executing requests */
-export class HttpClient<
-  TRequest extends FetchRequest = FetchRequest,
-  TResponse extends FetchResponse = FetchResponse,
-> implements IHttpClient<TRequest, TResponse>
-{
-  /**
-   * 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>;
-
-  /**
-   * 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>;
-
-  /**
-   * Middleware wrapping the network call, for cross-cutting concerns such as retries,
-   * caching, or telemetry. This property is part of the `HttpClientCreateOptions`
-   * configuration object used to create an `HttpClient` instance.
-   */
-  public readonly middlewareHandler: IHttpMiddlewareHandler;
-
-  /**
-   * 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>();
-
-  /**
-   * 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.
-   * @returns An `Observable` that emits each request before it is executed.
-   */
-  public get request$(): Observable<TRequest> {
-    return this._request$.asObservable();
-  }
-
-  /**
-   * A stream of responses that have been received.
-   * @returns An `Observable` that emits each response as it is received.
-   */
-  public get response$(): Observable<TResponse> {
-    return this._response$.asObservable();
-  }
-
-  /**
-   * Creates a new `HttpClient`.
-   * @param uri - The base URI used to resolve relative request paths.
-   * @param options - Optional request and response handlers.
-   */
-  constructor(
-    public uri: string,
-    options?: Partial<HttpClientCreateOptions<TRequest, TResponse>>,
-  ) {
-    this.requestHandler = new HttpRequestHandler<TRequest>(options?.requestHandler);
-    this.responseHandler = new HttpResponseHandler<TResponse>(options?.responseHandler);
-    this.middlewareHandler = new HttpMiddlewareHandler(options?.middlewareHandler);
-    this._init();
-  }
-
-  /**
-   * 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.
-   *
-   * @template T - The expected shape of the fetched data.
-   * @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>,
-  ): StreamResponse<T> {
-    return this._fetch$(path, args);
-  }
-
-  /**
-   * Fetches data from the specified path and returns a Promise containing the fetched data.
-   *
-   * @template T - The expected shape of 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>,
-  ): Promise<T> {
-    return firstValueFrom(this.fetch$<T>(path, args));
-  }
-
-  /**
-   * @deprecated Use {@link fetch} instead.
-   * @template T - The expected shape of 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 fetchAsync<T = TResponse>(
-    path: string,
-    args?: FetchRequestInit<T, TRequest, TResponse>,
-  ): Promise<T> {
-    return this.fetch(path, args);
-  }
-
-  /**
-   * Fetches data from the specified path and returns a stream response containing the data in JSON format.
-   *
-   * @template T - The expected shape of the parsed JSON data.
-   * @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>,
-  ): StreamResponse<T> {
-    const body = typeof args?.body === 'object' ? JSON.stringify(args?.body) : args?.body;
-    const selector = args?.selector ?? jsonSelector;
-    const headers = new Headers(args?.headers);
-    headers.append('Accept', 'application/json');
-    headers.append('Content-Type', 'application/json');
-    return this.fetch$(path, {
-      ...args,
-      body,
-      selector,
-      headers,
-    } as FetchRequestInit<T, TRequest, TResponse>);
-  }
-
-  /**
-   * Fetches data from the specified path and returns a Promise containing the fetched data in JSON format.
-   *
-   * @template T - The expected shape of the parsed JSON data.
-   * @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>,
-  ): Promise<T> {
-    return firstValueFrom(this.json$<T>(path, args));
-  }
-
-  /**
-   * Fetches a blob resource from the specified path and returns a stream response.
-   *
-   * @template T - The expected shape of the fetched blob data.
-   * @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<T, TRequest, TResponse>,
-  ): StreamResponse<T> {
-    // Get the selector value from the provided args, or use the default blobSelector
-    const selector = args?.selector ?? blobSelector;
-
-    // Create the FetchRequestInit object with the provided args and the selector
-    const init = {
-      ...args,
-      selector,
-    } as FetchRequestInit<T, TRequest, TResponse>;
-
-    // Call the fetch$ method with the provided path and the constructed init object
-    return this.fetch$(path, init);
-  }
-
-  /**
-   * Fetches a blob from the specified path and returns a Promise that resolves to the blob result.
-   *
-   * @template T - The expected shape of the fetched blob data.
-   * @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));
-  }
-
-  /**
-   * Initiates a Server-Sent Events (SSE) stream request to the specified path and returns a stream of events.
-   *
-   * @template T - The type of the event data expected from the SSE stream.
-   * @param path - The endpoint path to connect to for the SSE stream.
-   * @param args - Optional fetch request initialization options, including headers and abort signal.
-   * @param options - Optional selector options for customizing the SSE stream, excluding the abort signal.
-   *
-   * @returns A `StreamResponse` that emits `ServerSentEvent<T>` objects as they are received from the server.
-   *
-   * @example
-   * const sse$ = httpClient.sse$(
-   *   '/events',
-   *   { method: 'POST', body: JSON.stringify({ prompt: 'tell me a joke' }) },
-   *   { eventFilter: ['message'] },
-   * );
-   * sse$.subscribe({
-   *   next: (event) => console.log(event),
-   *   error: (err) => console.error(err),
-   *   complete: () => console.log('Completed'),
-   * });
-   */
-  public sse$<T = unknown>(
-    path: string,
-    args?: FetchRequestInit<ServerSentEvent<T>, TRequest, TResponse> | null,
-    options?: Omit<SseSelectorOptions<T>, 'abortSignal'>,
-  ): StreamResponse<ServerSentEvent<T>> {
-    // Setup default common headers for SSE
-    const headers = new Headers(args?.headers);
-    headers.append('Accept', 'text/event-stream');
-    headers.append('Content-Type', 'text/event-stream');
-    headers.append('Cache-Control', 'no-cache');
-    headers.append('Connection', 'keep-alive');
-
-    // Create the selector using the provided options and the abort signal from args
-    const selector = createSseSelector<T>({ ...options, abortSignal: args?.signal });
-
-    // Call the fetch$ method with the provided path and the constructed init object
-    return this._fetch$(path, { selector, ...args, headers } as FetchRequestInit<
-      ServerSentEvent<T>,
-      TRequest,
-      TResponse
-    >);
-  }
-
-  /**
-   * @deprecated Use {@link json} instead.
-   * @template T - The expected shape of the parsed JSON data.
-   * @param path - The path to fetch the data from.
-   * @param args - Optional request initialization options, including a custom selector function and request body.
-   * @returns A Promise containing the fetched data in JSON format.
-   */
-  public jsonAsync<T = unknown>(
-    path: string,
-    args?: FetchRequestInit<T, JsonRequest<TRequest>, TResponse>,
-  ): Promise<T> {
-    return this.json(path, args);
-  }
-
-  /**
-   * Executes an HTTP request using the specified method and path.
-   *
-   * @template T - The expected shape of the result.
-   * @template TMethod - The name of the `IHttpClient` method to invoke.
-   * @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,
-    init?: FetchRequestInit<T, TRequest, TResponse>,
-  ): ReturnType<IHttpClient[TMethod]> {
-    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, and abort the
-   * per-request `AbortSignal` passed through to `_performFetch`, so the
-   * underlying network call is cancelled even behind registered middleware.
-   */
-  public abort(): void {
-    this._abort$.next();
-  }
-
-  /**
-   * Fetches data from the specified path and returns an Observable that emits the response.
-   *
-   * @template T - The expected shape of the emitted data.
-   * @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.
-   *
-   * @throws {HttpResponseError} When the optional `selector` throws while transforming the response.
-   *
-   * 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>,
-  ): Observable<T> {
-    const { selector, ...options } = args || {};
-    // A registered middleware's `next(...)` resolves through a `Promise` (see
-    // `HttpMiddlewareHandler`), which `firstValueFrom` fulfils via its own independent
-    // subscription to `_performFetch` — one the `takeUntil(this._abort$)` below never reaches,
-    // since it sits outside the subscription tree that `takeUntil` tears down. Combining this
-    // controller's signal into the request `init` lets `_performFetch` (`fromFetch` by default)
-    // abort the underlying network call directly, regardless of whether middleware severed the
-    // RxJS teardown chain.
-    const abortController = new AbortController();
-    // abort only fires once per request; the subscription is torn down in `finalize` below
-    const abort = this._abort$.pipe(take(1)).subscribe(() => abortController.abort());
-    const callerSignal = (options as RequestInit).signal;
-    const signal = callerSignal
-      ? AbortSignal.any([callerSignal, abortController.signal])
-      : abortController.signal;
-    // `fromFetch` yields the raw fetch `Response`, but `responseHandler.process()` (called via
-    // `_prepareResponse`) expects the pipeline's generic `TResponse` shape — cast through
-    // `unknown` since the two are only compatible after that processing step.
-    const response$ = of({
-      ...options,
-      signal,
-      path,
-      uri: this._resolveUrl(path),
-    } as TRequest).pipe(
-      /** prepare request, allow extensions to modify request  */
-      switchMap((x) => this._prepareRequest(x)),
-      /** push request to event buss */
-      tap((x) => this._request$.next(x)),
-      /** execute request through registered middleware, terminating at _performFetch */
-      switchMap(({ uri, path: _path, ...init }) =>
-        this.middlewareHandler.process(uri, init, (u, i) => this._performFetch(u, i)),
-      ),
-      /** prepare response, allow extensions to modify response  */
-      switchMap((x) => this._prepareResponse(x as unknown as TResponse)),
-      /** push response to event buss */
-      tap((x) => this._response$.next(x)),
-
-      /** execute selector */
-      switchMap((response) => {
-        // only run the selector when one was provided; otherwise pass the response through untouched
-        if (selector) {
-          try {
-            return selector(response);
-          } catch (err) {
-            throw new HttpResponseError(
-              'failed to execute response selector',
-              response as Response,
-              {
-                cause: err,
-              },
-            );
-          }
-        }
-        return of(response);
-      }),
-      /** cancel request on abort signal */
-      takeUntil(this._abort$),
-      /** the abort signal subscription only ever fires once; tear it down once this request settles either way */
-      finalize(() => abort.unsubscribe()),
-    );
-    // The pipe above resolves to the per-call generic `T` (via the optional `selector`), but
-    // the observable's static type tracks the class-level `TResponse` — cast to the caller's `T`.
-    return response$ as unknown as Observable<T>;
-  }
-
-  /**
-   * Performs the actual network call for a prepared request.
-   *
-   * @remarks
-   * Isolated from {@link _fetch$} so a test double can replace only this step —
-   * matching a request against registered route handlers instead of reaching
-   * the network — while everything around it (request preparation, the
-   * response pipeline, abort handling) runs unchanged. See
-   * `@equinor/fusion-framework-module-http/mock`.
-   *
-   * @param uri - The fully resolved URL for the request.
-   * @param init - The prepared `fetch` request options.
-   * @returns An observable of the raw `Response`, ahead of {@link _prepareResponse}.
-   */
-  protected _performFetch(uri: string, init: RequestInit): ObservableInput<Response> {
-    return fromFetch(uri, init);
-  }
-
-  /**
-   * 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 { origin, pathname: basePath } = new URL(
-      this.uri,
-      this.uri.startsWith('http') ? undefined : window.location.origin,
-    );
-    const pathname = [basePath, path].join('/').replace(/\/{2,}/g, '/');
-    return new URL(pathname, origin).href;
-  }
-}

package/src/lib/client/index.ts

@@ -1,4 +0,0 @@
-export { HttpClient } from './client';
-export { HttpClientMsal } from './client-msal';
-
-export * from './types';