@equinor/fusion-framework-module-http 0.1.0-beta.9 → 0.2.0

package/src/client.ts

@@ -3,15 +3,25 @@ import { switchMap, takeUntil, tap } from 'rxjs/operators';
 import { fromFetch } from 'rxjs/fetch';
 
 import { ProcessOperators } from './process-operators';
+import { jsonSelector } from './selector';
 
-export type HttpRequestInit = RequestInit & { uri: string; path: string };
+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>;
+};
 
 /**
  * Extends @see {ProcessOperators} for pre-processing requests.
  */
-export class HttpRequestHandler<
-    T extends HttpRequestInit = HttpRequestInit
-> extends ProcessOperators<T> {
+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
@@ -26,16 +36,17 @@ export class HttpRequestHandler<
     }
 }
 
-export type HttpClientCreateOptions<T extends HttpRequestInit = HttpRequestInit> = {
+export type HttpClientCreateOptions<T extends FetchRequest = FetchRequest> = {
     requestHandler: HttpRequestHandler<T>;
 };
 
 export type HttpResponseHandler<T> = (response: Response) => Promise<T>;
 
-export interface IHttpClient<
-    TRequest extends HttpRequestInit = HttpRequestInit,
-    TResponse = Response
-> {
+/**
+ * @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: HttpRequestHandler<TRequest>;
@@ -52,11 +63,13 @@ export interface IHttpClient<
      * 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 = window.Fusion.createClient('my-client');
+     * const client = modules.http.createClient('my-client');
      * const input$ = fromEvent(document.getElementById('input'), 'input');
      * input$.pipe(
      *   // only call after no key input in .5s
@@ -80,10 +93,14 @@ export interface IHttpClient<
      * ).subscribe(console.log);
      * ```
      */
-    fetch(init: Omit<TRequest, 'uri'> | string): Observable<TResponse>;
+    fetch<T = TResponse>(
+        path: string,
+        init?: FetchRequestInit<T, TRequest, TResponse>
+    ): Observable<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;
@@ -110,7 +127,20 @@ export interface IHttpClient<
      * });
      * ```
      */
-    fetchAsync(init: Omit<TRequest, 'uri'> | string): Promise<TResponse>;
+    fetchAsync<T = TResponse>(
+        path: string,
+        init?: FetchRequestInit<T, TRequest, TResponse>
+    ): Promise<T>;
+
+    json<T = TResponse>(
+        path: string,
+        init?: FetchRequestInit<T, TRequest, TResponse>
+    ): Observable<T>;
+
+    jsonAsync<T = TResponse>(
+        path: string,
+        init?: FetchRequestInit<T, TRequest, TResponse>
+    ): Promise<T>;
 
     /**
      * Abort all ongoing request for current client
@@ -119,7 +149,7 @@ export interface IHttpClient<
 }
 
 /** Base http client for executing requests */
-export class HttpClient<TRequest extends HttpRequestInit = HttpRequestInit, TResponse = Response>
+export class HttpClient<TRequest extends FetchRequest = FetchRequest, TResponse = Response>
     implements IHttpClient<TRequest, TResponse>
 {
     readonly requestHandler: HttpRequestHandler<TRequest>;
@@ -153,9 +183,57 @@ export class HttpClient<TRequest extends HttpRequestInit = HttpRequestInit, TRes
         // called by children for constructor setup
     }
 
-    public fetch(init: Omit<TRequest, 'uri'> | string): Observable<TResponse> {
-        const options = typeof init === 'string' ? { path: init } : init;
-        return of({ ...options, uri: this._resolveUrl(options.path) } as TRequest).pipe(
+    public fetch<T = TResponse>(
+        path: string,
+        args?: FetchRequestInit<T, TRequest, TResponse>
+    ): Observable<T> {
+        return this._fetch(path, args);
+    }
+
+    public fetchAsync<T = TResponse>(
+        path: string,
+        args?: FetchRequestInit<T, TRequest, TResponse>
+    ): Promise<T> {
+        return firstValueFrom(this.fetch<T>(path, args));
+    }
+
+    public json<T = TResponse>(
+        path: string,
+        args?: FetchRequestInit<T, TRequest, TResponse>
+    ): Observable<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 jsonAsync<T = TResponse>(
+        path: string,
+        args?: FetchRequestInit<T, TRequest, TResponse>
+    ): Promise<T> {
+        return firstValueFrom(this.json<T>(path, args));
+    }
+
+    public abort(): void {
+        this._abort$.next();
+    }
+
+    protected _fetch<T = TResponse>(
+        path: string,
+        args?: FetchRequestInit<T, TRequest, TResponse>
+    ): Observable<T> {
+        const { selector, ...options } = Object.assign({}, args || { selector: undefined }, {
+            path,
+        });
+        const response$ = of({
+            ...options,
+            uri: this._resolveUrl(options.path),
+        } as TRequest).pipe(
             /** prepare request, allow extensions to modify request  */
             switchMap((x) => this._prepareRequest(x)),
             /** push request to event buss */
@@ -166,17 +244,12 @@ export class HttpClient<TRequest extends HttpRequestInit = HttpRequestInit, TRes
             switchMap((x) => this._prepareResponse(x)),
             /** 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$)
         );
-    }
-
-    public fetchAsync(init: Omit<TRequest, 'uri'> | string): Promise<TResponse> {
-        return firstValueFrom(this.fetch(init));
-    }
-
-    public abort(): void {
-        this._abort$.next();
+        return response$ as unknown as Observable<T>;
     }
 
     protected _prepareRequest(init: TRequest): ObservableInput<TRequest> {

package/src/configurator.ts

@@ -1,6 +1,6 @@
-import { HttpRequestHandler, HttpRequestInit, IHttpClient } from './client';
+import { HttpRequestHandler, FetchRequest, IHttpClient } from './client';
 
-interface HttpClientConstructorOptions<TInit extends HttpRequestInit> {
+interface HttpClientConstructorOptions<TInit extends FetchRequest> {
     requestHandler: HttpRequestHandler<TInit>;
 }
 
@@ -11,8 +11,9 @@ interface HttpClientConstructor<TClient extends IHttpClient> {
     ): TClient;
 }
 
-interface HttpClientOptions<TClient extends IHttpClient> {
+export interface HttpClientOptions<TClient extends IHttpClient> {
     baseUri?: string;
+    defaultScopes?: string[];
     ctor?: HttpClientConstructor<TClient>;
     onCreate?: (client: TClient) => void;
     requestHandler?: HttpRequestHandler<HttpClientRequestInitType<TClient>>;
@@ -20,49 +21,93 @@ interface HttpClientOptions<TClient extends IHttpClient> {
 
 type HttpClientRequestInitType<T extends IHttpClient> = T extends IHttpClient<infer U> ? U : never;
 
+/**
+ * Instance for configuring http client
+ * @template TClient base type of client that the provider will create
+ */
 export interface IHttpClientConfigurator<TClient extends IHttpClient = IHttpClient> {
     readonly clients: Record<string, HttpClientOptions<TClient>>;
     readonly defaultHttpClientCtor: HttpClientConstructor<TClient>;
     readonly defaultHttpRequestHandler: HttpRequestHandler<HttpClientRequestInitType<TClient>>;
 
-    configureClient(name: string, uri: string): HttpClientConfigurator<TClient>;
-
+    /**
+     * Configure a client with arguments
+     * @param name name of the client
+     * @param args option that are used cor creating a client
+     * @example
+     * ```ts
+     * configurator.http.configureClient('foo',{
+     *   baseUri: 'https://foo.bar',
+     *   defaultScopes: ['foobar/.default']
+     * });
+     * ```
+     */
     configureClient<T extends TClient>(
         name: string,
         args: HttpClientOptions<T>
     ): HttpClientConfigurator<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>;
+
+    /**
+     * Creates a client with callback configuration
+     * @param name name of the client
+     * @param onCreate callback when a client is created
+     * ```ts
+     * configurator.http.configureClient('foo',(client) => {
+     *   client.requestHandler.add('logger', (request) => console.log(request));
+     * });
+     * ```
+     */
     configureClient<T extends TClient>(
         name: string,
         onCreate: (client: T) => void
     ): HttpClientConfigurator<TClient>;
 
+    /**
+     * Check if there is a configuration for provided name
+     */
     hasClient(name: string): boolean;
 }
 
+/** @inheritdoc */
 export class HttpClientConfigurator<TClient extends IHttpClient>
     implements IHttpClientConfigurator<TClient>
 {
     protected _clients: Record<string, HttpClientOptions<TClient>> = {};
 
+    /** Get a clone of all configured clients */
     public get clients(): Record<string, HttpClientOptions<TClient>> {
         return { ...this._clients };
     }
 
+    /** default class for creation of http clients */
     readonly defaultHttpClientCtor: HttpClientConstructor<TClient>;
 
+    /** default request handler for http clients, applied on creation */
     readonly defaultHttpRequestHandler = new HttpRequestHandler<
         HttpClientRequestInitType<TClient>
     >();
 
+    /**
+     * Create a instance of http configuration
+     * @param client defaultHttpRequestHandler
+     */
     constructor(client: HttpClientConstructor<TClient>) {
         this.defaultHttpClientCtor = client;
     }
 
+    /** @inheritdoc */
     hasClient(name: string): boolean {
         return Object.keys(this._clients).includes(name);
     }
 
+    /** @inheritdoc */
     configureClient<T extends TClient>(
         name: string,
         args: string | HttpClientOptions<T> | HttpClientOptions<T>['onCreate']

package/src/index.ts

@@ -1,8 +1,14 @@
-export { HttpClient, IHttpClient } from './client';
+/**
+ * [[include:module-http/README.MD]]
+ * @module
+ */
+
+export { HttpClient, IHttpClient, FetchRequestInit } from './client';
 export { HttpClientMsal } from './client-msal';
 
 export * from './configurator';
 export * from './provider';
 export * from './module';
+export * from './selector';
 
 export { default } from './module';

package/src/provider.ts

@@ -1,5 +1,5 @@
 import { HttpClient } from './client';
-import { IHttpClientConfigurator } from './configurator';
+import { HttpClientOptions, IHttpClientConfigurator } from './configurator';
 
 export class ClientNotFoundException extends Error {
     constructor(message: string) {
@@ -12,6 +12,7 @@ export interface IHttpClientProvider<TClient extends HttpClient = HttpClient> {
     hasClient(key: string): boolean;
     /** create a new http client */
     createClient(key: string): TClient;
+    createClient(key: HttpClientOptions<TClient>): TClient;
     /**
      * Class cast creation of custom client
      * @example
@@ -46,21 +47,18 @@ export class HttpClientProvider<TClient extends HttpClient>
         return Object.keys(this.config.clients).includes(key);
     }
 
-    public createClient(key: string): TClient {
-        let config = this.config.clients[key];
-        if (!config && isURL(key)) {
-            config = { baseUri: key };
-        } else if (!config) {
-            throw new ClientNotFoundException(`No registered http client for key [${key}]`);
-        }
+    public createClient(keyOrConfig: string | HttpClientOptions<TClient>): TClient {
+        const config = this._resolveConfig(keyOrConfig);
         const {
             baseUri,
+            defaultScopes = [],
             onCreate,
             ctor = this.config.defaultHttpClientCtor,
             requestHandler = this.config.defaultHttpRequestHandler,
-        } = config;
+        } = config as HttpClientOptions<TClient>;
         const options = { requestHandler };
         const instance = new ctor(baseUri || '', options) as TClient;
+        Object.assign(instance, { defaultScopes });
         onCreate && onCreate(instance as TClient);
         return instance as TClient;
     }
@@ -68,4 +66,20 @@ export class HttpClientProvider<TClient extends HttpClient>
     public createCustomClient<T extends HttpClient>(key: string): T {
         return this.createClient(key) as unknown as T;
     }
+
+    protected _resolveConfig(
+        keyOrConfig: string | HttpClientOptions<TClient>
+    ): HttpClientOptions<TClient> {
+        if (typeof keyOrConfig === 'string') {
+            const config = this.config.clients[keyOrConfig];
+            if (!config && isURL(keyOrConfig)) {
+                return { baseUri: keyOrConfig };
+            } else if (!config) {
+                throw new ClientNotFoundException(
+                    `No registered http client for key [${keyOrConfig}]`
+                );
+            }
+        }
+        return keyOrConfig as HttpClientOptions<TClient>;
+    }
 }

package/src/selector.ts

@@ -0,0 +1,12 @@
+export const jsonSelector = <TType = unknown, TResponse extends Response = Response>(
+    response: TResponse
+): Promise<TType> => {
+    if (!response.ok) {
+        throw new Error('Network response was not OK');
+    }
+    try {
+        return response.json();
+    } catch (err) {
+        throw Error('failed to parse response', { cause: err as Error });
+    }
+};