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

package/src/bookmarks/schemas.ts

@@ -3,38 +3,36 @@ import { ApiVersion } from './api-version';
 import { z } from 'zod';
 
 export const ApiDateSchema = z
-    .string()
-    .datetime({ offset: true })
-    .transform((x) => new Date(x));
+  .string()
+  .datetime({ offset: true })
+  .transform((x) => new Date(x));
 
 export const ApiPersonSchema = {
-    [ApiVersion.v1]: z.object({
-        azureUniqueId: z.string(),
-        name: z.string(),
-        mail: z.string().optional(),
-        phoneNumber: z.string().optional(),
-        jobTitle: z.string().optional(),
-        accountType: z
-            .enum(['Employee', 'Consultant', 'External', 'Application', 'Local'])
-            .optional(),
-        accountClassification: z.enum(['Unclassified', 'Internal', 'External']).nullish(),
-    }),
+  [ApiVersion.v1]: z.object({
+    azureUniqueId: z.string(),
+    name: z.string(),
+    mail: z.string().optional(),
+    phoneNumber: z.string().optional(),
+    jobTitle: z.string().optional(),
+    accountType: z.enum(['Employee', 'Consultant', 'External', 'Application', 'Local']).optional(),
+    accountClassification: z.enum(['Unclassified', 'Internal', 'External']).nullish(),
+  }),
 };
 
 export const ApiSourceSystem = {
-    [ApiVersion.v1]: z.object({
-        identifier: z.string(),
-        name: z.string().nullish(),
-        subSystem: z.string().nullish(),
-    }),
+  [ApiVersion.v1]: z.object({
+    identifier: z.string(),
+    name: z.string().nullish(),
+    subSystem: z.string().nullish(),
+  }),
 };
 
 export const ApiFusionContext = {
-    [ApiVersion.v1]: z.object({
-        id: z.string(),
-        name: z.string().nullish(),
-        type: z.string().nullish(),
-    }),
+  [ApiVersion.v1]: z.object({
+    id: z.string(),
+    name: z.string().nullish(),
+    type: z.string().nullish(),
+  }),
 };
 
 /**
@@ -43,39 +41,39 @@ export const ApiFusionContext = {
  * This schema is defined for the v1 API version, and the properties are validated using the Zod library.
  */
 export const ApiBookmarkSchema = {
-    get [ApiVersion.v1]() {
-        return z.object({
-            id: z.string(),
-            name: z.string(),
-            appKey: z.string(),
-            description: z.string().optional(),
-            isShared: z.boolean().optional(),
-            context: ApiFusionContext[ApiVersion.v1].optional(),
-            createdBy: ApiPersonSchema[ApiVersion.v1],
-            updatedBy: ApiPersonSchema[ApiVersion.v1].optional(),
-            created: ApiDateSchema,
-            updated: ApiDateSchema.optional(),
-            sourceSystem: ApiSourceSystem[ApiVersion.v1].nullish(),
-        });
-    },
-    get [ApiVersion.v2]() {
-        return this[ApiVersion.v1];
-    },
+  get [ApiVersion.v1]() {
+    return z.object({
+      id: z.string(),
+      name: z.string(),
+      appKey: z.string(),
+      description: z.string().optional(),
+      isShared: z.boolean().optional(),
+      context: ApiFusionContext[ApiVersion.v1].optional(),
+      createdBy: ApiPersonSchema[ApiVersion.v1],
+      updatedBy: ApiPersonSchema[ApiVersion.v1].optional(),
+      created: ApiDateSchema,
+      updated: ApiDateSchema.optional(),
+      sourceSystem: ApiSourceSystem[ApiVersion.v1].nullish(),
+    });
+  },
+  get [ApiVersion.v2]() {
+    return this[ApiVersion.v1];
+  },
 };
 
 export const ApiBookmarkPayload = {
-    get [ApiVersion.v1]() {
-        return z
-            .record(z.unknown())
-            .or(z.string())
-            .optional()
-            .default('')
-            .transform((x) => {
-                try {
-                    return typeof x === 'string' ? JSON.parse(x) : x;
-                } catch {
-                    return x;
-                }
-            });
-    },
+  get [ApiVersion.v1]() {
+    return z
+      .record(z.unknown())
+      .or(z.string())
+      .optional()
+      .default('')
+      .transform((x) => {
+        try {
+          return typeof x === 'string' ? JSON.parse(x) : x;
+        } catch {
+          return x;
+        }
+      });
+  },
 };

package/src/bookmarks/selectors.ts

@@ -1,5 +1,5 @@
 import { HttpJsonResponseError, HttpResponseError } from '@equinor/fusion-framework-module-http';
-import { type ResponseSelector } from '@equinor/fusion-framework-module-http/selectors';
+import type { ResponseSelector } from '@equinor/fusion-framework-module-http/selectors';
 
 /**
  * A response selector that checks the status of an HTTP response and throws an error if the response is not successful.
@@ -9,23 +9,23 @@ import { type ResponseSelector } from '@equinor/fusion-framework-module-http/sel
  * @throws {HttpJsonResponseError} If the response is not successful, with the error message, response, and any additional data or cause.
  */
 export const statusSelector: ResponseSelector<boolean> = async (res) => {
-    if (res.ok) {
-        return true;
+  if (res.ok) {
+    return true;
+  }
+  const message = `Failed to execute request. Status code: ${res.status}`;
+  let cause: unknown;
+  let data: unknown;
+  switch (res.status) {
+    case 403:
+    case 404: {
+      try {
+        data = await res.json();
+      } catch (error) {
+        cause = error;
+      }
     }
-    const message = `Failed to execute request. Status code: ${res.status}`;
-    let cause: unknown;
-    let data: unknown;
-    switch (res.status) {
-        case 403:
-        case 404: {
-            try {
-                data = await res.json();
-            } catch (error) {
-                cause = error;
-            }
-        }
-    }
-    throw new HttpJsonResponseError(message, res, { cause, data });
+  }
+  throw new HttpJsonResponseError(message, res, { cause, data });
 };
 
 /**
@@ -36,11 +36,11 @@ export const statusSelector: ResponseSelector<boolean> = async (res) => {
  * @throws {HttpJsonResponseError} If the response is not successful and does not have a 404 status code, with the error message, response, and any additional data or cause.
  */
 export const headSelector: ResponseSelector<boolean> = async (res) => {
-    if (res.ok) {
-        return true;
-    }
-    if (res.status === 404) {
-        return false;
-    }
-    throw new HttpResponseError(`Failed to execute request. Status code: ${res.status}`, res);
+  if (res.ok) {
+    return true;
+  }
+  if (res.status === 404) {
+    return false;
+  }
+  throw new HttpResponseError(`Failed to execute request. Status code: ${res.status}`, res);
 };

package/src/bookmarks/types.ts

@@ -1,16 +1,16 @@
 import type {
-    FilterAllowedApiVersions as FilterAllowApiVersionsBase,
-    ExtractApiVersion as ExtractApiVersionBase,
+  FilterAllowedApiVersions as FilterAllowApiVersionsBase,
+  ExtractApiVersion as ExtractApiVersionBase,
 } from '../types';
 
-import { ApiVersion } from './api-version';
+import type { ApiVersion } from './api-version';
 
 export { ClientMethodType, ClientMethod, ApiClientArguments } from '../types';
 
 export type FilterAllowedApiVersions<TAllowed extends string = keyof typeof ApiVersion> =
-    FilterAllowApiVersionsBase<typeof ApiVersion, TAllowed>;
+  FilterAllowApiVersionsBase<typeof ApiVersion, TAllowed>;
 
 export type ExtractApiVersion<
-    TVersion extends string,
-    TAllowed extends string = FilterAllowedApiVersions,
+  TVersion extends string,
+  TAllowed extends string = FilterAllowedApiVersions,
 > = ExtractApiVersionBase<typeof ApiVersion, TVersion, TAllowed>;

package/src/configurator.ts

@@ -1,8 +1,8 @@
-import { ApiClientFactory } from './types';
+import type { ApiClientFactory } from './types';
 
 export interface IApiConfigurator {
-    /** Method for creating IHttpClients */
-    createClient?: ApiClientFactory;
+  /** Method for creating IHttpClients */
+  createClient?: ApiClientFactory;
 }
 
 export class ApiConfigurator implements IApiConfigurator {}

package/src/context/api-models.ts

@@ -1,42 +1,42 @@
 import { ApiVersion } from './static';
 
 type ApiContextEntity_v1 = {
-    id: string;
-    externalId: string | null;
-    source: string | null;
-    type: ApiContextType_v1;
-    value: Record<string, unknown> | null;
-    title: string | null;
-    isActive: boolean;
-    isDeleted: boolean;
-    created: string;
-    updated: string | null;
+  id: string;
+  externalId: string | null;
+  source: string | null;
+  type: ApiContextType_v1;
+  value: Record<string, unknown> | null;
+  title: string | null;
+  isActive: boolean;
+  isDeleted: boolean;
+  created: string;
+  updated: string | null;
 };
 
 type ApiContextEntity_v2 = unknown;
 
 type ApiContextEntityTypes = {
-    [ApiVersion.v1]: ApiContextEntity_v1;
-    [ApiVersion.v2]: ApiContextEntity_v2;
+  [ApiVersion.v1]: ApiContextEntity_v1;
+  [ApiVersion.v2]: ApiContextEntity_v2;
 };
 
 export type ApiContextEntity<T extends string = ApiVersion> = T extends ApiVersion
-    ? ApiContextEntityTypes[T]
-    : unknown;
+  ? ApiContextEntityTypes[T]
+  : unknown;
 
 /** === types === */
 
 type ApiContextType_v1 = {
-    id: string;
-    isChildType: boolean;
-    parentTypeIds: string[] | null;
+  id: string;
+  isChildType: boolean;
+  parentTypeIds: string[] | null;
 };
 
 type ApiContextType_v2 = unknown;
 
 type ApiContextTypeTypes = {
-    [ApiVersion.v1]: ApiContextType_v1;
-    [ApiVersion.v2]: ApiContextType_v2;
+  [ApiVersion.v1]: ApiContextType_v1;
+  [ApiVersion.v2]: ApiContextType_v2;
 };
 
 export type ApiContextType<T extends ApiVersion> = ApiContextTypeTypes[T];

package/src/context/client.ts

@@ -1,76 +1,86 @@
-import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import type { IHttpClient } from '@equinor/fusion-framework-module-http';
 
 import type { ClientMethod } from './types';
 import { ApiVersion } from './static';
 
-import { getContext, GetContextFn, GetContextResponse, GetContextResult } from './get';
+import {
+  getContext,
+  type GetContextFn,
+  type GetContextResponse,
+  type GetContextResult,
+} from './get';
 
-import { queryContext, QueryContextFn, QueryContextResponse, QueryContextResult } from './query';
+import {
+  queryContext,
+  type QueryContextFn,
+  type QueryContextResponse,
+  type QueryContextResult,
+} from './query';
 
 import {
-    RelatedContextFn,
-    RelatedContextResponse,
-    RelatedContextResult,
-    relatedContexts,
+  type RelatedContextFn,
+  type RelatedContextResponse,
+  type RelatedContextResult,
+  relatedContexts,
 } from './related';
 
 export class ContextApiClient<
-    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
-    TClient extends IHttpClient = IHttpClient,
+  TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+  TClient extends IHttpClient = IHttpClient,
 > {
-    get Version(): typeof ApiVersion {
-        return ApiVersion;
-    }
+  get Version(): typeof ApiVersion {
+    return ApiVersion;
+  }
 
-    constructor(
-        protected _client: TClient,
-        protected _method: TMethod,
-    ) {}
+  constructor(
+    protected _client: TClient,
+    protected _method: TMethod,
+  ) {}
 
-    /**
-     * Fetch context by id
-     * @see {@link get/client}
-     */
-    public get<
-        TVersion extends string = keyof typeof ApiVersion,
-        TResult = GetContextResponse<TVersion>,
-    >(
-        version: TVersion,
-        ...args: Parameters<GetContextFn<TVersion, TMethod, TClient, TResult>>
-    ): GetContextResult<TVersion, TMethod, TResult> {
-        const fn = getContext<TVersion, TMethod, TClient>(this._client, version, this._method);
-        return fn<TResult>(...args);
-    }
+  /**
+   * Fetch context by id
+   * @see {@link get/client}
+   */
+  public get<
+    TVersion extends string = keyof typeof ApiVersion,
+    TResult = GetContextResponse<TVersion>,
+  >(
+    version: TVersion,
+    ...args: Parameters<GetContextFn<TVersion, TMethod, TClient, TResult>>
+  ): GetContextResult<TVersion, TMethod, TResult> {
+    const fn = getContext<TVersion, TMethod, TClient>(this._client, version, this._method);
+    return fn<TResult>(...args);
+  }
 
-    /**
-     * Query context service
-     * @see {@link query/client}
-     */
-    public query<
-        TVersion extends string = keyof typeof ApiVersion,
-        TResult = QueryContextResponse<TVersion>,
-    >(
-        version: TVersion,
-        ...args: Parameters<QueryContextFn<TVersion, TMethod, TClient, TResult>>
-    ): QueryContextResult<TVersion, TMethod, TResult> {
-        const fn = queryContext<TVersion, TMethod, TClient>(this._client, version, this._method);
-        return fn<TResult>(...args);
-    }
+  /**
+   * Query context service
+   * @see {@link query/client}
+   */
+  public query<
+    TVersion extends string = keyof typeof ApiVersion,
+    TResult = QueryContextResponse<TVersion>,
+  >(
+    version: TVersion,
+    ...args: Parameters<QueryContextFn<TVersion, TMethod, TClient, TResult>>
+  ): QueryContextResult<TVersion, TMethod, TResult> {
+    const fn = queryContext<TVersion, TMethod, TClient>(this._client, version, this._method);
+    return fn<TResult>(...args);
+  }
 
-    /**
-     * Query context service
-     * @see {@link query/client}
-     */
-    public related<
-        TVersion extends string = keyof typeof ApiVersion,
-        TResult = RelatedContextResponse<TVersion>,
-    >(
-        version: TVersion,
-        ...args: Parameters<RelatedContextFn<TVersion, TMethod, TClient, TResult>>
-    ): RelatedContextResult<TVersion, TMethod, TResult> {
-        const fn = relatedContexts<TVersion, TMethod, TClient>(this._client, version, this._method);
-        return fn<TResult>(...args);
-    }
+  /**
+   * Query context service
+   * @see {@link query/client}
+   */
+  public related<
+    TVersion extends string = keyof typeof ApiVersion,
+    TResult = RelatedContextResponse<TVersion>,
+  >(
+    version: TVersion,
+    ...args: Parameters<RelatedContextFn<TVersion, TMethod, TClient, TResult>>
+  ): RelatedContextResult<TVersion, TMethod, TResult> {
+    const fn = relatedContexts<TVersion, TMethod, TClient>(this._client, version, this._method);
+    return fn<TResult>(...args);
+  }
 }
 
 export default ContextApiClient;

package/src/context/get/client.ts

@@ -1,6 +1,6 @@
-import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 
-import { ApiVersion } from '..';
+import type { ApiVersion } from '..';
 
 import { generateParameters } from './generate-parameters';
 
@@ -13,21 +13,21 @@ import type { ClientMethod, GetContextArgs, GetContextResponse, GetContextResult
  * @param method - client method to call
  */
 export const getContext =
-    <
-        TVersion extends string = keyof typeof ApiVersion,
-        TMethod extends keyof ClientMethod = keyof ClientMethod,
-        TClient extends IHttpClient = IHttpClient,
-    >(
-        client: TClient,
-        version: TVersion,
-        method: TMethod = 'json' as TMethod,
-    ) =>
-    <T = GetContextResponse<TVersion>>(
-        args: GetContextArgs<TVersion>,
-        init?: ClientRequestInit<TClient, T>,
-    ): GetContextResult<TVersion, TMethod, T> =>
-        client[method](
-            ...generateParameters<T, TVersion, TClient>(version, args, init),
-        ) as GetContextResult<TVersion, TMethod, T>;
+  <
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod = keyof ClientMethod,
+    TClient extends IHttpClient = IHttpClient,
+  >(
+    client: TClient,
+    version: TVersion,
+    method: TMethod = 'json' as TMethod,
+  ) =>
+  <T = GetContextResponse<TVersion>>(
+    args: GetContextArgs<TVersion>,
+    init?: ClientRequestInit<TClient, T>,
+  ): GetContextResult<TVersion, TMethod, T> =>
+    client[method](
+      ...generateParameters<T, TVersion, TClient>(version, args, init),
+    ) as GetContextResult<TVersion, TMethod, T>;
 
 export default getContext;

package/src/context/get/generate-endpoint.ts

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

package/src/context/get/generate-parameters.ts

@@ -1,6 +1,6 @@
 import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 
-import { ApiVersion } from '..';
+import type { ApiVersion } from '..';
 
 import { generateEndpoint } from './generate-endpoint';
 
@@ -8,16 +8,16 @@ import type { ApiClientArguments, GetContextArgs } from './types';
 
 /** function for creating http client arguments  */
 export const generateParameters = <
-    TResult,
-    TVersion extends string = keyof typeof ApiVersion,
-    TClient extends IHttpClient = IHttpClient,
+  TResult,
+  TVersion extends string = keyof typeof ApiVersion,
+  TClient extends IHttpClient = IHttpClient,
 >(
-    version: TVersion,
-    args: GetContextArgs<TVersion>,
-    init?: ClientRequestInit<TClient, TResult>,
+  version: TVersion,
+  args: GetContextArgs<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/context/get/types.ts

@@ -1,45 +1,45 @@
-import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import type { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
 
-import { ApiVersion, ApiContextEntity, ClientMethod } from '..';
+import { ApiVersion, type ApiContextEntity, type ClientMethod } from '..';
 
 export { ApiClientArguments, ClientMethod } from '..';
 
 type GetContextArgs_v1 = {
-    id: string;
+  id: string;
 };
 
 type GetContextArgs_v2 = GetContextArgs_v1;
 
 type GetContextArgsTypes = {
-    [ApiVersion.v1]: GetContextArgs_v1;
-    [ApiVersion.v2]: GetContextArgs_v2;
+  [ApiVersion.v1]: GetContextArgs_v1;
+  [ApiVersion.v2]: GetContextArgs_v2;
 };
 
 export type GetContextArgs<T extends string> = T extends keyof typeof ApiVersion
-    ? GetContextArgsTypes[(typeof ApiVersion)[T]]
-    : unknown;
+  ? GetContextArgsTypes[(typeof ApiVersion)[T]]
+  : unknown;
 
 type GetContextResponseTypes = {
-    [ApiVersion.v1]: ApiContextEntity<ApiVersion.v1>;
-    [ApiVersion.v2]: ApiContextEntity<ApiVersion.v2>;
+  [ApiVersion.v1]: ApiContextEntity<ApiVersion.v1>;
+  [ApiVersion.v2]: ApiContextEntity<ApiVersion.v2>;
 };
 
 export type GetContextResponse<T> = T extends keyof typeof ApiVersion
-    ? GetContextResponseTypes[(typeof ApiVersion)[T]]
-    : unknown;
+  ? GetContextResponseTypes[(typeof ApiVersion)[T]]
+  : unknown;
 
 export type GetContextFn<
-    TVersion extends string = keyof typeof ApiVersion,
-    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
-    TClient extends IHttpClient = IHttpClient,
-    TResult = GetContextResponse<TVersion>,
+  TVersion extends string = keyof typeof ApiVersion,
+  TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+  TClient extends IHttpClient = IHttpClient,
+  TResult = GetContextResponse<TVersion>,
 > = (
-    args: GetContextArgs<TVersion>,
-    init?: ClientRequestInit<TClient, TResult>,
+  args: GetContextArgs<TVersion>,
+  init?: ClientRequestInit<TClient, TResult>,
 ) => GetContextResult<TVersion, TMethod, TResult>;
 
 export type GetContextResult<
-    TVersion extends string = keyof typeof ApiVersion,
-    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
-    TResult = GetContextResponse<TVersion>,
+  TVersion extends string = keyof typeof ApiVersion,
+  TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+  TResult = GetContextResponse<TVersion>,
 > = ClientMethod<TResult>[TMethod];