@equinor/fusion-framework-module-http 2.0.5 → 2.0.6

package/dist/types/module.d.ts

@@ -1,4 +1,4 @@
-import { HttpClientMsal } from './client-msal';
+import { HttpClientMsal } from './lib/client';
 import { IHttpClientConfigurator, HttpClientOptions } from './configurator';
 import { IHttpClientProvider } from './provider';
 import type { Module, ModuleConfigType, IModuleConfigurator } from '@equinor/fusion-framework-module';
@@ -9,7 +9,7 @@ export declare const configureHttp: (configure: (config: ModuleConfigType<HttpMo
 export declare const configureHttpClient: (name: string, args: HttpClientOptions) => IModuleConfigurator<HttpModule>;
 declare module '@equinor/fusion-framework-module' {
     interface Modules {
-        http: HttpModule;
+        http: HttpMsalModule;
     }
 }
 export default module;

package/dist/types/provider.d.ts

@@ -1,10 +1,12 @@
-import { HttpClient, HttpRequestHandler, IHttpClient } from './client';
+import { HttpClient } from './lib/client';
 import { HttpClientOptions, HttpClientRequestInitType, IHttpClientConfigurator } from './configurator';
+import type { IHttpRequestHandler } from './lib/operators';
+import type { IHttpClient } from './lib/client';
 export declare class ClientNotFoundException extends Error {
     constructor(message: string);
 }
 export interface IHttpClientProvider<TClient extends IHttpClient = IHttpClient> {
-    readonly defaultHttpRequestHandler: HttpRequestHandler<HttpClientRequestInitType<TClient>>;
+    readonly defaultHttpRequestHandler: IHttpRequestHandler<HttpClientRequestInitType<TClient>>;
     hasClient(key: string): boolean;
     createClient(key: string): TClient;
     createClient(key: HttpClientOptions<TClient>): TClient;
@@ -12,7 +14,7 @@ export interface IHttpClientProvider<TClient extends IHttpClient = IHttpClient>
 }
 export declare class HttpClientProvider<TClient extends IHttpClient = IHttpClient> implements IHttpClientProvider<TClient> {
     protected config: IHttpClientConfigurator<TClient>;
-    get defaultHttpRequestHandler(): HttpRequestHandler<HttpClientRequestInitType<TClient>>;
+    get defaultHttpRequestHandler(): IHttpRequestHandler<HttpClientRequestInitType<TClient>>;
     constructor(config: IHttpClientConfigurator<TClient>);
     hasClient(key: string): boolean;
     createClient(keyOrConfig: string | HttpClientOptions<TClient>): TClient;

package/package.json

@@ -1,12 +1,31 @@
 {
   "name": "@equinor/fusion-framework-module-http",
-  "version": "2.0.5",
+  "version": "2.0.6",
   "description": "",
   "main": "dist/esm/index.js",
+  "types": "index.d.ts",
   "exports": {
-    ".": "./dist/esm/index.js"
+    ".": "./dist/esm/index.js",
+    "./client": "./dist/esm/lib/client/index.js",
+    "./operators": "./dist/esm/lib/operators/index.js",
+    "./selectors": "./dist/esm/lib/selectors/index.js"
+  },
+  "typesVersions": {
+    ">=4.2": {
+      "*": [
+        "dist/types/*"
+      ],
+      "client": [
+        "dist/types/lib/client/index.d.ts"
+      ],
+      "operators": [
+        "dist/types/lib/operators/index.d.ts"
+      ],
+      "selectors": [
+        "dist/types/lib/selectors/index.d.ts"
+      ]
+    }
   },
-  "types": "dist/types/index.d.ts",
   "scripts": {
     "build": "npm run build:typescript",
     "build:typescript": "tsc -b --verbose"
@@ -29,5 +48,5 @@
   "devDependencies": {
     "typescript": "^4.8.2"
   },
-  "gitHead": "4e92ef5173981f4e43bad9a2a2e53fb3f71da7a1"
+  "gitHead": "afbbc5036ce33357ea7f946a082282b72f86da30"
 }

package/src/configurator.ts

@@ -1,7 +1,10 @@
-import { HttpRequestHandler, FetchRequest, IHttpClient, HttpResponseHandler } from './client';
+import { HttpRequestHandler } from './lib/operators';
+
+import type { FetchRequest, IHttpClient } from './lib/client';
+import type { IHttpRequestHandler, IHttpResponseHandler } from './lib/operators';
 
 interface HttpClientConstructorOptions<TInit extends FetchRequest> {
-    requestHandler: HttpRequestHandler<TInit>;
+    requestHandler: IHttpRequestHandler<TInit>;
 }
 
 interface HttpClientConstructor<TClient extends IHttpClient> {
@@ -16,8 +19,8 @@ export interface HttpClientOptions<TClient extends IHttpClient = IHttpClient> {
     defaultScopes?: string[];
     ctor?: HttpClientConstructor<TClient>;
     onCreate?: (client: TClient) => void;
-    requestHandler?: HttpRequestHandler<HttpClientRequestInitType<TClient>>;
-    responseHandler?: HttpResponseHandler<HttpClientRequestInitType<TClient>>;
+    requestHandler?: IHttpRequestHandler<HttpClientRequestInitType<TClient>>;
+    responseHandler?: IHttpResponseHandler<HttpClientRequestInitType<TClient>>;
 }
 
 export type HttpClientRequestInitType<T extends IHttpClient> = T extends IHttpClient<infer U>
@@ -31,7 +34,7 @@ export type HttpClientRequestInitType<T extends IHttpClient> = T extends IHttpCl
 export interface IHttpClientConfigurator<TClient extends IHttpClient = IHttpClient> {
     readonly clients: Record<string, HttpClientOptions<TClient>>;
     readonly defaultHttpClientCtor: HttpClientConstructor<TClient>;
-    readonly defaultHttpRequestHandler: HttpRequestHandler<HttpClientRequestInitType<TClient>>;
+    readonly defaultHttpRequestHandler: IHttpRequestHandler<HttpClientRequestInitType<TClient>>;
 
     /**
      * Configure a client with arguments
@@ -48,14 +51,14 @@ export interface IHttpClientConfigurator<TClient extends IHttpClient = IHttpClie
     configureClient<T extends TClient>(
         name: string,
         args: HttpClientOptions<T>
-    ): HttpClientConfigurator<TClient>;
+    ): IHttpClientConfigurator<TClient>;
 
     /**
      * Configure a simple client by name to an endpoint
      * @param name name of the client
      * @param uri base endpoint for the client
      */
-    configureClient(name: string, uri: string): HttpClientConfigurator<TClient>;
+    configureClient(name: string, uri: string): IHttpClientConfigurator<TClient>;
 
     /**
      * Creates a client with callback configuration

package/src/index.ts

@@ -3,12 +3,10 @@
  * @module
  */
 
-export { HttpClient, IHttpClient, FetchRequestInit, FetchRequest } from './client';
-export { HttpClientMsal } from './client-msal';
-
 export * from './configurator';
 export * from './provider';
 export * from './module';
-export * from './selector';
+
+export type { IHttpClient } from './lib/client';
 
 export { default } from './module';

package/src/{client-msal.ts → lib/client/client-msal.ts}

@@ -1,5 +1,6 @@
 import type { Observable } from 'rxjs';
-import { HttpClient, FetchRequestInit, FetchRequest } from './client';
+import type { FetchRequestInit, FetchRequest } from '.';
+import { HttpClient } from './client';
 
 /** Extends request init with scope  */
 type MsalFetchRequest = FetchRequest & { scopes?: string[] };

package/src/lib/client/client.ts

@@ -0,0 +1,161 @@
+import { firstValueFrom, of, Subject } from 'rxjs';
+import { switchMap, takeUntil, tap } from 'rxjs/operators';
+import { fromFetch } from 'rxjs/fetch';
+
+import { HttpRequestHandler, HttpResponseHandler } from '../operators';
+import { jsonSelector } from '../selectors';
+
+import type { Observable, ObservableInput } from 'rxjs';
+import type { IHttpRequestHandler, IHttpResponseHandler } from '../operators';
+import type { FetchRequest, FetchRequestInit, IHttpClient, StreamResponse } from '.';
+
+export type HttpClientCreateOptions<
+    TRequest extends FetchRequest = FetchRequest,
+    TResponse = Response
+> = {
+    requestHandler: IHttpRequestHandler<TRequest>;
+    responseHandler: IHttpResponseHandler<TResponse>;
+};
+
+/** Base http client for executing requests */
+export class HttpClient<TRequest extends FetchRequest = FetchRequest, TResponse = Response>
+    implements IHttpClient<TRequest, TResponse>
+{
+    readonly requestHandler: IHttpRequestHandler<TRequest>;
+
+    readonly responseHandler: IHttpResponseHandler<TResponse>;
+
+    /** stream of requests that are about to be executed  */
+    protected _request$ = new Subject<TRequest>();
+
+    /** stream of request responses */
+    protected _response$ = new Subject<TResponse>();
+
+    protected _abort$ = new Subject<void>();
+
+    public get request$(): Observable<TRequest> {
+        return this._request$.asObservable();
+    }
+
+    public get response$(): Observable<TResponse> {
+        return this._response$.asObservable();
+    }
+
+    constructor(
+        public uri: string,
+        options?: Partial<HttpClientCreateOptions<TRequest, TResponse>>
+    ) {
+        this.requestHandler = options?.requestHandler ?? new HttpRequestHandler<TRequest>();
+        this.responseHandler = options?.responseHandler ?? new HttpResponseHandler<TResponse>();
+        this._init();
+    }
+
+    /** internal abstract method, for overriding instead of overriding constructor */
+    protected _init(): void {
+        // called by children for constructor setup
+    }
+
+    public fetch$<T = TResponse>(
+        path: string,
+        args?: FetchRequestInit<T, TRequest, TResponse>
+    ): StreamResponse<T> {
+        return this._fetch$(path, args);
+    }
+
+    public fetch<T = TResponse>(
+        path: string,
+        args?: FetchRequestInit<T, TRequest, TResponse>
+    ): Promise<T> {
+        return firstValueFrom(this.fetch$<T>(path, args));
+    }
+
+    /** @deprecated */
+    public fetchAsync<T = TResponse>(
+        path: string,
+        args?: FetchRequestInit<T, TRequest, TResponse>
+    ): Promise<T> {
+        return this.fetch(path, args);
+    }
+
+    public json$<T = TResponse>(
+        path: string,
+        args?: FetchRequestInit<T, TRequest, TResponse>
+    ): StreamResponse<T> {
+        const body = typeof args?.body === 'object' ? JSON.stringify(args?.body) : args?.body;
+        const selector = args?.selector ?? jsonSelector;
+        const header = new Headers(args?.headers);
+        header.append('Content-Type', 'application/json');
+        return this.fetch$(path, {
+            ...args,
+            body,
+            selector,
+        } as FetchRequestInit<T, TRequest, TResponse>);
+    }
+
+    public json<T = TResponse>(
+        path: string,
+        args?: FetchRequestInit<T, TRequest, TResponse>
+    ): Promise<T> {
+        return firstValueFrom(this.json$<T>(path, args));
+    }
+
+    /** @deprecated */
+    public jsonAsync<T = TResponse>(
+        path: string,
+        args?: FetchRequestInit<T, TRequest, TResponse>
+    ): Promise<T> {
+        return this.json(path, args);
+    }
+
+    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]>;
+    }
+
+    public abort(): void {
+        this._abort$.next();
+    }
+
+    protected _fetch$<T = TResponse>(
+        path: string,
+        args?: FetchRequestInit<T, TRequest, TResponse>
+    ): Observable<T> {
+        const { selector, ...options } = args || {};
+        const response$ = of({
+            ...options,
+            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 */
+            switchMap(({ uri, path: _path, ...init }) => fromFetch(uri, init)),
+            /** 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)),
+
+            switchMap((x) => (selector ? selector(x) : Promise.resolve(x))),
+            /** cancel request on abort signal */
+            takeUntil(this._abort$)
+        );
+        return response$ as unknown as Observable<T>;
+    }
+
+    protected _prepareRequest(init: TRequest): ObservableInput<TRequest> {
+        return this.requestHandler.process(init);
+    }
+
+    protected _prepareResponse(response: TResponse): ObservableInput<TResponse> {
+        return this.responseHandler.process(response);
+    }
+
+    protected _resolveUrl(path: string): string {
+        const baseUrl = this.uri || window.location.origin;
+        return new URL(path, baseUrl).href;
+    }
+}

package/src/lib/client/index.ts

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

package/src/lib/client/types.ts

@@ -0,0 +1,145 @@
+import type { ObservableInput, Observable } from 'rxjs';
+import type { IHttpRequestHandler, IHttpResponseHandler } from '../operators/types';
+
+export type StreamResponse<T> = Observable<T>;
+
+export type FetchRequest = RequestInit & {
+    uri: string;
+    path: string;
+};
+
+export type FetchRequestInit<
+    TReturn = unknown,
+    TRequest = FetchRequest,
+    TResponse = Response
+> = Omit<TRequest, 'uri' | 'path'> & {
+    selector?: (response: TResponse) => ObservableInput<TReturn>;
+};
+
+export type ClientRequestInit<T extends IHttpClient, TReturn = unknown> = T extends IHttpClient<
+    infer TRequest,
+    infer TResponse
+>
+    ? FetchRequestInit<TReturn, TRequest, TResponse>
+    : never;
+
+export type ExecutionMethod = 'fetch' | 'fetch$' | 'json' | 'json$';
+
+export type ExecutionMethodParameters<
+    TMethod extends ExecutionMethod = 'fetch',
+    TClient extends IHttpClient = IHttpClient
+> = Parameters<TClient[TMethod]>;
+
+export type ExecutionResponse<
+    TMethod extends ExecutionMethod = 'fetch',
+    TClient extends IHttpClient = IHttpClient
+> = ReturnType<TClient[TMethod]>;
+
+/**
+ * @template TRequest request arguments @see {@link https://developer.mozilla.org/en-US/docs/Web/API/request|request}
+ * @template TResponse request arguments @see {@link https://developer.mozilla.org/en-US/docs/Web/API/response|response}
+ */
+export interface IHttpClient<TRequest extends FetchRequest = FetchRequest, TResponse = Response> {
+    uri: string;
+    /** pre-processor of requests */
+    readonly requestHandler: IHttpRequestHandler<TRequest>;
+    /** post-processor of requests */
+    readonly responseHandler: IHttpResponseHandler<TResponse>;
+
+    /** Observable stream of request */
+    request$: Observable<TRequest>;
+
+    /** Observable stream of responses */
+    response$: Observable<TResponse>;
+
+    /**
+     * Observable request.
+     * Simplifies execution of request and
+     * note: request will not be executed until subscribe!
+     *
+     * @see {@link https://rxjs.dev/api/fetch/fromFetch|RXJS}
+     * @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,
+        init?: FetchRequestInit<T, TRequest, TResponse>
+    ): 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<T = TResponse>(path: string, init?: FetchRequestInit<T, TRequest, TResponse>): Promise<T>;
+
+    json$<T = TResponse>(
+        path: string,
+        init?: FetchRequestInit<T, TRequest, TResponse>
+    ): StreamResponse<T>;
+
+    json<T = TResponse>(path: string, init?: FetchRequestInit<T, TRequest, TResponse>): Promise<T>;
+
+    /**
+     *
+     */
+    execute<T = TResponse, TMethod extends 'fetch' | 'fetch$' | 'json' | 'json$' = 'fetch'>(
+        method: TMethod,
+        path: string,
+        init?: FetchRequestInit<T, TRequest, TResponse>
+    ): ReturnType<IHttpClient[TMethod]>;
+
+    /**
+     * Abort all ongoing request for current client
+     */
+    abort(): void;
+}

package/src/lib/index.ts

@@ -0,0 +1,3 @@
+export * from './client';
+export * from './operators';
+export * from './selectors';

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

@@ -0,0 +1,21 @@
+import { ProcessOperators } from './process-operators';
+import { requestOperatorHeader } from './request-operator-header';
+
+import type { FetchRequest } from '../client';
+
+/**
+ * Extends @see {ProcessOperators} for pre-processing requests.
+ */
+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
+     */
+    setHeader(key: string, value: string): HttpRequestHandler<T> {
+        const operator = requestOperatorHeader<T>(key, value);
+        return this.set('header-' + key, operator) as HttpRequestHandler<T>;
+    }
+}
+
+export default HttpRequestHandler;

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

@@ -0,0 +1,5 @@
+import { ProcessOperators } from './process-operators';
+
+export class HttpResponseHandler<T = Response> extends ProcessOperators<T> {}
+
+export default HttpResponseHandler;

package/src/lib/operators/index.ts

@@ -0,0 +1,5 @@
+export { HttpRequestHandler } from './http-request-handler';
+export { HttpResponseHandler } from './http-response-handler';
+export { ProcessOperators } from './process-operators';
+
+export * from './types';

package/src/{process-operators.ts → lib/operators/process-operators.ts}

@@ -1,43 +1,26 @@
 import { from, of } from 'rxjs';
 import type { Observable } from 'rxjs';
 import { last, mergeScan } from 'rxjs/operators';
+import { IProcessOperators, ProcessOperator } from './types';
 
-export type ProcessOperator<T, R = T> = (request: T) => R | void | Promise<R | void>;
-
-/**
- * Container for sync/async operators.
- * Pipes each operator sequential
- */
-export class ProcessOperators<T> {
+export class ProcessOperators<T> implements IProcessOperators<T> {
     protected _operators: Record<string, ProcessOperator<T>> = {};
 
-    /**
-     * Add a new operator (throw error if already defined)
-     */
     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);
     }
 
-    /**
-     * Add or sets a operator
-     */
     set(key: string, operator: ProcessOperator<T>): ProcessOperators<T> {
         this._operators[key] = operator;
         return this;
     }
 
-    /**
-     * Get a operator, will return undefined on invalid key.
-     */
     get(key: string): ProcessOperator<T> {
         return this._operators[key];
     }
 
-    /**
-     *  Process registered processors.
-     */
     process(request: T): Observable<T> {
         const operators = Object.values(this._operators);
         /** if no operators registered, just return the observable value */

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

@@ -0,0 +1,12 @@
+import type { FetchRequest } from '../client';
+import type { ProcessOperator } from './types';
+
+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 };
+    };
+
+export default requestOperatorHeader;

package/src/lib/operators/types.ts

@@ -0,0 +1,42 @@
+import type { Observable } from 'rxjs';
+import type { FetchRequest } from '../client';
+
+export type ProcessOperator<T, R = T> = (request: T) => R | void | Promise<R | void>;
+
+/**
+ * Container for sync/async operators.
+ * Pipes each operator sequential
+ */
+export interface IProcessOperators<T> {
+    /**
+     * Add a new operator (throw error if already defined)
+     */
+    add(key: string, operator: ProcessOperator<T>): IProcessOperators<T>;
+
+    /**
+     * Add or sets a operator
+     */
+    set(key: string, operator: ProcessOperator<T>): IProcessOperators<T>;
+
+    /**
+     * Get a operator, will return undefined on invalid key.
+     */
+    get(key: string): ProcessOperator<T>;
+
+    /**
+     *  Process registered processors.
+     */
+    process(request: T): Observable<T>;
+}
+
+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>;
+}
+
+export interface IHttpResponseHandler<T = Response> extends IProcessOperators<T> {}

package/src/lib/selectors/index.ts

@@ -0,0 +1 @@
+export { jsonSelector } from './json-selector';

package/src/{selector.ts → lib/selectors/json-selector.ts}

@@ -10,3 +10,5 @@ export const jsonSelector = <TType = unknown, TResponse extends Response = Respo
         throw Error('failed to parse response');
     }
 };
+
+export default jsonSelector;

package/src/module.ts

@@ -1,4 +1,4 @@
-import { HttpClientMsal } from './client-msal';
+import { HttpClientMsal } from './lib/client';
 import { IHttpClientConfigurator, HttpClientConfigurator, HttpClientOptions } from './configurator';
 import { IHttpClientProvider, HttpClientProvider } from './provider';
 
@@ -45,7 +45,7 @@ export const configureHttpClient = (
 
 declare module '@equinor/fusion-framework-module' {
     interface Modules {
-        http: HttpModule;
+        http: HttpMsalModule;
     }
 }
 

package/src/provider.ts

@@ -1,10 +1,13 @@
-import { HttpClient, HttpRequestHandler, IHttpClient } from './client';
+import { HttpClient } from './lib/client';
 import {
     HttpClientOptions,
     HttpClientRequestInitType,
     IHttpClientConfigurator,
 } from './configurator';
 
+import type { IHttpRequestHandler } from './lib/operators';
+import type { IHttpClient } from './lib/client';
+
 export class ClientNotFoundException extends Error {
     constructor(message: string) {
         super(message);
@@ -12,7 +15,7 @@ export class ClientNotFoundException extends Error {
 }
 
 export interface IHttpClientProvider<TClient extends IHttpClient = IHttpClient> {
-    readonly defaultHttpRequestHandler: HttpRequestHandler<HttpClientRequestInitType<TClient>>;
+    readonly defaultHttpRequestHandler: IHttpRequestHandler<HttpClientRequestInitType<TClient>>;
     /** check if a client is configured */
     hasClient(key: string): boolean;
     /** create a new http client */
@@ -46,7 +49,7 @@ const isURL = (url: string) => {
 export class HttpClientProvider<TClient extends IHttpClient = IHttpClient>
     implements IHttpClientProvider<TClient>
 {
-    get defaultHttpRequestHandler(): HttpRequestHandler<HttpClientRequestInitType<TClient>> {
+    get defaultHttpRequestHandler(): IHttpRequestHandler<HttpClientRequestInitType<TClient>> {
         return this.config.defaultHttpRequestHandler;
     }