@equinor/fusion-framework-module-services 5.1.1-msal-0b0dadf270ee512f019a325c2f1586f91f9150a4 → 5.1.2

package/src/people/person-photo/types.ts

@@ -1,25 +1,25 @@
-import { BlobResult } from '@equinor/fusion-framework-module-http/client';
+import type { BlobResult } from '@equinor/fusion-framework-module-http/client';
 import { ApiVersion } from '../static';
-import { ClientDataMethod } from '../../types';
+import type { ClientDataMethod } from '../../types';
 
 export type SupportedApiVersion = Extract<keyof typeof ApiVersion, 'v2'>;
 
 type ApiRequestArgsMap = {
-    [ApiVersion.v2]: {
-        azureId: string;
-    };
+  [ApiVersion.v2]: {
+    azureId: string;
+  };
 };
 
 export type AllowedArgs = ApiRequestArgsMap[keyof ApiRequestArgsMap];
 
 export type ApiRequestArgs<T extends SupportedApiVersion> =
-    ApiRequestArgsMap[(typeof ApiVersion)[T]];
+  ApiRequestArgsMap[(typeof ApiVersion)[T]];
 
 type ApiResponseTypes = {
-    [ApiVersion.v2]: BlobResult;
+  [ApiVersion.v2]: BlobResult;
 };
 
 export type ApiResponse<T extends SupportedApiVersion> = ApiResponseTypes[(typeof ApiVersion)[T]];
 
 export type ApiResult<TMethod extends keyof ClientDataMethod = keyof ClientDataMethod> =
-    ClientDataMethod[TMethod];
+  ClientDataMethod[TMethod];

package/src/people/query/client.ts

@@ -1,4 +1,4 @@
-import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 
 import { generateParameters } from './generate-parameters';
 
@@ -12,22 +12,24 @@ import type { ApiResponse, ApiResult, ApiRequestArgs, SupportedApiVersion } from
  * @param method - client method to call
  */
 export const client =
-    <
-        TVersion extends SupportedApiVersion,
-        TMethod extends keyof ClientMethod = keyof ClientMethod,
-        TClient extends IHttpClient = IHttpClient,
-        TArgs extends ApiRequestArgs<TVersion> = ApiRequestArgs<TVersion>,
-    >(
-        client: TClient,
-        version: TVersion,
-        method: TMethod = 'json' as TMethod,
-    ) =>
-    <T = ApiResponse<TVersion>>(
-        args: TArgs,
-        init?: ClientRequestInit<TClient, T>,
-    ): ApiResult<TVersion, TMethod, T> =>
-        client[method](
-            ...generateParameters<T, TVersion, TClient>(version, args, init),
-        ) as ApiResult<TVersion, TMethod, T>;
+  <
+    TVersion extends SupportedApiVersion,
+    TMethod extends keyof ClientMethod = keyof ClientMethod,
+    TClient extends IHttpClient = IHttpClient,
+    TArgs extends ApiRequestArgs<TVersion> = ApiRequestArgs<TVersion>,
+  >(
+    client: TClient,
+    version: TVersion,
+    method: TMethod = 'json' as TMethod,
+  ) =>
+  <T = ApiResponse<TVersion>>(
+    args: TArgs,
+    init?: ClientRequestInit<TClient, T>,
+  ): ApiResult<TVersion, TMethod, T> =>
+    client[method](...generateParameters<T, TVersion, TClient>(version, args, init)) as ApiResult<
+      TVersion,
+      TMethod,
+      T
+    >;
 
 export default client;

package/src/people/query/generate-endpoint.ts

@@ -7,20 +7,20 @@ import type { ApiRequestArgs, SupportedApiVersion } from './types';
  * Method for generating endpoint for getting context by id
  */
 export const generateEndpoint = <TVersion extends SupportedApiVersion>(
-    version: TVersion,
-    args: ApiRequestArgs<TVersion>,
+  version: TVersion,
+  args: ApiRequestArgs<TVersion>,
 ) => {
-    const apiVersion = ApiVersion[version as keyof typeof ApiVersion] ?? version;
-    switch (apiVersion) {
-        case ApiVersion.v2: {
-            const { search } = args;
-            const params = new URLSearchParams();
-            params.append('api-version', apiVersion);
-            params.append('$search', search);
-            return `/persons?${String(params)}`;
-        }
-        default: {
-            throw new UnsupportedApiVersion(version);
-        }
+  const apiVersion = ApiVersion[version as keyof typeof ApiVersion] ?? version;
+  switch (apiVersion) {
+    case ApiVersion.v2: {
+      const { search } = args;
+      const params = new URLSearchParams();
+      params.append('api-version', apiVersion);
+      params.append('$search', search);
+      return `/persons?${String(params)}`;
     }
+    default: {
+      throw new UnsupportedApiVersion(version);
+    }
+  }
 };

package/src/people/query/generate-parameters.ts

@@ -7,16 +7,16 @@ import type { ApiRequestArgs, SupportedApiVersion } from './types';
 
 /** function for creating http client arguments  */
 export const generateParameters = <
-    TResult,
-    TVersion extends SupportedApiVersion,
-    TClient extends IHttpClient = IHttpClient,
+  TResult,
+  TVersion extends SupportedApiVersion,
+  TClient extends IHttpClient = IHttpClient,
 >(
-    version: TVersion,
-    args: ApiRequestArgs<TVersion>,
-    init?: ClientRequestInit<TClient, TResult>,
+  version: TVersion,
+  args: ApiRequestArgs<TVersion>,
+  init?: ClientRequestInit<TClient, TResult>,
 ): ApiClientArguments<TClient, TResult> => {
-    const path = generateEndpoint(version, args);
-    return [path, init];
+  const path = generateEndpoint(version, args);
+  return [path, init];
 };
 
 export default generateParameters;

package/src/people/query/types.ts

@@ -1,28 +1,28 @@
 import { ApiVersion } from '../static';
-import { ApiPerson_v2 } from '../api-models.v2';
-import { ClientMethod } from '../../types';
+import type { ApiPerson_v2 } from '../api-models.v2';
+import type { ClientMethod } from '../../types';
 
 export type SupportedApiVersion = Extract<keyof typeof ApiVersion, 'v2'>;
 
 type ApiRequestArgsMap = {
-    [ApiVersion.v2]: {
-        search: string;
-    };
+  [ApiVersion.v2]: {
+    search: string;
+  };
 };
 
 export type AllowedArgs = ApiRequestArgsMap[keyof ApiRequestArgsMap];
 
 export type ApiRequestArgs<T extends SupportedApiVersion> =
-    ApiRequestArgsMap[(typeof ApiVersion)[T]];
+  ApiRequestArgsMap[(typeof ApiVersion)[T]];
 
 type ApiResponseTypes = {
-    [ApiVersion.v2]: Array<ApiPerson_v2>;
+  [ApiVersion.v2]: Array<ApiPerson_v2>;
 };
 
 export type ApiResponse<T extends SupportedApiVersion> = ApiResponseTypes[(typeof ApiVersion)[T]];
 
 export type ApiResult<
-    TVersion extends SupportedApiVersion,
-    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
-    TResult = ApiResponse<TVersion>,
+  TVersion extends SupportedApiVersion,
+  TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+  TResult = ApiResponse<TVersion>,
 > = ClientMethod<TResult>[TMethod];

package/src/people/static.ts

@@ -1,4 +1,4 @@
 export enum ApiVersion {
-    'v2' = '2.0',
-    'v4' = '4.0',
+  v2 = '2.0',
+  v4 = '4.0',
 }

package/src/people/utils.ts

@@ -1,29 +1,29 @@
-import { ApiPerson } from './api-models';
+import type { ApiPerson } from './api-models';
 import { ApiVersion } from './static';
 
 // type SupportedApiVersion = Extract<keyof typeof ApiVersion, 'v2' | 'v4'>;
 
 const requiredApiPersonAttributes = {
-    [ApiVersion.v2]: [
-        'azureUniqueId',
-        /** TODO - has to be more required attributes to identify V2??? */
-    ] satisfies Array<keyof ApiPerson<'v2'>>,
-    [ApiVersion.v4]: [
-        /** TODO - has to be more required attributes to identify V4??? */
-        'azureUniqueId',
-    ] satisfies Array<keyof ApiPerson<'v4'>>,
+  [ApiVersion.v2]: [
+    'azureUniqueId',
+    /** TODO - has to be more required attributes to identify V2??? */
+  ] satisfies Array<keyof ApiPerson<'v2'>>,
+  [ApiVersion.v4]: [
+    /** TODO - has to be more required attributes to identify V4??? */
+    'azureUniqueId',
+  ] satisfies Array<keyof ApiPerson<'v4'>>,
 };
 
 export const isApiPerson = <V extends keyof typeof ApiVersion>(version: V) => {
-    /** todo add options for more strict check */
-    return <T>(value: T): value is T extends ApiPerson<V> ? T : never => {
-        /** early escape if value is not defined or not a object */
-        if (typeof value !== 'object') {
-            return false;
-        }
-        const attr = Object.keys(value as object);
-        const requiredAttr = requiredApiPersonAttributes[ApiVersion[version]];
-        const result = requiredAttr.every((key) => attr.includes(key));
-        return result;
-    };
+  /** todo add options for more strict check */
+  return <T>(value: T): value is T extends ApiPerson<V> ? T : never => {
+    /** early escape if value is not defined or not a object */
+    if (typeof value !== 'object') {
+      return false;
+    }
+    const attr = Object.keys(value as object);
+    const requiredAttr = requiredApiPersonAttributes[ApiVersion[version]];
+    const result = requiredAttr.every((key) => attr.includes(key));
+    return result;
+  };
 };

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.2';