@equinor/fusion-framework-module-http 7.0.8 → 8.0.0

package/src/provider.ts

@@ -11,15 +11,19 @@ import { BaseModuleProvider } from '@equinor/fusion-framework-module/provider';
 import { version } from './version';
 
 /**
- * Exception thrown when a client cannot be found.
+ * Thrown when `createClient(name)` is called with an unknown client key.
  *
- * 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}
+ * This is only used when the provided string is neither a registered client name
+ * nor an absolute `http:` or `https:` URL.
  */
 export class ClientNotFoundException extends Error {}
 
+/**
+ * Creates fresh HTTP client instances from named or ad-hoc configuration.
+ *
+ * A provider can create clients from registered names, inline `HttpClientOptions`,
+ * or absolute URLs treated as ad-hoc `baseUri` values.
+ */
 export interface IHttpClientProvider<TClient extends IHttpClient = IHttpClient> {
   /**
    * The default HTTP request handler used by the HttpClientProvider.
@@ -43,35 +47,48 @@ export interface IHttpClientProvider<TClient extends IHttpClient = IHttpClient>
   createClient(key: HttpClientOptions<TClient>): TClient;
 
   /**
-   * Class cast creation of custom client
+   * Creates a client instance and casts it to a custom HTTP client type.
+   *
+   * This is most useful when the named client configuration uses a custom `ctor`
+   * that extends `HttpClient` with domain-specific methods.
    * @example
    * ```ts
-   * config.http.configureClient('foobar', (client) => {
-   *   client.ctor = MyClient;
-   *   client.uri = 'https://foobar.com';
+   * config.http.configureClient('foobar', {
+   *   ctor: MyClient,
+   *   baseUri: 'https://foobar.com',
    * });
+   * ```
    */
   createCustomClient<T extends HttpClient>(key: string): T;
 }
 
+/** URL protocols accepted as valid ad-hoc base URIs. */
+const SUPPORTED_PROTOCOLS = ['http:', 'https:', 'ws:', 'wss:'] as const;
+
 /**
- * Checks if a given string is a valid URL.
- * @param url - The string to check for a valid URL.
- * @returns `true` if the input string is a valid URL, `false` otherwise.
+ * Checks if a given string is a valid absolute URL with a supported protocol.
+ * @param url - The string to check.
+ * @returns `true` when the string uses one of {@link SUPPORTED_PROTOCOLS}.
  */
-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 isURL = (url: string): boolean => {
+  try {
+    const parsed = new URL(url);
+    return (SUPPORTED_PROTOCOLS as readonly string[]).includes(parsed.protocol);
+  } catch {
+    return false;
+  }
 };
 
+/**
+ * Heuristic check for strings that look like a bare hostname or URL without a
+ * protocol prefix (e.g. `api.example.com` or `api.example.com/v1`).
+ *
+ * Used to emit a deprecation warning when callers rely on the old (pre-patch)
+ * behaviour that accepted protocol-less URLs.
+ */
+const looksLikeURL = (value: string): boolean =>
+  !value.includes(' ') && /^[a-z\d]([a-z\d-]*\.)+[a-z]{2,}/i.test(value);
+
 /**
  * The `HttpClientProvider` class is responsible for managing HTTP client instances and their configuration.
  * It provides methods to check if a client is configured, create new client instances, and create custom client instances.
@@ -105,7 +122,7 @@ export class HttpClientProvider<TClient extends IHttpClient = IHttpClient>
   }
 
   /**
-   * Creates a new HTTP client instance with the specified configuration.
+   * Creates a fresh HTTP client instance from a named or ad-hoc configuration.
    *
    * @param keyOrConfig - The key or configuration object for the HTTP client.
    * @returns The created HTTP client instance.
@@ -115,12 +132,8 @@ export class HttpClientProvider<TClient extends IHttpClient = IHttpClient>
    * 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 method applies `baseUri`, `defaultScopes`, `requestHandler`, `responseHandler`,
+   * a custom `ctor` when configured, and finally runs `onCreate` for the newly created instance.
    *
    * The created HTTP client instance is returned.
    */
@@ -132,8 +145,9 @@ export class HttpClientProvider<TClient extends IHttpClient = IHttpClient>
       onCreate,
       ctor = this.config.defaultHttpClientCtor,
       requestHandler = this.defaultHttpRequestHandler,
+      responseHandler,
     } = config as HttpClientOptions<TClient>;
-    const options = { requestHandler };
+    const options = { requestHandler, responseHandler };
     const instance = new ctor(baseUri || '', options) as TClient;
     Object.assign(instance, { defaultScopes });
     onCreate?.(instance as TClient);
@@ -141,7 +155,7 @@ export class HttpClientProvider<TClient extends IHttpClient = IHttpClient>
   }
 
   /**
-   * Creates a new HTTP client instance with the specified configuration.
+   * Creates a client instance and returns it as the requested custom client type.
    *
    * @param key - The key of the pre-configured HTTP client to create.
    * @returns The created HTTP client instance, cast to the specified type `T`.
@@ -159,8 +173,9 @@ export class HttpClientProvider<TClient extends IHttpClient = IHttpClient>
   /**
    * 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.
+   * If a string is provided, it is treated as either a pre-configured client key or,
+   * when it is an absolute `http:` or `https:` URL, as an ad-hoc `baseUri`.
+   * If an `HttpClientOptions` object is provided, it is used directly 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.
@@ -172,6 +187,13 @@ export class HttpClientProvider<TClient extends IHttpClient = IHttpClient>
       const config = this.config.clients[keyOrConfig];
       if (!config && isURL(keyOrConfig)) {
         return { baseUri: keyOrConfig };
+      } else if (!config && looksLikeURL(keyOrConfig)) {
+        console.warn(
+          `[HttpClientProvider] "${keyOrConfig}" looks like a URL but is missing the http:// or https:// protocol. ` +
+            `Treating it as "https://${keyOrConfig}". ` +
+            `Pass a fully-qualified URL to silence this warning.`,
+        );
+        return { baseUri: `https://${keyOrConfig}` };
       } else if (!config) {
         throw new ClientNotFoundException(`No registered http client for key [${keyOrConfig}]`);
       }

package/src/version.ts

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

package/tests/HttpClient.test.ts

@@ -1,9 +1,10 @@
-import { describe, it, expect, beforeEach } from 'vitest';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { lastValueFrom } from 'rxjs';
 
+import { ClientNotFoundException, HttpClientProvider } from '../src';
 import { HttpClientConfigurator } from '../src/configurator';
-import { HttpClient } from '../src/lib';
-import { HttpClientProvider } from '../src';
-import { lastValueFrom } from 'rxjs';
+import { HttpClient, HttpClientMsal } from '../src/lib';
+import { HttpResponseHandler } from '../src/lib/operators';
 
 let provider: HttpClientProvider;
 
@@ -14,35 +15,113 @@ describe('HttpClient', () => {
     provider = new HttpClientProvider(config);
   });
 
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
   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 allow providing headers in request', async () => {
+    const client = provider.createClient('foo');
+    client.requestHandler.setHeader('x-foo', 'bar');
+
+    const request = await lastValueFrom(
+      client.requestHandler.process({
+        path: '/api',
+        uri: client.uri,
+        headers: { 'x-bar': 'baz' },
+      }),
+    );
+
+    const headers = request.headers as Headers;
+    expect(headers.get('x-foo')).toBe('bar');
+    expect(headers.get('x-bar')).toBe('baz');
+  });
 
   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();
   });
+
+  it('should execute configured response handlers from client options', async () => {
+    const responseSpy = vi.fn();
+    const config = new HttpClientConfigurator(HttpClient);
+
+    config.configureClient('bar', {
+      baseUri: 'http://localhost:3000',
+      responseHandler: new HttpResponseHandler({
+        'response-spy': responseSpy,
+      }),
+    });
+
+    const localProvider = new HttpClientProvider(config);
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response(null, { status: 200 }));
+
+    await localProvider.createClient('bar').fetch('/api');
+
+    expect(responseSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it('should emit the original path on the request stream', async () => {
+    const requestSpy = vi.fn();
+    vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response(null, { status: 200 }));
+
+    const client = provider.createClient('foo');
+    const subscription = client.request$.subscribe(requestSpy);
+
+    await client.fetch('/api');
+    subscription.unsubscribe();
+
+    expect(requestSpy).toHaveBeenCalledWith(
+      expect.objectContaining({
+        path: '/api',
+        uri: 'http://localhost:3000/api',
+      }),
+    );
+  });
+
+  it('should throw when a configured client cannot be found', () => {
+    expect(() => provider.createClient('missing-client')).toThrowError(
+      new ClientNotFoundException('No registered http client for key [missing-client]'),
+    );
+  });
+
+  it('should treat a bare hostname as https:// URL with a warning', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    const client = provider.createClient('api.example.com');
+    expect(client.uri).toBe('https://api.example.com');
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('missing the http:// or https:// protocol'),
+    );
+  });
+});
+
+describe('HttpClientMsal', () => {
+  it('should not mutate the provided request init object', () => {
+    const client = new HttpClientMsal('http://localhost:3000');
+    client.defaultScopes = ['scope.default'];
+
+    const init = { scopes: ['scope.request'] };
+
+    client.fetch$('/api', init);
+
+    expect(init).toStrictEqual({ scopes: ['scope.request'] });
+  });
 });

package/tests/operators.test.ts

@@ -1,9 +1,12 @@
 /* eslint-disable @typescript-eslint/ban-ts-comment */
 import { describe, it, expect, vi } from 'vitest';
+import { lastValueFrom, of } from 'rxjs';
+import { toArray } from 'rxjs/operators';
 import {
   capitalizeRequestMethodOperator,
   type ProcessOperator,
   requestValidationOperator,
+  sseMap,
 } from '../src/lib/operators';
 import type { FetchRequest } from '../src/lib';
 
@@ -107,3 +110,24 @@ describe('requestValidationOperator', () => {
     await expect(result).rejects.toThrowError('RFC 2615');
   });
 });
+
+describe('sseMap', () => {
+  it('should map SSE responses through the operators index export', async () => {
+    const response = new Response(
+      new ReadableStream({
+        start(controller) {
+          controller.enqueue(new TextEncoder().encode('data: {"key": "value"}\n\n'));
+          controller.close();
+        },
+      }),
+      {
+        headers: { 'Content-Type': 'text/event-stream' },
+        status: 200,
+      },
+    );
+
+    const events = await lastValueFrom(of(response).pipe(sseMap<{ key: string }>(), toArray()));
+
+    expect(events).toEqual([{ data: { key: 'value' } }]);
+  });
+});

package/tests/sse.selector.test.ts

@@ -1,9 +1,8 @@
 import { describe, it, expect } from 'vitest';
 import { ServerSentEventResponseError } from '../src/errors.js';
-import { createSseSelector } from '../src/lib/selectors/sse-selector.js'; // Adjust the import path as needed
+import { createSseSelector, type ServerSentEvent } from '../src/lib/selectors';
 import { of, lastValueFrom } from 'rxjs';
 import { concatMap, scan } from 'rxjs/operators';
-import { set } from 'zod';
 
 // Helper to create a mock Response
 function createMockResponse(
@@ -34,7 +33,7 @@ describe('createSseSelector', () => {
     const events = await lastValueFrom(
       of(response).pipe(
         concatMap(selector),
-        scan((acc, event) => [...acc, event], [] as any[]),
+        scan((acc, event) => [...acc, event], [] as ServerSentEvent[]),
       ),
     );
     expect(events).toEqual([{ data: { key: 'value' } }]);
@@ -79,7 +78,7 @@ describe('createSseSelector', () => {
     const events = await lastValueFrom(
       of(response).pipe(
         concatMap(selector),
-        scan((acc, event) => [...acc, event], [] as any[]),
+        scan((acc, event) => [...acc, event], [] as ServerSentEvent[]),
       ),
     );
 
@@ -98,7 +97,7 @@ describe('createSseSelector', () => {
     const events = await lastValueFrom(
       of(response).pipe(
         concatMap(selector),
-        scan((acc, event) => [...acc, event], [] as any[]),
+        scan((acc, event) => [...acc, event], [] as ServerSentEvent[]),
       ),
     );
 
@@ -117,7 +116,7 @@ describe('createSseSelector', () => {
     const events = await lastValueFrom(
       of(response).pipe(
         concatMap(selector),
-        scan((acc, event) => [...acc, event], [] as any[]),
+        scan((acc, event) => [...acc, event], [] as ServerSentEvent[]),
       ),
     );
 
@@ -136,7 +135,7 @@ describe('createSseSelector', () => {
     const eventsPromise = lastValueFrom(
       of(response).pipe(
         concatMap(selector),
-        scan((acc, event) => [...acc, event], [] as any[]),
+        scan((acc, event) => [...acc, event], [] as ServerSentEvent[]),
       ),
     );