@equinor/fusion-framework-module-http 0.0.0-next-20230915111233

package/src/lib/operators/process-operators.ts

@@ -0,0 +1,43 @@
+import { from, of } from 'rxjs';
+import type { Observable } from 'rxjs';
+import { last, mergeScan } from 'rxjs/operators';
+import { IProcessOperators, ProcessOperator } from './types';
+
+export class ProcessOperators<T> implements IProcessOperators<T> {
+    protected _operators: Record<string, ProcessOperator<T>> = {};
+
+    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);
+    }
+
+    set(key: string, operator: ProcessOperator<T>): ProcessOperators<T> {
+        this._operators[key] = operator;
+        return this;
+    }
+
+    get(key: string): ProcessOperator<T> {
+        return this._operators[key];
+    }
+
+    process(request: T): Observable<T> {
+        const operators = Object.values(this._operators);
+        /** if no operators registered, just return the observable value */
+        if (!operators.length) {
+            return of(request);
+        }
+        return from(Object.values(this._operators)).pipe(
+            mergeScan(
+                // resolve current operator and return result or previous if void
+                (value, operator) => Promise.resolve(operator(value)).then((x) => x ?? value),
+                // initial value
+                request,
+                // only allow concurrency of one operator
+                1,
+            ),
+            // output result of last operator
+            last(),
+        );
+    }
+}

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/blob-selector.ts

@@ -0,0 +1,19 @@
+export const blobSelector = <TResponse extends Response = Response>(
+    response: TResponse,
+): Promise<Blob> => {
+    if (!response.ok) {
+        throw new Error('network response was not OK');
+    }
+    //Status code 204 is no content
+    if (response.status === 204) {
+        throw new Error('no content');
+    }
+
+    try {
+        return response.blob();
+    } catch (err) {
+        throw Error('failed to parse response');
+    }
+};
+
+export default blobSelector;

package/src/lib/selectors/index.ts

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

package/src/lib/selectors/json-selector.ts

@@ -0,0 +1,19 @@
+export const jsonSelector = <TType = unknown, TResponse extends Response = Response>(
+    response: TResponse,
+): Promise<TType> => {
+    if (!response.ok) {
+        throw new Error('network response was not OK');
+    }
+    //Status code 204 is no content
+    if (response.status === 204) {
+        return Promise.resolve() as Promise<TType>;
+    }
+
+    try {
+        return response.json();
+    } catch (err) {
+        throw Error('failed to parse response');
+    }
+};
+
+export default jsonSelector;

package/src/module.ts

@@ -0,0 +1,80 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { HttpClientMsal } from './lib/client';
+import { IHttpClientConfigurator, HttpClientConfigurator, HttpClientOptions } from './configurator';
+import { IHttpClientProvider, HttpClientProvider } from './provider';
+
+import type {
+    Module,
+    ModuleConfigType,
+    IModuleConfigurator,
+} from '@equinor/fusion-framework-module';
+
+import { MsalModule } from '@equinor/fusion-framework-module-msal';
+
+export type HttpModule = Module<'http', IHttpClientProvider, IHttpClientConfigurator>;
+
+export type HttpMsalModule = Module<
+    'http',
+    IHttpClientProvider<HttpClientMsal>,
+    IHttpClientConfigurator<HttpClientMsal>,
+    [MsalModule]
+>;
+
+/**
+ *  Configure http-client
+ */
+export const module: HttpMsalModule = {
+    name: 'http',
+    configure: () => new HttpClientConfigurator(HttpClientMsal),
+    initialize: async ({
+        config,
+        hasModule,
+        requireInstance,
+    }): Promise<HttpClientProvider<HttpClientMsal>> => {
+        const httpProvider = new HttpClientProvider(config);
+        if (hasModule('auth')) {
+            const authProvider = await requireInstance('auth');
+            httpProvider.defaultHttpRequestHandler.set('MSAL', async (request) => {
+                const { scopes = [] } = request;
+                if (scopes.length) {
+                    /** TODO should be try catch, check caller for handling */
+                    const token = await authProvider.acquireToken({
+                        scopes,
+                    });
+                    if (token) {
+                        const headers = new Headers(request.headers);
+                        headers.set('Authorization', `Bearer ${token.accessToken}`);
+                        return { ...request, headers };
+                    }
+                }
+            });
+        }
+        return httpProvider;
+    },
+};
+
+export const configureHttp = <TRef = unknown>(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    configure: (config: ModuleConfigType<HttpMsalModule>, ref?: TRef) => void,
+): IModuleConfigurator<HttpMsalModule, TRef> => ({
+    module,
+    configure,
+});
+
+export const configureHttpClient = <TRef = unknown>(
+    name: string,
+    args: HttpClientOptions<HttpClientMsal>,
+): IModuleConfigurator<HttpMsalModule, TRef> => ({
+    module,
+    configure: (config: ModuleConfigType<HttpMsalModule>) => {
+        config.configureClient(name, args);
+    },
+});
+
+declare module '@equinor/fusion-framework-module' {
+    interface Modules {
+        http: HttpMsalModule;
+    }
+}
+
+export default module;

package/src/provider.ts

@@ -0,0 +1,98 @@
+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);
+    }
+}
+
+export interface IHttpClientProvider<TClient extends IHttpClient = IHttpClient> {
+    readonly defaultHttpRequestHandler: IHttpRequestHandler<HttpClientRequestInitType<TClient>>;
+    /** check if a client is configured */
+    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
+     * ```ts
+     * config.http.configureClient('foobar', (client) => {
+     *   client.ctor = MyClient;
+     *   client.uri = 'https://foobar.com';
+     * });
+     */
+    createCustomClient<T extends HttpClient>(key: string): T;
+}
+
+const isURL = (url: string) => {
+    const pattern = new RegExp(
+        '^(https?:\\/\\/)?' + // protocol
+            '((([a-z\\d]([a-z\\d-]*[a-z\\d])*)\\.?)+[a-z]{2,}|' + // domain name
+            '((\\d{1,3}\\.){3}\\d{1,3}))' + // OR ip (v4) address
+            '(\\:\\d+)?(\\/[-a-z\\d%_.~+]*)*' + // port and path
+            '(\\?[;&a-z\\d%_.~+=-]*)?' + // query string
+            '(\\#[-a-z\\d_]*)?$',
+        'i',
+    ); // fragment locator
+    return pattern.test(url);
+};
+
+export class HttpClientProvider<TClient extends IHttpClient = IHttpClient>
+    implements IHttpClientProvider<TClient>
+{
+    get defaultHttpRequestHandler(): IHttpRequestHandler<HttpClientRequestInitType<TClient>> {
+        return this.config.defaultHttpRequestHandler;
+    }
+
+    constructor(protected config: IHttpClientConfigurator<TClient>) {}
+
+    public hasClient(key: string): boolean {
+        return Object.keys(this.config.clients).includes(key);
+    }
+
+    public createClient(keyOrConfig: string | HttpClientOptions<TClient>): TClient {
+        const config = this._resolveConfig(keyOrConfig);
+        const {
+            baseUri,
+            defaultScopes = [],
+            onCreate,
+            ctor = this.config.defaultHttpClientCtor,
+            requestHandler = this.defaultHttpRequestHandler,
+        } = 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;
+    }
+
+    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 config;
+        }
+        return keyOrConfig as HttpClientOptions<TClient>;
+    }
+}

package/src/version.ts

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

package/tsconfig.json

@@ -0,0 +1,24 @@
+{
+  "extends": "../../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist/esm",
+    "rootDir": "src",
+    "declarationDir": "./dist/types",
+    
+  },
+  "references": [
+    {
+      "path": "../module"
+    },
+    {
+      "path": "../msal"
+    }
+  ],
+  "include": [
+    "src/**/*",
+  ],
+  "exclude": [
+    "node_modules",
+    "lib"
+  ]
+}