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

package/src/errors/HttpJsonResponseError.ts

@@ -12,6 +12,7 @@ export class HttpJsonResponseError<
   TResponse = Response,
 > extends HttpResponseError<TResponse> {
   static Name = 'HttpJsonResponseError';
+  /** The parsed JSON data associated with the error response, if any. */
   public readonly data?: TType;
 
   /**

package/src/lib/client/client.ts

@@ -1,12 +1,16 @@
-import { firstValueFrom, of, Subject } from 'rxjs';
-import { switchMap, takeUntil, tap } from 'rxjs/operators';
+import { finalize, firstValueFrom, of, Subject } from 'rxjs';
+import { switchMap, take, takeUntil, tap } from 'rxjs/operators';
 import { fromFetch } from 'rxjs/fetch';
 
-import { HttpRequestHandler, HttpResponseHandler } from '../operators';
+import { HttpMiddlewareHandler, HttpRequestHandler, HttpResponseHandler } from '../operators';
 import { blobSelector, jsonSelector } from '../selectors';
 
 import type { Observable, ObservableInput } from 'rxjs';
-import type { IHttpRequestHandler, IHttpResponseHandler } from '../operators';
+import type {
+  IHttpMiddlewareHandler,
+  IHttpRequestHandler,
+  IHttpResponseHandler,
+} from '../operators';
 import type {
   BlobResult,
   FetchRequest,
@@ -38,6 +42,7 @@ export type HttpClientCreateOptions<
 > = {
   requestHandler: IHttpRequestHandler<TRequest>;
   responseHandler: IHttpResponseHandler<TResponse>;
+  middlewareHandler: IHttpMiddlewareHandler;
 };
 
 /** Base http client for executing requests */
@@ -58,6 +63,13 @@ export class HttpClient<
    */
   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.
@@ -103,6 +115,7 @@ export class HttpClient<
   ) {
     this.requestHandler = new HttpRequestHandler<TRequest>(options?.requestHandler);
     this.responseHandler = new HttpResponseHandler<TResponse>(options?.responseHandler);
+    this.middlewareHandler = new HttpMiddlewareHandler(options?.middlewareHandler);
     this._init();
   }
 
@@ -326,7 +339,9 @@ export class HttpClient<
   /**
    * 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.
+   * 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();
@@ -355,11 +370,26 @@ export class HttpClient<
     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(
@@ -367,8 +397,10 @@ export class HttpClient<
       switchMap((x) => this._prepareRequest(x)),
       /** push request to event buss */
       tap((x) => this._request$.next(x)),
-      /** execute request */
-      switchMap(({ uri, path: _path, ...init }) => fromFetch(uri, init)),
+      /** 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 */
@@ -394,12 +426,32 @@ export class HttpClient<
       }),
       /** 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.

package/src/lib/operators/HttpMiddlewareHandler.ts

@@ -0,0 +1,58 @@
+import { firstValueFrom, from, of } from 'rxjs';
+import type { Observable, ObservableInput } from 'rxjs';
+
+import type { HttpMiddleware, HttpMiddlewareNext, IHttpMiddlewareHandler } from './types';
+
+/**
+ * Normalizes a step's result to a `Promise`, so a middleware calling `next(...)` never has to
+ * branch on whether the next step short-circuited with a plain `Response` or reached all the
+ * way to an Observable-returning network call.
+ */
+function toPromise(result: Response | ObservableInput<Response>): Promise<Response> {
+  return result instanceof Response ? Promise.resolve(result) : firstValueFrom(from(result));
+}
+
+/**
+ * Composes registered {@link HttpMiddleware} into a single execution pipeline wrapping the
+ * network call, so retries, caching, telemetry, or circuit-breaking can wrap `_performFetch`
+ * without touching request or response payload transforms.
+ *
+ * @see {@link HttpClient}
+ */
+export class HttpMiddlewareHandler implements IHttpMiddlewareHandler {
+  #middleware: HttpMiddleware[];
+
+  /**
+   * Constructs a handler, optionally cloning another handler's registered middleware.
+   * @param source - An existing handler to clone the registered middleware from.
+   */
+  constructor(source?: IHttpMiddlewareHandler) {
+    this.#middleware = source ? [...source.middleware] : [];
+  }
+
+  /** @inheritdoc */
+  get middleware(): readonly HttpMiddleware[] {
+    return this.#middleware;
+  }
+
+  /** @inheritdoc */
+  use(middleware: HttpMiddleware): HttpMiddlewareHandler {
+    this.#middleware.push(middleware);
+    return this;
+  }
+
+  /** @inheritdoc */
+  process(uri: string, init: RequestInit, terminal: HttpMiddlewareNext): Observable<Response> {
+    // wrap outward-in so the first-registered middleware is outermost, matching a conventional middleware chain
+    const chain = this.#middleware.reduceRight<HttpMiddlewareNext>(
+      (next, middleware) => (nextUri, nextInit) =>
+        middleware(nextUri, nextInit, (u, i) => toPromise(next(u, i))),
+      terminal,
+    );
+    const result = chain(uri, init);
+    // a middleware may short-circuit with a plain Response (no ObservableInput wrapping needed)
+    return result instanceof Response ? of(result) : from(result);
+  }
+}
+
+export default HttpMiddlewareHandler;

package/src/lib/operators/index.ts

@@ -1,5 +1,6 @@
 export { HttpRequestHandler } from './HttpRequestHandler';
 export { HttpResponseHandler } from './HttpResponseHandler';
+export { HttpMiddlewareHandler } from './HttpMiddlewareHandler';
 export { ProcessOperators } from './ProcessOperators';
 export { capitalizeRequestMethodOperator } from './capitalize-request-method-operator';
 export { requestValidationOperator } from './request-validation-operator';

package/src/lib/operators/types.ts

@@ -1,4 +1,4 @@
-import type { Observable } from 'rxjs';
+import type { Observable, ObservableInput } from 'rxjs';
 import type { FetchRequest } from '../client';
 
 /**
@@ -86,3 +86,89 @@ export interface IHttpRequestHandler<T extends FetchRequest = FetchRequest>
  * @template T - The type of the response being processed. Defaults to `Response`.
  */
 export interface IHttpResponseHandler<T = Response> extends IProcessOperators<T> {}
+
+/**
+ * Continues an HTTP request by resolving the given (already-processed) request into a response.
+ *
+ * @remarks
+ * The terminal `next` passed to the outermost {@link HttpMiddleware} ultimately resolves to
+ * `HttpClient._performFetch` — the same overridable seam the mock system replaces — so
+ * middleware wraps around either the real network call or a mocked one transparently.
+ *
+ * @param uri - The fully resolved URL for the request.
+ * @param init - The prepared `fetch` request options.
+ * @returns The resulting `Response`, or an observable input of it.
+ */
+export type HttpMiddlewareNext = (
+  uri: string,
+  init: RequestInit,
+) => Response | ObservableInput<Response>;
+
+/**
+ * Continues to the next registered {@link HttpMiddleware}, or the network call itself,
+ * always resolving to a `Response` regardless of how that next step actually produced it —
+ * a short-circuited `Response`, a `Promise`, or an `Observable`.
+ *
+ * @param uri - The fully resolved URL for the request.
+ * @param init - The prepared `fetch` request options.
+ * @returns A promise of the resulting `Response`.
+ */
+export type HttpMiddlewareContinuation = (uri: string, init: RequestInit) => Promise<Response>;
+
+/**
+ * Wraps request execution to add cross-cutting behavior — retries, caching, telemetry,
+ * circuit breaking — around the network call itself, rather than transforming the
+ * request or response payload.
+ *
+ * @remarks
+ * Unlike {@link ProcessOperator}, which transforms a value in a linear pipeline, a middleware
+ * controls whether and how many times `next` runs: it can short-circuit by never calling
+ * `next`, retry by calling it more than once, or recover from a rejection it throws.
+ * Registered middleware compose in an "onion" — the first one registered is outermost, so it
+ * sees the request first and the response last.
+ *
+ * @param uri - The fully resolved URL for the request.
+ * @param init - The prepared `fetch` request options.
+ * @param next - Continues to the next registered middleware, or the network call itself.
+ * @returns The resulting `Response`, or an observable input of it.
+ *
+ * @example Retry once on a failed response
+ * ```typescript
+ * const retryOnce: HttpMiddleware = async (uri, init, next) => {
+ *   const response = await next(uri, init);
+ *   return response.ok ? response : next(uri, init);
+ * };
+ * ```
+ */
+export type HttpMiddleware = (
+  uri: string,
+  init: RequestInit,
+  next: HttpMiddlewareContinuation,
+) => Response | ObservableInput<Response>;
+
+/**
+ * Registers and composes {@link HttpMiddleware} into a single execution pipeline wrapping
+ * the network call.
+ */
+export interface IHttpMiddlewareHandler {
+  /**
+   * Gets the registered middleware, in registration order.
+   */
+  get middleware(): readonly HttpMiddleware[];
+
+  /**
+   * Registers a middleware, wrapping every middleware registered before it.
+   * @param middleware - The middleware to register.
+   * @returns The updated handler, for chaining.
+   */
+  use(middleware: HttpMiddleware): IHttpMiddlewareHandler;
+
+  /**
+   * Runs the registered middleware chain around a request, ending with `terminal`.
+   * @param uri - The fully resolved URL for the request.
+   * @param init - The prepared `fetch` request options.
+   * @param terminal - The innermost step the chain wraps, called when every middleware defers to `next`.
+   * @returns An observable of the resulting `Response`.
+   */
+  process(uri: string, init: RequestInit, terminal: HttpMiddlewareNext): Observable<Response>;
+}

package/src/mock/create-open-api-mock-middleware.ts

@@ -0,0 +1,40 @@
+import type { HttpMiddleware } from '../lib/operators/types';
+
+import { resolveOpenApiMockResponse, type OpenApiMockLike } from './resolve-open-api-mock-response';
+
+/**
+ * Adapts an `OpenApiMock` into an {@link HttpMiddleware}, so
+ * `configurator.http.addMiddleware(...)` fakes every matching request
+ * straight from an OpenAPI document — no separate mock configurator needed.
+ *
+ * @remarks
+ * A request that matches no operation in the document falls through to
+ * `next`, so this composes with whatever else is registered — including the
+ * real network call, or another middleware further down the chain. Because
+ * `addMiddleware` wraps `_performFetch` rather than replacing it, the exact
+ * same registration also fakes requests through any client this configurator
+ * builds, so app config never has to branch on whether it's under test.
+ *
+ * @param openApiMock - Typically `createOpenApiMock(document)` from `@equinor/fusion-openapi-mock`.
+ * @returns A middleware for {@link IHttpClientConfigurator.addMiddleware}.
+ *
+ * @example Fake every operation in a spec, straight from the document
+ * ```typescript
+ * import { createOpenApiMock } from '@equinor/fusion-openapi-mock';
+ * import openapi from './openapi.json' with { type: 'json' };
+ *
+ * configurator.http.addMiddleware(createOpenApiMockMiddleware(createOpenApiMock(openapi)));
+ * ```
+ */
+export function createOpenApiMockMiddleware(openApiMock: OpenApiMockLike): HttpMiddleware {
+  return async (uri, init, next) => {
+    const response = await resolveOpenApiMockResponse(
+      openApiMock,
+      init.method ?? 'GET',
+      new URL(uri),
+    );
+    return response ?? next(uri, init);
+  };
+}
+
+export default createOpenApiMockMiddleware;

package/src/mock/create-router-middleware.ts

@@ -0,0 +1,158 @@
+import type { HttpMiddleware } from '../lib/operators/types';
+
+/**
+ * A route match handed to a {@link MockRouteHandler} once its pattern has matched a request.
+ */
+export interface MockRouteMatch {
+  /** Path parameters extracted from named segments in the route pattern, e.g. `:id` -> `params.id`. */
+  params: Record<string, string>;
+  /** The fully resolved request URL, for reading query parameters via `url.searchParams`. */
+  url: URL;
+  /** The request as a Fetch-standard `Request`, for reading headers or a JSON/text body. */
+  request: Request;
+}
+
+/** Builds the `Response` for one matched route. */
+export type MockRouteHandler = (match: MockRouteMatch) => Response | Promise<Response>;
+
+/**
+ * Registers route handlers for {@link createRouterMiddleware}, in the style of a minimal
+ * Express-like router — path templates (`:id`) and per-method registration, without pulling
+ * in a real routing library.
+ */
+export interface IMockRouterBuilder {
+  /** Registers `handler` for `GET` requests matching `path`. @see {@link IMockRouterBuilder.on} */
+  get(path: string, handler: MockRouteHandler): IMockRouterBuilder;
+  /** Registers `handler` for `POST` requests matching `path`. @see {@link IMockRouterBuilder.on} */
+  post(path: string, handler: MockRouteHandler): IMockRouterBuilder;
+  /** Registers `handler` for `PUT` requests matching `path`. @see {@link IMockRouterBuilder.on} */
+  put(path: string, handler: MockRouteHandler): IMockRouterBuilder;
+  /** Registers `handler` for `PATCH` requests matching `path`. @see {@link IMockRouterBuilder.on} */
+  patch(path: string, handler: MockRouteHandler): IMockRouterBuilder;
+  /** Registers `handler` for `DELETE` requests matching `path`. @see {@link IMockRouterBuilder.on} */
+  delete(path: string, handler: MockRouteHandler): IMockRouterBuilder;
+  /**
+   * Registers `handler` for a method and path template.
+   * @param method - The HTTP method to match, case-insensitively, or `undefined` to match any method.
+   * @param path - A path template relative to the router's base URI. A segment starting with
+   *   `:` (e.g. `/contexts/:id`) captures that segment into `params`; every other segment must
+   *   match literally. A trailing slash is always optional.
+   * @param handler - Builds the `Response` for a matching request.
+   */
+  on(method: string | undefined, path: string, handler: MockRouteHandler): IMockRouterBuilder;
+}
+
+interface RegisteredRoute {
+  method: string | undefined;
+  regexp: RegExp;
+  keys: string[];
+  handler: MockRouteHandler;
+}
+
+/**
+ * Compiles a path template into a matching `RegExp` plus the ordered list of named parameters
+ * it captures.
+ *
+ * @param path - A path template such as `/contexts/:id`.
+ * @returns The compiled pattern and the parameter names it captures, in segment order.
+ */
+function compilePath(path: string): { regexp: RegExp; keys: string[] } {
+  const keys: string[] = [];
+  const pattern = path
+    .split('/')
+    // each segment either captures a path parameter or must match literally
+    .map((segment) => {
+      // only `:name` segments become capture groups; everything else must match literally
+      if (!segment.startsWith(':')) {
+        return segment.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      }
+      keys.push(segment.slice(1));
+      return '([^/]+)';
+    })
+    .join('/');
+  return { regexp: new RegExp(`^${pattern}/?$`), keys };
+}
+
+/**
+ * Builds an {@link HttpMiddleware} that answers requests to one base URI with hand-registered
+ * route handlers, matched by method and a path template (`:id`-style segments) — a lightweight
+ * router for tests with more than a couple of routes to fake, without hand-rolling `RegExp`
+ * matching against `uri` in every middleware.
+ *
+ * @remarks
+ * A request outside `baseUri`, or matching no registered route, falls through to `next`, so
+ * this composes with other middleware — including the real network call, or another router
+ * for a different base URI — registered around it. Routes are tried in registration order;
+ * the first match wins.
+ *
+ * Deliberately not an MSW-compatible API — this stays inside `addMiddleware`'s own request
+ * pipeline rather than intercepting the network boundary, so it has none of MSW's response
+ * transformers, `onUnhandledRequest` diagnostics, or wildcard patterns.
+ *
+ * @param baseUri - The base URI this router answers for, e.g. `https://api.example.com`.
+ * @param build - Registers routes on the given {@link IMockRouterBuilder}.
+ * @returns A middleware for {@link IHttpClientConfigurator.addMiddleware}.
+ *
+ * @example Fake a handful of routes under one base URI
+ * ```typescript
+ * configurator.http.addMiddleware(
+ *   createRouterMiddleware('https://context.example.com', (router) => {
+ *     router.get('/contexts/:id/relations', () => Response.json([{ id: 'ctx-3' }]));
+ *     router.get('/contexts', () => Response.json([{ id: 'ctx-2' }]));
+ *     router.get('/contexts/:id', ({ params }) => Response.json({ id: params.id }));
+ *   }),
+ * );
+ * ```
+ */
+export function createRouterMiddleware(
+  baseUri: string,
+  build: (router: IMockRouterBuilder) => void,
+): HttpMiddleware {
+  const routes: RegisteredRoute[] = [];
+  const register = (
+    method: string | undefined,
+    path: string,
+    handler: MockRouteHandler,
+  ): IMockRouterBuilder => {
+    const { regexp, keys } = compilePath(path);
+    routes.push({ method: method?.toUpperCase(), regexp, keys, handler });
+    return router;
+  };
+  const router: IMockRouterBuilder = {
+    get: (path, handler) => register('GET', path, handler),
+    post: (path, handler) => register('POST', path, handler),
+    put: (path, handler) => register('PUT', path, handler),
+    patch: (path, handler) => register('PATCH', path, handler),
+    delete: (path, handler) => register('DELETE', path, handler),
+    on: register,
+  };
+  build(router);
+
+  const base = new URL(baseUri);
+  const basePath = base.pathname.replace(/\/$/, '');
+
+  return async (uri, init, next) => {
+    const url = new URL(uri);
+    // requests to a different origin, or outside this router's base path, are none of its concern
+    if (url.origin !== base.origin || !url.pathname.startsWith(basePath)) return next(uri, init);
+
+    const pathname = url.pathname.slice(basePath.length) || '/';
+    const method = (init.method ?? 'GET').toUpperCase();
+
+    // first registered route whose method and pattern both match wins
+    for (const route of routes) {
+      // a route registered for a specific method never answers a request for another method
+      if (route.method && route.method !== method) continue;
+      const match = route.regexp.exec(pathname);
+      // pattern didn't match this pathname at all — try the next registered route
+      if (!match) continue;
+      // capture groups are positional, in the same order `compilePath` recorded their names
+      const params = Object.fromEntries(route.keys.map((key, i) => [key, match[i + 1]]));
+      return route.handler({ params, url, request: new Request(uri, init) });
+    }
+
+    return next(uri, init);
+  };
+}
+
+export default createRouterMiddleware;

package/src/mock/index.ts

@@ -0,0 +1,26 @@
+/**
+ * Testing utilities for the HTTP module.
+ *
+ * @remarks
+ * Imported from `@equinor/fusion-framework-module-http/mock`, so testing
+ * utilities ship and version with the implementation they stand in for.
+ *
+ * There is no separate mock client or configurator here — register a
+ * short-circuiting `HttpMiddleware` through `configurator.http.addMiddleware(...)`
+ * on the real `HttpClientConfigurator` instead, so app config never has to
+ * branch on whether it's under test. See {@link createOpenApiMockMiddleware}
+ * for faking a whole OpenAPI document's operations that way.
+ *
+ * This entry point has no dependency on any test runner.
+ *
+ * @packageDocumentation
+ */
+
+export { createOpenApiMockMiddleware } from './create-open-api-mock-middleware';
+export type { OpenApiMockLike } from './resolve-open-api-mock-response';
+export {
+  createRouterMiddleware,
+  type MockRouteHandler,
+  type MockRouteMatch,
+  type IMockRouterBuilder,
+} from './create-router-middleware';

package/src/mock/resolve-open-api-mock-response.ts

@@ -0,0 +1,36 @@
+/**
+ * The subset of `OpenApiMock` (from `@equinor/fusion-openapi-mock`'s
+ * `createOpenApiMock`) the adapters in this file need — duck-typed so this
+ * package has no dependency on that one; anything shaped like this works.
+ */
+export interface OpenApiMockLike {
+  resolve(request: {
+    method: string;
+    path: string;
+    query?: Record<string, string>;
+  }): Promise<{ status: number; mock: unknown } | undefined>;
+}
+
+/**
+ * Resolves a method and URL against an `OpenApiMock`, building a `Response`
+ * from whatever it matches — shared by every adapter targeting a different
+ * middleware shape, so the method/path/query mapping and status/body wiring
+ * lives in one place.
+ *
+ * @param openApiMock - The mock to resolve against.
+ * @param method - The request's HTTP method.
+ * @param url - The request's fully resolved URL.
+ * @returns The faked `Response`, or `undefined` when no operation matches.
+ */
+export async function resolveOpenApiMockResponse(
+  openApiMock: OpenApiMockLike,
+  method: string,
+  url: URL,
+): Promise<Response | undefined> {
+  const result = await openApiMock.resolve({
+    method,
+    path: url.pathname,
+    query: Object.fromEntries(url.searchParams),
+  });
+  return result && Response.json(result.mock, { status: result.status });
+}

package/src/provider.ts

@@ -5,7 +5,7 @@ import type {
   IHttpClientConfigurator,
 } from './configurator';
 
-import type { IHttpRequestHandler } from './lib/operators';
+import type { IHttpMiddlewareHandler, IHttpRequestHandler } from './lib/operators';
 import type { IHttpClient } from './lib/client';
 import { BaseModuleProvider } from '@equinor/fusion-framework-module/provider';
 import { version } from './version';
@@ -24,6 +24,12 @@ export interface IHttpClientProvider<TClient extends IHttpClient = IHttpClient>
    */
   readonly defaultHttpRequestHandler: IHttpRequestHandler<HttpClientRequestInitType<TClient>>;
 
+  /**
+   * The default middleware chain used by the HttpClientProvider, wrapping the network call
+   * for every client it creates unless a client overrides it with its own `middlewareHandler`.
+   */
+  readonly defaultHttpMiddlewareHandler: IHttpMiddlewareHandler;
+
   /**
    * Checks if a client is configured with the given key.
    * @param key - The key of the client to check.
@@ -98,6 +104,14 @@ export class HttpClientProvider<TClient extends IHttpClient = IHttpClient>
     return this.config.defaultHttpRequestHandler;
   }
 
+  /**
+   * Gets the default middleware chain for the HTTP client provider.
+   * @returns The default middleware chain.
+   */
+  get defaultHttpMiddlewareHandler(): IHttpMiddlewareHandler {
+    return this.config.defaultHttpMiddlewareHandler;
+  }
+
   /**
    * Creates a new `HttpClientProvider`.
    * @param config - The configurator providing client definitions and defaults.
@@ -143,8 +157,9 @@ export class HttpClientProvider<TClient extends IHttpClient = IHttpClient>
       ctor = this.config.defaultHttpClientCtor,
       requestHandler = this.defaultHttpRequestHandler,
       responseHandler,
+      middlewareHandler = this.defaultHttpMiddlewareHandler,
     } = config as HttpClientOptions<TClient>;
-    const options = { requestHandler, responseHandler };
+    const options = { requestHandler, responseHandler, middlewareHandler };
     const instance = new ctor(baseUri || '', options) as TClient;
     // attach the resolved default scopes onto the instance without overwriting other own properties
     Object.assign(instance, { defaultScopes });

package/src/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '8.0.4';
+export const version = '8.1.0-next.0';

package/tests/HttpClient.test.ts

@@ -111,6 +111,52 @@ describe('HttpClient', () => {
       expect.stringContaining('missing the http:// or https:// protocol'),
     );
   });
+
+  it('runs middleware registered through the configurator around every created client', async () => {
+    const config = new HttpClientConfigurator(HttpClient);
+    config.configureClient('foo', 'http://localhost:3000');
+    config.addMiddleware(() => Response.json('from-middleware'));
+
+    const client = new HttpClientProvider(config).createClient('foo');
+
+    await expect(client.json('/api')).resolves.toBe('from-middleware');
+  });
+
+  it('lets middleware call next through to the real network call', async () => {
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue(Response.json('from-network'));
+
+    const config = new HttpClientConfigurator(HttpClient);
+    config.configureClient('foo', 'http://localhost:3000');
+    config.addMiddleware((uri, init, next) => next(uri, init));
+
+    const client = new HttpClientProvider(config).createClient('foo');
+
+    await expect(client.json('/api')).resolves.toBe('from-network');
+  });
+
+  it('aborts the underlying fetch on abort(), even behind a pass-through middleware', async () => {
+    // `next(...)` resolves through a Promise (`HttpMiddlewareHandler`'s `toPromise`), so this
+    // asserts the fix doesn't rely on RxJS unsubscription reaching `_performFetch` through it.
+    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockImplementation(
+      (_input, init) =>
+        new Promise((_resolve, reject) => {
+          init?.signal?.addEventListener('abort', () => reject(init.signal?.reason));
+        }),
+    );
+
+    const config = new HttpClientConfigurator(HttpClient);
+    config.configureClient('foo', 'http://localhost:3000');
+    config.addMiddleware((uri, init, next) => next(uri, init));
+
+    const client = new HttpClientProvider(config).createClient('foo');
+    const request = client.json('/api');
+    // let the request reach `_performFetch` (and register the abort listener) before aborting
+    await vi.waitFor(() => expect(fetchSpy).toHaveBeenCalledTimes(1));
+    client.abort();
+
+    await expect(request).rejects.toBeDefined();
+    expect(fetchSpy.mock.calls[0][1]?.signal?.aborted).toBe(true);
+  });
 });
 
 describe('HttpClientMsal', () => {