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

package/src/context/query/client.ts

@@ -1,35 +1,35 @@
-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';
 
 import type {
-    QueryContextArgs,
-    QueryContextResponse,
-    QueryContextResult,
-    ClientMethod,
+  QueryContextArgs,
+  QueryContextResponse,
+  QueryContextResult,
+  ClientMethod,
 } from './types';
 
 /**
  * Function for querying the context service
  */
 export const queryContext =
-    <
-        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 = QueryContextResponse<TVersion>>(
-        args: QueryContextArgs<TVersion>,
-        init?: ClientRequestInit<TClient, T>,
-    ): QueryContextResult<TVersion, TMethod, T> =>
-        client[method](
-            ...generateParameters<T, TVersion, TClient>(version, args, init),
-        ) as QueryContextResult<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 = QueryContextResponse<TVersion>>(
+    args: QueryContextArgs<TVersion>,
+    init?: ClientRequestInit<TClient, T>,
+  ): QueryContextResult<TVersion, TMethod, T> =>
+    client[method](
+      ...generateParameters<T, TVersion, TClient>(version, args, init),
+    ) as QueryContextResult<TVersion, TMethod, T>;
 
 export default queryContext;

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

@@ -5,63 +5,62 @@ import { UnsupportedApiVersion } from '../../errors';
 import { ApiVersion } from '..';
 
 import type {
-    QueryContextArgs,
-    QueryContextOdataFilter,
-    QueryContextOdataParameters,
+  QueryContextArgs,
+  QueryContextOdataFilter,
+  QueryContextOdataParameters,
 } from './types';
 
 const buildOdataFilter = (filterObj: QueryContextOdataFilter) => {
-    return Object.keys(filterObj).reduce((acc, key) => {
-        switch (key) {
-            case 'type':
-                return filterObj[key]?.length ? { ...acc, [key]: { in: filterObj[key] } } : acc;
-            default:
-                return { ...acc, [key]: filterObj[key as keyof typeof filterObj] };
-        }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    }, {} as any);
+  return Object.keys(filterObj).reduce((acc, key) => {
+    switch (key) {
+      case 'type':
+        return filterObj[key]?.length ? { ...acc, [key]: { in: filterObj[key] } } : acc;
+      default:
+        return { ...acc, [key]: filterObj[key as keyof typeof filterObj] };
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  }, {} as any);
 };
 
 const buildOdataObject = (parameters: QueryContextOdataParameters) => {
-    return Object.entries(parameters)
-        .filter(([_, value]) => !!value)
-        .reduce((acc, [key, value]) => {
-            switch (key) {
-                case 'filter':
-                    return {
-                        ...acc,
-                        [key]: buildOdataFilter(value as QueryContextOdataFilter),
-                    };
-                default:
-                    return { ...acc, [key]: parameters[key as keyof typeof parameters] };
-            }
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        }, {} as any);
+  return Object.entries(parameters)
+    .filter(([_, value]) => !!value)
+    .reduce((acc, [key, value]) => {
+      switch (key) {
+        case 'filter':
+          return {
+            ...acc,
+            [key]: buildOdataFilter(value as QueryContextOdataFilter),
+          };
+        default:
+          return { ...acc, [key]: parameters[key as keyof typeof parameters] };
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }, {} as any);
 };
 
 const createSearchParameters = (args: string | QueryContextOdataParameters) => {
-    return typeof args === 'string' ? args : buildOdataQuery(buildOdataObject(args));
+  return typeof args === 'string' ? args : buildOdataQuery(buildOdataObject(args));
 };
 
 export const generateEndpoint = <TVersion extends string = keyof typeof ApiVersion>(
-    version: TVersion,
-    args: QueryContextArgs<TVersion>,
-) => {
-    const apiVersion = ApiVersion[version as keyof typeof ApiVersion] ?? version;
-    switch (apiVersion) {
-        case ApiVersion.v2:
-            throw new UnsupportedApiVersion(version);
-        case ApiVersion.v1:
-        default: {
-            const { query, includeDeleted } = args as QueryContextArgs<'v1'>;
-            const params = new URLSearchParams(createSearchParameters(query));
-            params.append('api-version', apiVersion);
-            if (includeDeleted) {
-                params.append('includeDeleted', 'true');
-            }
-            return `/contexts/?${String(params)}`;
-        }
+  version: TVersion,
+  args: QueryContextArgs<TVersion>,
+): string => {
+  const apiVersion = ApiVersion[version as keyof typeof ApiVersion] ?? version;
+  switch (apiVersion) {
+    case ApiVersion.v2:
+      throw new UnsupportedApiVersion(version);
+    default: {
+      const { query, includeDeleted } = args as QueryContextArgs<'v1'>;
+      const params = new URLSearchParams(createSearchParameters(query));
+      params.append('api-version', apiVersion);
+      if (includeDeleted) {
+        params.append('includeDeleted', 'true');
+      }
+      return `/contexts/?${String(params)}`;
     }
+  }
 };
 
 export default generateEndpoint;

package/src/context/query/generate-parameters.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 { generateEndpoint } from './generate-endpoint';
 
@@ -8,16 +8,16 @@ import type { QueryContextArgs, ApiClientArguments } from './types';
 
 /** Function for generating parameter for querying context service  */
 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: QueryContextArgs<TVersion>,
-    init?: ClientRequestInit<TClient, TResult>,
+  version: TVersion,
+  args: QueryContextArgs<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/query/types.ts

@@ -1,56 +1,56 @@
-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 '..';
 
 export type QueryContextOdataFilter = {
-    type?: string[];
-    externalId?: string;
+  type?: string[];
+  externalId?: string;
 };
 
 export type QueryContextOdataParameters = {
-    search?: string;
-    filter?: QueryContextOdataFilter;
+  search?: string;
+  filter?: QueryContextOdataFilter;
 };
 
 type QueryContextArgs_v1 = {
-    query: string | QueryContextOdataParameters;
-    includeDeleted?: boolean;
+  query: string | QueryContextOdataParameters;
+  includeDeleted?: boolean;
 };
 
 type QueryContextArgs_v2 = QueryContextArgs_v1;
 
 type SearchContextArgTypes = {
-    [ApiVersion.v1]: QueryContextArgs_v1;
-    [ApiVersion.v2]: QueryContextArgs_v2;
+  [ApiVersion.v1]: QueryContextArgs_v1;
+  [ApiVersion.v2]: QueryContextArgs_v2;
 };
 
 export type QueryContextArgs<T> = T extends keyof typeof ApiVersion
-    ? SearchContextArgTypes[(typeof ApiVersion)[T]]
-    : { query: { search: string } };
+  ? SearchContextArgTypes[(typeof ApiVersion)[T]]
+  : { query: { search: string } };
 
 type QueryContextResponseTypes = {
-    [ApiVersion.v1]: Array<ApiContextEntity<ApiVersion.v1>>;
-    [ApiVersion.v2]: Array<ApiContextEntity<ApiVersion.v2>>;
+  [ApiVersion.v1]: Array<ApiContextEntity<ApiVersion.v1>>;
+  [ApiVersion.v2]: Array<ApiContextEntity<ApiVersion.v2>>;
 };
 
 export type QueryContextResponse<T> = T extends keyof typeof ApiVersion
-    ? QueryContextResponseTypes[(typeof ApiVersion)[T]]
-    : unknown;
+  ? QueryContextResponseTypes[(typeof ApiVersion)[T]]
+  : unknown;
 
 export type QueryContextFn<
-    TVersion extends string = keyof typeof ApiVersion,
-    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
-    TClient extends IHttpClient = IHttpClient,
-    TResult = QueryContextResponse<TVersion>,
+  TVersion extends string = keyof typeof ApiVersion,
+  TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+  TClient extends IHttpClient = IHttpClient,
+  TResult = QueryContextResponse<TVersion>,
 > = (
-    args: QueryContextArgs<TVersion>,
-    init?: ClientRequestInit<TClient, TResult>,
+  args: QueryContextArgs<TVersion>,
+  init?: ClientRequestInit<TClient, TResult>,
 ) => QueryContextResult<TVersion, TMethod, TResult>;
 
 export type QueryContextResult<
-    TVersion extends string = keyof typeof ApiVersion,
-    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
-    TResult = QueryContextResponse<TVersion>,
+  TVersion extends string = keyof typeof ApiVersion,
+  TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+  TResult = QueryContextResponse<TVersion>,
 > = ClientMethod<TResult>[TMethod];

package/src/context/related/client.ts

@@ -1,35 +1,35 @@
-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';
 
 import type {
-    RelatedContextArgs,
-    RelatedContextResponse,
-    RelatedContextResult,
-    ClientMethod,
+  RelatedContextArgs,
+  RelatedContextResponse,
+  RelatedContextResult,
+  ClientMethod,
 } from './types';
 
 /**
  * Function for querying the context service
  */
 export const relatedContexts =
-    <
-        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 = RelatedContextResponse<TVersion>>(
-        args: RelatedContextArgs<TVersion>,
-        init?: ClientRequestInit<TClient, T>,
-    ): RelatedContextResult<TVersion, TMethod, T> =>
-        client[method](
-            ...generateParameters<T, TVersion, TClient>(version, args, init),
-        ) as RelatedContextResult<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 = RelatedContextResponse<TVersion>>(
+    args: RelatedContextArgs<TVersion>,
+    init?: ClientRequestInit<TClient, T>,
+  ): RelatedContextResult<TVersion, TMethod, T> =>
+    client[method](
+      ...generateParameters<T, TVersion, TClient>(version, args, init),
+    ) as RelatedContextResult<TVersion, TMethod, T>;
 
 export default relatedContexts;

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

@@ -5,59 +5,58 @@ import { UnsupportedApiVersion } from '../../errors';
 import { ApiVersion } from '..';
 
 import type {
-    RelatedContextArgs,
-    RelatedContextOdataFilter,
-    RelatedContextOdataParameters,
+  RelatedContextArgs,
+  RelatedContextOdataFilter,
+  RelatedContextOdataParameters,
 } from './types';
 
 const buildOdataFilter = (filterObj: RelatedContextOdataFilter) => {
-    return Object.keys(filterObj).reduce((acc, key) => {
-        switch (key) {
-            case 'type':
-                return filterObj[key]?.length ? { ...acc, [key]: { in: filterObj[key] } } : acc;
-            default:
-                return { ...acc, [key]: filterObj[key as keyof typeof filterObj] };
-        }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    }, {} as any);
+  return Object.keys(filterObj).reduce((acc, key) => {
+    switch (key) {
+      case 'type':
+        return filterObj[key]?.length ? { ...acc, [key]: { in: filterObj[key] } } : acc;
+      default:
+        return { ...acc, [key]: filterObj[key as keyof typeof filterObj] };
+    }
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  }, {} as any);
 };
 const buildOdataObject = (parameters: RelatedContextOdataParameters) => {
-    return Object.entries(parameters)
-        .filter(([_, value]) => !!value)
-        .reduce((acc, [key, value]) => {
-            switch (key) {
-                case 'filter':
-                    return {
-                        ...acc,
-                        [key]: buildOdataFilter(value as RelatedContextOdataFilter),
-                    };
-                default:
-                    return { ...acc, [key]: parameters[key as keyof typeof parameters] };
-            }
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        }, {} as any);
+  return Object.entries(parameters)
+    .filter(([_, value]) => !!value)
+    .reduce((acc, [key, value]) => {
+      switch (key) {
+        case 'filter':
+          return {
+            ...acc,
+            [key]: buildOdataFilter(value as RelatedContextOdataFilter),
+          };
+        default:
+          return { ...acc, [key]: parameters[key as keyof typeof parameters] };
+      }
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    }, {} as any);
 };
 
 const createSearchParameters = (args: string | RelatedContextOdataParameters) => {
-    return typeof args === 'string' ? args : buildOdataQuery(buildOdataObject(args));
+  return typeof args === 'string' ? args : buildOdataQuery(buildOdataObject(args));
 };
 
 export const generateEndpoint = <TVersion extends string = keyof typeof ApiVersion>(
-    version: TVersion,
-    args: RelatedContextArgs<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, query } = args as RelatedContextArgs<'v1'>;
-            const params = new URLSearchParams(createSearchParameters(query || ''));
-            params.append('api-version', apiVersion);
-            return `/contexts/${id}/relations?${String(params)}`;
-        }
+  version: TVersion,
+  args: RelatedContextArgs<TVersion>,
+): string => {
+  const apiVersion = ApiVersion[version as keyof typeof ApiVersion] ?? version;
+  switch (apiVersion) {
+    case ApiVersion.v2:
+      throw new UnsupportedApiVersion(version);
+    default: {
+      const { id, query } = args as RelatedContextArgs<'v1'>;
+      const params = new URLSearchParams(createSearchParameters(query || ''));
+      params.append('api-version', apiVersion);
+      return `/contexts/${id}/relations?${String(params)}`;
     }
+  }
 };
 
 export default generateEndpoint;

package/src/context/related/generate-parameters.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 { generateEndpoint } from './generate-endpoint';
 
@@ -8,16 +8,16 @@ import type { RelatedContextArgs, ApiClientArguments } from './types';
 
 /** Function for generating parameter for querying context service  */
 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: RelatedContextArgs<TVersion>,
-    init?: ClientRequestInit<TClient, TResult>,
+  version: TVersion,
+  args: RelatedContextArgs<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/related/types.ts

@@ -1,61 +1,61 @@
-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 '..';
 
 export type ApiRelatedContextEntity<T extends ApiVersion> = ApiContextEntity<T> & {
-    relationSource: string; // "ProjectMaster|OrgChart",
-    relationType: unknown;
+  relationSource: string; // "ProjectMaster|OrgChart",
+  relationType: unknown;
 };
 
 export type RelatedContextOdataFilter = {
-    type?: string[];
+  type?: string[];
 };
 
 export type RelatedContextOdataParameters = {
-    search?: string;
-    filter?: RelatedContextOdataFilter;
+  search?: string;
+  filter?: RelatedContextOdataFilter;
 };
 
 type RelatedContextArgs_v1 = {
-    /** context id */
-    id: string;
-    query?: string | RelatedContextOdataParameters;
+  /** context id */
+  id: string;
+  query?: string | RelatedContextOdataParameters;
 };
 
 type RelatedContextArgs_v2 = RelatedContextArgs_v1;
 
 type RelatedContextArgTypes = {
-    [ApiVersion.v1]: RelatedContextArgs_v1;
-    [ApiVersion.v2]: RelatedContextArgs_v2;
+  [ApiVersion.v1]: RelatedContextArgs_v1;
+  [ApiVersion.v2]: RelatedContextArgs_v2;
 };
 
 export type RelatedContextArgs<T> = T extends keyof typeof ApiVersion
-    ? RelatedContextArgTypes[(typeof ApiVersion)[T]]
-    : { id: string };
+  ? RelatedContextArgTypes[(typeof ApiVersion)[T]]
+  : { id: string };
 
 type RelatedContextResponseTypes = {
-    [ApiVersion.v1]: Array<ApiRelatedContextEntity<ApiVersion.v1>>;
-    [ApiVersion.v2]: Array<ApiRelatedContextEntity<ApiVersion.v2>>;
+  [ApiVersion.v1]: Array<ApiRelatedContextEntity<ApiVersion.v1>>;
+  [ApiVersion.v2]: Array<ApiRelatedContextEntity<ApiVersion.v2>>;
 };
 
 export type RelatedContextResponse<T> = T extends keyof typeof ApiVersion
-    ? RelatedContextResponseTypes[(typeof ApiVersion)[T]]
-    : unknown;
+  ? RelatedContextResponseTypes[(typeof ApiVersion)[T]]
+  : unknown;
 
 export type RelatedContextFn<
-    TVersion extends string = keyof typeof ApiVersion,
-    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
-    TClient extends IHttpClient = IHttpClient,
-    TResult = RelatedContextResponse<TVersion>,
+  TVersion extends string = keyof typeof ApiVersion,
+  TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+  TClient extends IHttpClient = IHttpClient,
+  TResult = RelatedContextResponse<TVersion>,
 > = (
-    args: RelatedContextArgs<TVersion>,
-    init?: ClientRequestInit<TClient, TResult>,
+  args: RelatedContextArgs<TVersion>,
+  init?: ClientRequestInit<TClient, TResult>,
 ) => RelatedContextResult<TVersion, TMethod, TResult>;
 
 export type RelatedContextResult<
-    TVersion extends string = keyof typeof ApiVersion,
-    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
-    TResult = RelatedContextResponse<TVersion>,
+  TVersion extends string = keyof typeof ApiVersion,
+  TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+  TResult = RelatedContextResponse<TVersion>,
 > = ClientMethod<TResult>[TMethod];

package/src/context/static.ts

@@ -1,6 +1,6 @@
 /** index of api versions of context service */
 export enum ApiVersion {
-    'v1' = '1.0',
-    /** not in use atm */
-    'v2' = '2.0',
+  v1 = '1.0',
+  /** not in use atm */
+  v2 = '2.0',
 }

package/src/errors.ts

@@ -1,8 +1,8 @@
 export class UnsupportedApiVersion extends Error {
-    constructor(
-        public readonly version: string | number,
-        cause?: unknown,
-    ) {
-        super(`unsupported version ${version}`, { cause });
-    }
+  constructor(
+    public readonly version: string | number,
+    cause?: unknown,
+  ) {
+    super(`unsupported version ${version}`, { cause });
+  }
 }