@equinor/fusion-framework-module-http 6.2.1 → 6.2.2

package/src/module.ts

@@ -1,15 +1,19 @@
 /* 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 IHttpClientConfigurator,
+  HttpClientConfigurator,
+  type HttpClientOptions,
+} from './configurator';
+import { type IHttpClientProvider, HttpClientProvider } from './provider';
 
 import type {
-    Module,
-    ModuleConfigType,
-    IModuleConfigurator,
+  Module,
+  ModuleConfigType,
+  IModuleConfigurator,
 } from '@equinor/fusion-framework-module';
 
-import { MsalModule } from '@equinor/fusion-framework-module-msal';
+import type { MsalModule } from '@equinor/fusion-framework-module-msal';
 
 /**
  * Defines the type for the HTTP module, which includes:
@@ -29,75 +33,75 @@ export type HttpModule = Module<'http', IHttpClientProvider, IHttpClientConfigur
  * - The list of required modules, which includes the `MsalModule`
  */
 export type HttpMsalModule = Module<
-    'http',
-    IHttpClientProvider<HttpClientMsal>,
-    IHttpClientConfigurator<HttpClientMsal>,
-    [MsalModule]
+  'http',
+  IHttpClientProvider<HttpClientMsal>,
+  IHttpClientConfigurator<HttpClientMsal>,
+  [MsalModule]
 >;
 
 /**
  * HTTP module with MSAL authentication.
  */
 export const module: HttpMsalModule = {
-    name: 'http',
-    /**
-     * Configures the HTTP module with MSAL authentication.
-     *
-     * This function creates a new `HttpClientConfigurator` instance using the `HttpClientMsal` class.
-     * The `HttpClientConfigurator` is responsible for configuring the HTTP client with the necessary options,
-     * such as the base URL, request headers, and other settings.
-     *
-     * @returns A new `HttpClientConfigurator` instance configured for MSAL authentication.
-     */
-    configure: () => new HttpClientConfigurator(HttpClientMsal),
+  name: 'http',
+  /**
+   * Configures the HTTP module with MSAL authentication.
+   *
+   * This function creates a new `HttpClientConfigurator` instance using the `HttpClientMsal` class.
+   * The `HttpClientConfigurator` is responsible for configuring the HTTP client with the necessary options,
+   * such as the base URL, request headers, and other settings.
+   *
+   * @returns A new `HttpClientConfigurator` instance configured for MSAL authentication.
+   */
+  configure: () => new HttpClientConfigurator(HttpClientMsal),
 
-    /**
-     * Initializes the HTTP client provider with MSAL authentication.
-     *
-     * This function is responsible for setting up the default HTTP request handler
-     * to acquire an access token from MSAL and attach it to the request headers
-     * when the request includes scopes.
-     *
-     * @param config - The module configuration.
-     * @param hasModule - A function to check if a module is available.
-     * @param requireInstance - A function to get an instance of a module.
-     * @returns A promise that resolves to the HTTP client provider.
-     */
-    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 };
-                    }
-                }
-            });
+  /**
+   * Initializes the HTTP client provider with MSAL authentication.
+   *
+   * This function is responsible for setting up the default HTTP request handler
+   * to acquire an access token from MSAL and attach it to the request headers
+   * when the request includes scopes.
+   *
+   * @param config - The module configuration.
+   * @param hasModule - A function to check if a module is available.
+   * @param requireInstance - A function to get an instance of a module.
+   * @returns A promise that resolves to the HTTP client provider.
+   */
+  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;
-    },
+      });
+    }
+    return httpProvider;
+  },
 };
 
 /**
  * Configures the HTTP module with MSAL authentication.
  */
 export const configureHttp = <TRef = unknown>(
-    configure: (config: ModuleConfigType<HttpMsalModule>, ref?: TRef) => void,
+  configure: (config: ModuleConfigType<HttpMsalModule>, ref?: TRef) => void,
 ): IModuleConfigurator<HttpMsalModule, TRef> => ({
-    module,
-    configure,
+  module,
+  configure,
 });
 
 /**
@@ -112,22 +116,22 @@ export const configureHttp = <TRef = unknown>(
  * @returns A module configurator that can be used to configure the HTTP module.
  */
 export const configureHttpClient = <TRef = unknown>(
-    name: string,
-    args: HttpClientOptions<HttpClientMsal>,
+  name: string,
+  args: HttpClientOptions<HttpClientMsal>,
 ): IModuleConfigurator<HttpMsalModule, TRef> => ({
-    module,
-    configure: (config: ModuleConfigType<HttpMsalModule>) => {
-        config.configureClient(name, args);
-    },
+  module,
+  configure: (config: ModuleConfigType<HttpMsalModule>) => {
+    config.configureClient(name, args);
+  },
 });
 
 /**
  * Declares a module named '@equinor/fusion-framework-module' that contains an interface named 'Modules' with a property 'http' of type 'HttpMsalModule'.
  */
 declare module '@equinor/fusion-framework-module' {
-    interface Modules {
-        http: HttpMsalModule;
-    }
+  interface Modules {
+    http: HttpMsalModule;
+  }
 }
 
 export default module;

package/src/provider.ts

@@ -1,51 +1,55 @@
-import { HttpClient } from './lib/client';
-import {
-    HttpClientOptions,
-    HttpClientRequestInitType,
-    IHttpClientConfigurator,
+import type { HttpClient } from './lib/client';
+import type {
+  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);
-    }
-}
+/**
+ * Exception thrown when a client cannot be found.
+ *
+ * This error is typically used to indicate that a requested client instance
+ * does not exist or cannot be located within the current context.
+ *
+ * @extends {Error}
+ */
+export class ClientNotFoundException extends Error {}
 
 export interface IHttpClientProvider<TClient extends IHttpClient = IHttpClient> {
-    /**
-     * The default HTTP request handler used by the HttpClientProvider.
-     * This handler is responsible for executing HTTP requests using the configured HttpClient.
-     */
-    readonly defaultHttpRequestHandler: IHttpRequestHandler<HttpClientRequestInitType<TClient>>;
+  /**
+   * The default HTTP request handler used by the HttpClientProvider.
+   * This handler is responsible for executing HTTP requests using the configured HttpClient.
+   */
+  readonly defaultHttpRequestHandler: IHttpRequestHandler<HttpClientRequestInitType<TClient>>;
 
-    /**
-     * Checks if a client is configured with the given key.
-     * @param key - The key of the client to check.
-     * @returns `true` if a client is configured with the given key, `false` otherwise.
-     */
-    hasClient(key: string): boolean;
+  /**
+   * Checks if a client is configured with the given key.
+   * @param key - The key of the client to check.
+   * @returns `true` if a client is configured with the given key, `false` otherwise.
+   */
+  hasClient(key: string): boolean;
 
-    /**
-     * Creates a new HTTP client instance with the specified key.
-     * @param key - The key of the HTTP client to create.
-     * @returns The created HTTP client instance.
-     */
-    createClient(key: string): TClient;
-    createClient(key: HttpClientOptions<TClient>): TClient;
+  /**
+   * Creates a new HTTP client instance with the specified key.
+   * @param key - The key of the HTTP client to create.
+   * @returns The created HTTP client instance.
+   */
+  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;
+  /**
+   * 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;
 }
 
 /**
@@ -54,16 +58,16 @@ export interface IHttpClientProvider<TClient extends IHttpClient = IHttpClient>
  * @returns `true` if the input string is a valid URL, `false` otherwise.
  */
 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);
+  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);
 };
 
 /**
@@ -71,102 +75,100 @@ const isURL = (url: string) => {
  * It provides methods to check if a client is configured, create new client instances, and create custom client instances.
  */
 export class HttpClientProvider<TClient extends IHttpClient = IHttpClient>
-    implements IHttpClientProvider<TClient>
+  implements IHttpClientProvider<TClient>
 {
-    /**
-     * Gets the default HTTP request handler for the HTTP client provider.
-     * @returns The default HTTP request handler.
-     */
-    get defaultHttpRequestHandler(): IHttpRequestHandler<HttpClientRequestInitType<TClient>> {
-        return this.config.defaultHttpRequestHandler;
-    }
+  /**
+   * Gets the default HTTP request handler for the HTTP client provider.
+   * @returns The default HTTP request handler.
+   */
+  get defaultHttpRequestHandler(): IHttpRequestHandler<HttpClientRequestInitType<TClient>> {
+    return this.config.defaultHttpRequestHandler;
+  }
 
-    constructor(protected config: IHttpClientConfigurator<TClient>) {}
+  constructor(protected config: IHttpClientConfigurator<TClient>) {}
 
-    /**
-     * Checks if a client with the given key is configured in the `HttpClientProvider`.
-     * @param key - The key of the HTTP client to check.
-     * @returns `true` if a client with the given key is configured, `false` otherwise.
-     */
-    public hasClient(key: string): boolean {
-        return Object.keys(this.config.clients).includes(key);
-    }
+  /**
+   * Checks if a client with the given key is configured in the `HttpClientProvider`.
+   * @param key - The key of the HTTP client to check.
+   * @returns `true` if a client with the given key is configured, `false` otherwise.
+   */
+  public hasClient(key: string): boolean {
+    return Object.keys(this.config.clients).includes(key);
+  }
 
-    /**
-     * Creates a new HTTP client instance with the specified configuration.
-     *
-     * @param keyOrConfig - The key or configuration object for the HTTP client.
-     * @returns The created HTTP client instance.
-     *
-     * @remarks
-     * This method resolves the configuration for the HTTP client based on the provided `keyOrConfig` parameter.
-     * If a string is provided, it is treated as the key for a pre-configured client in the `HttpClientProvider`.
-     * If an `HttpClientOptions` object is provided, it is used as the configuration for the new client instance.
-     *
-     * The method sets up the HTTP client with the following options:
-     * - `baseUri`: The base URI for the HTTP client.
-     * - `defaultScopes`: The default scopes to be used for authentication.
-     * - `onCreate`: An optional callback function that is called when the client instance is created.
-     * - `ctor`: The constructor function for the HTTP client, defaulting to the configured `defaultHttpClientCtor`.
-     * - `requestHandler`: The HTTP request handler to be used by the client, defaulting to the `defaultHttpRequestHandler`.
-     *
-     * The created HTTP client instance is returned.
-     */
-    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;
-    }
+  /**
+   * Creates a new HTTP client instance with the specified configuration.
+   *
+   * @param keyOrConfig - The key or configuration object for the HTTP client.
+   * @returns The created HTTP client instance.
+   *
+   * @remarks
+   * This method resolves the configuration for the HTTP client based on the provided `keyOrConfig` parameter.
+   * If a string is provided, it is treated as the key for a pre-configured client in the `HttpClientProvider`.
+   * If an `HttpClientOptions` object is provided, it is used as the configuration for the new client instance.
+   *
+   * The method sets up the HTTP client with the following options:
+   * - `baseUri`: The base URI for the HTTP client.
+   * - `defaultScopes`: The default scopes to be used for authentication.
+   * - `onCreate`: An optional callback function that is called when the client instance is created.
+   * - `ctor`: The constructor function for the HTTP client, defaulting to the configured `defaultHttpClientCtor`.
+   * - `requestHandler`: The HTTP request handler to be used by the client, defaulting to the `defaultHttpRequestHandler`.
+   *
+   * The created HTTP client instance is returned.
+   */
+  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;
+  }
 
-    /**
-     * Creates a new HTTP client instance with the specified configuration.
-     *
-     * @param key - The key of the pre-configured HTTP client to create.
-     * @returns The created HTTP client instance, cast to the specified type `T`.
-     *
-     * @remarks
-     * This method delegates to the `createClient` method, but casts the returned
-     * instance to the specified type `T`. This can be useful when you need to
-     * work with a specific HTTP client implementation, but the `HttpClientProvider`
-     * is configured to use a different implementation.
-     */
-    public createCustomClient<T extends HttpClient>(key: string): T {
-        return this.createClient(key) as unknown as T;
-    }
+  /**
+   * Creates a new HTTP client instance with the specified configuration.
+   *
+   * @param key - The key of the pre-configured HTTP client to create.
+   * @returns The created HTTP client instance, cast to the specified type `T`.
+   *
+   * @remarks
+   * This method delegates to the `createClient` method, but casts the returned
+   * instance to the specified type `T`. This can be useful when you need to
+   * work with a specific HTTP client implementation, but the `HttpClientProvider`
+   * is configured to use a different implementation.
+   */
+  public createCustomClient<T extends HttpClient>(key: string): T {
+    return this.createClient(key) as unknown as T;
+  }
 
-    /**
-     * Resolves the configuration for an HTTP client based on the provided `keyOrConfig` parameter.
-     *
-     * If a string is provided, it is treated as the key for a pre-configured client in the `HttpClientProvider`.
-     * If an `HttpClientOptions` object is provided, it is used as the configuration for the new client instance.
-     *
-     * @param keyOrConfig - The key or configuration object for the HTTP client.
-     * @returns The resolved HTTP client configuration.
-     */
-    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>;
+  /**
+   * Resolves the configuration for an HTTP client based on the provided `keyOrConfig` parameter.
+   *
+   * If a string is provided, it is treated as the key for a pre-configured client in the `HttpClientProvider`.
+   * If an `HttpClientOptions` object is provided, it is used as the configuration for the new client instance.
+   *
+   * @param keyOrConfig - The key or configuration object for the HTTP client.
+   * @returns The resolved HTTP client configuration.
+   */
+  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

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

package/tests/HttpClient.test.ts

@@ -8,41 +8,41 @@ import { lastValueFrom } from 'rxjs';
 let provider: HttpClientProvider;
 
 describe('HttpClient', () => {
-    beforeEach(() => {
-        const config = new HttpClientConfigurator(HttpClient);
-        config.configureClient('foo', 'http://localhost:3000');
-        provider = new HttpClientProvider(config);
-    });
-
-    it('should create instance', () => {
-        const client = provider.createClient('foo');
-        expect(client).toBeDefined();
-        expect(client.uri).toBe('http://localhost:3000');
-    });
-
-    it('should allow providing headers in request', async () => {});
-
-    it('should not modify configured headers', async () => {
-        // create a new client from configuration
-        const fooClient = provider.createClient('foo');
-        fooClient.requestHandler.setHeader('x-foo', 'bar');
-
-        // generate a RequestInit object
-        const fooRequest = await lastValueFrom(
-            fooClient.requestHandler.process({ path: '/api', uri: fooClient.uri }),
-        );
-
-        expect((fooRequest.headers as Headers)?.get('x-foo')).toBe('bar');
-
-        // create a new client from the same configuration
-        const barClient = provider.createClient('foo');
-
-        // generate a RequestInit object
-        const barRequest = await lastValueFrom(
-            barClient.requestHandler.process({ path: '/api', uri: barClient.uri }),
-        );
-
-        // expect the request header to not been modified
-        expect((barRequest.headers as Headers)?.get('x-foo')).toBeUndefined();
-    });
+  beforeEach(() => {
+    const config = new HttpClientConfigurator(HttpClient);
+    config.configureClient('foo', 'http://localhost:3000');
+    provider = new HttpClientProvider(config);
+  });
+
+  it('should create instance', () => {
+    const client = provider.createClient('foo');
+    expect(client).toBeDefined();
+    expect(client.uri).toBe('http://localhost:3000');
+  });
+
+  it('should allow providing headers in request', async () => {});
+
+  it('should not modify configured headers', async () => {
+    // create a new client from configuration
+    const fooClient = provider.createClient('foo');
+    fooClient.requestHandler.setHeader('x-foo', 'bar');
+
+    // generate a RequestInit object
+    const fooRequest = await lastValueFrom(
+      fooClient.requestHandler.process({ path: '/api', uri: fooClient.uri }),
+    );
+
+    expect((fooRequest.headers as Headers)?.get('x-foo')).toBe('bar');
+
+    // create a new client from the same configuration
+    const barClient = provider.createClient('foo');
+
+    // generate a RequestInit object
+    const barRequest = await lastValueFrom(
+      barClient.requestHandler.process({ path: '/api', uri: barClient.uri }),
+    );
+
+    // expect the request header to not been modified
+    expect((barRequest.headers as Headers)?.get('x-foo')).toBeUndefined();
+  });
 });