@equinor/fusion-framework-module-services 5.1.1-msal-6cf764b628c2afdd64dfd06e42abc953d78556d2 → 5.1.1

package/src/provider.ts

@@ -1,117 +1,117 @@
-import { IHttpClient } from '@equinor/fusion-framework-module-http';
-import { ClientMethod } from './types';
+import type { IHttpClient } from '@equinor/fusion-framework-module-http';
+import type { ClientMethod } from './types';
 
-import { ApiClientFactory } from './types';
+import type { ApiClientFactory } from './types';
 import { ContextApiClient } from './context';
 import BookmarksApiClient from './bookmarks/client';
 import { NotificationApiClient } from './notification';
 import { PeopleApiClient } from './people/client';
 
 export interface IApiProvider<TClient extends IHttpClient = IHttpClient> {
-    /**
-     * @param method - Version of the service to use
-     */
-    createBookmarksClient<TMethod extends keyof ClientMethod>(
-        method: TMethod,
-    ): Promise<BookmarksApiClient<TMethod, TClient>>;
+  /**
+   * @param method - Version of the service to use
+   */
+  createBookmarksClient<TMethod extends keyof ClientMethod>(
+    method: TMethod,
+  ): Promise<BookmarksApiClient<TMethod, TClient>>;
 
-    /**
-     * @param method - Version of the service to use
-     */
-    createContextClient<TMethod extends keyof ClientMethod>(
-        method: TMethod,
-    ): Promise<ContextApiClient<TMethod, TClient>>;
-    /**
-     * @param method - Version of the service to use
-     */
-    createNotificationClient<TMethod extends keyof ClientMethod>(
-        method: TMethod,
-    ): Promise<NotificationApiClient<TMethod, TClient>>;
-    /**
-     * @param method - Version of the service to use
-     */
-    createPeopleClient(): Promise<PeopleApiClient<TClient>>;
+  /**
+   * @param method - Version of the service to use
+   */
+  createContextClient<TMethod extends keyof ClientMethod>(
+    method: TMethod,
+  ): Promise<ContextApiClient<TMethod, TClient>>;
+  /**
+   * @param method - Version of the service to use
+   */
+  createNotificationClient<TMethod extends keyof ClientMethod>(
+    method: TMethod,
+  ): Promise<NotificationApiClient<TMethod, TClient>>;
+  /**
+   * @param method - Version of the service to use
+   */
+  createPeopleClient(): Promise<PeopleApiClient<TClient>>;
 }
 
 type ApiProviderCtorArgs<TClient extends IHttpClient = IHttpClient> = {
-    /** method for creating IHttpClients for api clients */
-    createClient: ApiClientFactory<TClient>;
+  /** method for creating IHttpClients for api clients */
+  createClient: ApiClientFactory<TClient>;
 };
 
 // TODO move to own file
 type ApiProviderErrorResponse = {
-    type: ResponseType;
-    status: number;
-    statusText: string;
-    headers: Headers;
-    url: string;
-    data: unknown;
+  type: ResponseType;
+  status: number;
+  statusText: string;
+  headers: Headers;
+  url: string;
+  data: unknown;
 };
 
 // TODO move to own file
 export class ApiProviderError extends Error {
-    readonly response: ApiProviderErrorResponse;
+  readonly response: ApiProviderErrorResponse;
 
-    constructor(msg: string, response: ApiProviderErrorResponse, options?: ErrorOptions) {
-        super(msg, options);
-        this.response = response;
-        this.name = 'ApiProviderError';
-    }
+  constructor(msg: string, response: ApiProviderErrorResponse, options?: ErrorOptions) {
+    super(msg, options);
+    this.response = response;
+    this.name = 'ApiProviderError';
+  }
 }
 
 // TODO move to own file
 const validateResponse = async (response: Response) => {
-    if (!response.ok) {
-        const { headers, status, statusText, type, url, bodyUsed } = response;
-        const isJson = headers.get('content-type')?.match(/application\/(\w*)?[+]?json/);
-        const data = !bodyUsed && (await (isJson ? response.json() : response.text()));
-        throw new ApiProviderError('failed to execute request, response was not ok', {
-            headers,
-            status,
-            statusText,
-            type,
-            url,
-            data,
-        });
-    }
+  if (!response.ok) {
+    const { headers, status, statusText, type, url, bodyUsed } = response;
+    const isJson = headers.get('content-type')?.match(/application\/(\w*)?[+]?json/);
+    const data = !bodyUsed && (await (isJson ? response.json() : response.text()));
+    throw new ApiProviderError('failed to execute request, response was not ok', {
+      headers,
+      status,
+      statusText,
+      type,
+      url,
+      data,
+    });
+  }
 };
 
 export class ApiProvider<TClient extends IHttpClient = IHttpClient>
-    implements IApiProvider<TClient>
+  implements IApiProvider<TClient>
 {
-    protected _createClientFn: ApiClientFactory<TClient>;
-    constructor({ createClient }: ApiProviderCtorArgs<TClient>) {
-        this._createClientFn = createClient;
-    }
+  protected _createClientFn: ApiClientFactory<TClient>;
+  constructor({ createClient }: ApiProviderCtorArgs<TClient>) {
+    this._createClientFn = createClient;
+  }
 
-    public async createNotificationClient<TMethod extends keyof ClientMethod>(
-        method: TMethod,
-    ): Promise<NotificationApiClient<TMethod, TClient>> {
-        const httpClient = await this._createClientFn('notification');
-        httpClient.responseHandler.add('validate_api_request', validateResponse);
-        return new NotificationApiClient(httpClient, method);
-    }
+  public async createNotificationClient<TMethod extends keyof ClientMethod>(
+    method: TMethod,
+  ): Promise<NotificationApiClient<TMethod, TClient>> {
+    const httpClient = await this._createClientFn('notification');
+    httpClient.responseHandler.add('validate_api_request', validateResponse);
+    return new NotificationApiClient(httpClient, method);
+  }
 
-    public async createBookmarksClient<TMethod extends keyof ClientMethod>(
-        method: TMethod,
-    ): Promise<BookmarksApiClient<TMethod, TClient>> {
-        const httpClient = await this._createClientFn('bookmarks');
-        // TODO: update when new ResponseOperator is available
-        // will fail because 'HEAD' will return 404 when no bookmarks are found
-        // httpClient.responseHandler.add('validate_api_request', validateResponse);
-        return new BookmarksApiClient(httpClient, method);
-    }
+  public async createBookmarksClient<TMethod extends keyof ClientMethod>(
+    method: TMethod,
+  ): Promise<BookmarksApiClient<TMethod, TClient>> {
+    const httpClient = await this._createClientFn('bookmarks');
+    // TODO: update when new ResponseOperator is available
+    // will fail because 'HEAD' will return 404 when no bookmarks are found
+    // httpClient.responseHandler.add('validate_api_request', validateResponse);
+    return new BookmarksApiClient(httpClient, method);
+  }
 
-    public async createContextClient<TMethod extends keyof ClientMethod>(
-        method: TMethod,
-    ): Promise<ContextApiClient<TMethod, TClient>> {
-        const httpClient = await this._createClientFn('context');
-        httpClient.responseHandler.add('validate_api_request', validateResponse);
-        return new ContextApiClient(httpClient, method);
-    }
-    public async createPeopleClient(): Promise<PeopleApiClient<TClient>> {
-        const httpClient = await this._createClientFn('people');
-        httpClient.responseHandler.add('validate_api_request', validateResponse);
-        return new PeopleApiClient(httpClient);
-    }
+  public async createContextClient<TMethod extends keyof ClientMethod>(
+    method: TMethod,
+  ): Promise<ContextApiClient<TMethod, TClient>> {
+    const httpClient = await this._createClientFn('context');
+    httpClient.responseHandler.add('validate_api_request', validateResponse);
+    return new ContextApiClient(httpClient, method);
+  }
+  public async createPeopleClient(): Promise<PeopleApiClient<TClient>> {
+    const httpClient = await this._createClientFn('people');
+    httpClient.responseHandler.add('validate_api_request', validateResponse);
+    return new PeopleApiClient(httpClient);
+  }
 }

package/src/types.ts

@@ -1,8 +1,8 @@
-import {
-    ClientRequestInit,
-    IHttpClient,
-    StreamResponse,
-    BlobResult,
+import type {
+  ClientRequestInit,
+  IHttpClient,
+  StreamResponse,
+  BlobResult,
 } from '@equinor/fusion-framework-module-http/client';
 
 /**
@@ -12,7 +12,7 @@ import {
  * @returns A Promise that resolves to an instance of the HTTP client.
  */
 export type ApiClientFactory<TClient extends IHttpClient = IHttpClient> = (
-    name: string,
+  name: string,
 ) => Promise<TClient>;
 
 /**
@@ -24,27 +24,27 @@ export type ApiClientFactory<TClient extends IHttpClient = IHttpClient> = (
  * @param init - Optional initialization options for the API client request.
  */
 export type ApiClientArguments<TClient extends IHttpClient, TResult = unknown> = [
-    path: string,
-    init?: ClientRequestInit<TClient, TResult>,
+  path: string,
+  init?: ClientRequestInit<TClient, TResult>,
 ];
 
 /**
  * Execute methods on the IHttpClient
  */
 export type ClientMethod<T = unknown> = {
-    /**
-     * Fetch JSON data from a service
-     */
-    json: Promise<T>;
-    /**
-     * Fetch JSON data from a service as observable
-     */
-    json$: StreamResponse<T>;
+  /**
+   * Fetch JSON data from a service
+   */
+  json: Promise<T>;
+  /**
+   * Fetch JSON data from a service as observable
+   */
+  json$: StreamResponse<T>;
 };
 
 export type ClientDataMethod<T extends BlobResult = BlobResult> = {
-    blob: Promise<T>;
-    blob$: StreamResponse<T>;
+  blob: Promise<T>;
+  blob$: StreamResponse<T>;
 };
 
 export type ClientMethodType = keyof ClientMethod;
@@ -97,16 +97,16 @@ export type ClientMethodType = keyof ClientMethod;
  *   values are a subset of `AllowedTypes`.
  */
 export type FilterAllowedApiVersions<
-    TAvailableTypes extends Record<string, string>,
-    TAllowedTypes extends string | number | symbol = keyof TAvailableTypes,
+  TAvailableTypes extends Record<string, string>,
+  TAllowedTypes extends string | number | symbol = keyof TAvailableTypes,
 > = {
-    [K in keyof TAvailableTypes]: TAvailableTypes extends Record<K, infer V>
-        ? K extends TAllowedTypes
-            ? K | V
-            : V extends TAllowedTypes
-              ? V | K
-              : never
-        : never;
+  [K in keyof TAvailableTypes]: TAvailableTypes extends Record<K, infer V>
+    ? K extends TAllowedTypes
+      ? K | V
+      : V extends TAllowedTypes
+        ? V | K
+        : never
+    : never;
 }[keyof TAvailableTypes];
 
 /**
@@ -118,11 +118,11 @@ export type FilterAllowedApiVersions<
  * @returns The API version type if it is available and allowed, otherwise `never`.
  */
 export type ExtractApiVersion<
-    TAvailableTypes extends Record<string, string>,
-    TVersion extends string,
-    TAllowedTypes extends string | number | symbol = FilterAllowedApiVersions<TAvailableTypes>,
+  TAvailableTypes extends Record<string, string>,
+  TVersion extends string,
+  TAllowedTypes extends string | number | symbol = FilterAllowedApiVersions<TAvailableTypes>,
 > = TVersion extends keyof TAvailableTypes
-    ? TAvailableTypes[TVersion]
-    : TVersion extends TAllowedTypes
-      ? TVersion
-      : never;
+  ? TAvailableTypes[TVersion]
+  : TVersion extends TAllowedTypes
+    ? TVersion
+    : never;

package/src/utils.ts

@@ -1,9 +1,9 @@
-import { z } from 'zod';
+import type { z } from 'zod';
 
-import { FetchResponse } from '@equinor/fusion-framework-module-http';
+import type { FetchResponse } from '@equinor/fusion-framework-module-http';
 import {
-    type ResponseSelector,
-    jsonSelector,
+  type ResponseSelector,
+  jsonSelector,
 } from '@equinor/fusion-framework-module-http/selectors';
 
 import type { ExtractApiVersion } from './types';
@@ -16,25 +16,21 @@ import type { ExtractApiVersion } from './types';
  * @returns The extracted API version, or throws an error if the version is not supported.
  */
 export const extractVersion = <
-    TApiVersions extends Record<string, string>,
-    TAllowedApiVersion extends string,
-    TVersion extends string,
+  TApiVersions extends Record<string, string>,
+  TAllowedApiVersion extends string,
+  TVersion extends string,
 >(
-    apiVersions: TApiVersions,
-    version: TVersion,
+  apiVersions: TApiVersions,
+  version: TVersion,
 ): ExtractApiVersion<TApiVersions, TVersion, TAllowedApiVersion> => {
-    if (version in apiVersions) {
-        return apiVersions[version] as ExtractApiVersion<
-            TApiVersions,
-            TVersion,
-            TAllowedApiVersion
-        >;
-    }
-    const extractedVersion = Object.values(apiVersions).find((v) => v === version);
-    if (!extractedVersion) {
-        throw new Error(`Version ${version} is not supported`);
-    }
-    return extractedVersion as ExtractApiVersion<TApiVersions, TVersion, TAllowedApiVersion>;
+  if (version in apiVersions) {
+    return apiVersions[version] as ExtractApiVersion<TApiVersions, TVersion, TAllowedApiVersion>;
+  }
+  const extractedVersion = Object.values(apiVersions).find((v) => v === version);
+  if (!extractedVersion) {
+    throw new Error(`Version ${version} is not supported`);
+  }
+  return extractedVersion as ExtractApiVersion<TApiVersions, TVersion, TAllowedApiVersion>;
 };
 
 /**
@@ -44,8 +40,8 @@ export const extractVersion = <
  * @returns A response selector function that parses the response body using the provided schema.
  */
 export const schemaSelector =
-    <Output, Def extends z.ZodTypeDef, Input>(
-        schema: z.ZodSchema<Output, Def, Input>,
-    ): ResponseSelector<Output> =>
-    async (response: FetchResponse<Input>) =>
-        schema.parse(await jsonSelector(response));
+  <Output, Def extends z.ZodTypeDef, Input>(
+    schema: z.ZodSchema<Output, Def, Input>,
+  ): ResponseSelector<Output> =>
+  async (response: FetchResponse<Input>) =>
+    schema.parse(await jsonSelector(response));

package/src/version.ts

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