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

package/src/module.ts

@@ -1,16 +1,16 @@
 import type {
-    IModuleConfigurator,
-    IModulesConfigurator,
-    Module,
+  IModuleConfigurator,
+  IModulesConfigurator,
+  Module,
 } from '@equinor/fusion-framework-module';
 import type { HttpModule, IHttpClientProvider } from '@equinor/fusion-framework-module-http';
 import type {
-    ServiceDiscoveryModule,
-    ServiceDiscoveryProvider,
+  ServiceDiscoveryModule,
+  ServiceDiscoveryProvider,
 } from '@equinor/fusion-framework-module-service-discovery';
 
-import { IApiConfigurator, ApiConfigurator } from './configurator';
-import { IApiProvider, ApiProvider } from './provider';
+import { type IApiConfigurator, ApiConfigurator } from './configurator';
+import { type IApiProvider, ApiProvider } from './provider';
 
 import type { ApiClientFactory } from './types';
 
@@ -19,52 +19,50 @@ export type ServicesModuleKey = 'services';
 export const moduleKey: ServicesModuleKey = 'services';
 
 export type ServicesModule = Module<
-    ServicesModuleKey,
-    IApiProvider,
-    IApiConfigurator,
-    [HttpModule, ServiceDiscoveryModule]
+  ServicesModuleKey,
+  IApiProvider,
+  IApiConfigurator,
+  [HttpModule, ServiceDiscoveryModule]
 >;
 
 /**
  * Method to trying to resolve method for creating an IHttpClient
  */
 const createDefaultClient =
-    (http: IHttpClientProvider, serviceDiscovery?: ServiceDiscoveryProvider): ApiClientFactory =>
-    async (name: string) => {
-        if (http.hasClient(name)) {
-            return http.createClient(name);
-        }
-        if (serviceDiscovery) {
-            return serviceDiscovery.createClient(name);
-        }
-        throw Error(`failed to create http client for service ${name}`);
-    };
+  (http: IHttpClientProvider, serviceDiscovery?: ServiceDiscoveryProvider): ApiClientFactory =>
+  async (name: string) => {
+    if (http.hasClient(name)) {
+      return http.createClient(name);
+    }
+    if (serviceDiscovery) {
+      return serviceDiscovery.createClient(name);
+    }
+    throw Error(`failed to create http client for service ${name}`);
+  };
 
 /**
  *  Configure http-client
  */
 export const module: ServicesModule = {
-    name: moduleKey,
-    configure: () => new ApiConfigurator(),
-    initialize: async ({ ref, config, requireInstance, hasModule }) => {
-        /** we can not create this callback within the configuration, since it might require other modules. */
-        if (!config.createClient) {
-            const http = await requireInstance('http');
-            const serviceDiscovery: ServiceDiscoveryProvider | undefined = hasModule(
-                'serviceDiscovery',
-            )
-                ? /** if the module is within module, await creation */
-                  await requireInstance('serviceDiscovery')
-                : /** try to load parent service discovery provider */
-                  ref?.serviceDiscovery;
+  name: moduleKey,
+  configure: () => new ApiConfigurator(),
+  initialize: async ({ ref, config, requireInstance, hasModule }) => {
+    /** we can not create this callback within the configuration, since it might require other modules. */
+    if (!config.createClient) {
+      const http = await requireInstance('http');
+      const serviceDiscovery: ServiceDiscoveryProvider | undefined = hasModule('serviceDiscovery')
+        ? /** if the module is within module, await creation */
+          await requireInstance('serviceDiscovery')
+        : /** try to load parent service discovery provider */
+          ref?.serviceDiscovery;
 
-            config.createClient = createDefaultClient(http, serviceDiscovery);
-        }
-        if (!config.createClient) {
-            throw Error('missing configuration for creating API client');
-        }
-        return new ApiProvider(config as Required<IApiConfigurator>);
-    },
+      config.createClient = createDefaultClient(http, serviceDiscovery);
+    }
+    if (!config.createClient) {
+      throw Error('missing configuration for creating API client');
+    }
+    return new ApiProvider(config as Required<IApiConfigurator>);
+  },
 };
 
 /**
@@ -72,10 +70,10 @@ export const module: ServicesModule = {
  * @param config - configuration object
  */
 export const enableServices = (
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    config: IModulesConfigurator<any, any>,
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  config: IModulesConfigurator<any, any>,
 ): void => {
-    config.addConfig({ module });
+  config.addConfig({ module });
 };
 
 /**
@@ -87,18 +85,18 @@ export const enableServices = (
  * @returns Configuration object
  */
 export const configureServices = (
-    configure: (configurator: IApiConfigurator) => void,
+  configure: (configurator: IApiConfigurator) => void,
 ): IModuleConfigurator<ServicesModule> => {
-    return {
-        module,
-        configure,
-    };
+  return {
+    module,
+    configure,
+  };
 };
 
 declare module '@equinor/fusion-framework-module' {
-    interface Modules {
-        services: ServicesModule;
-    }
+  interface Modules {
+    services: ServicesModule;
+  }
 }
 
 export default module;

package/src/notification/api-models.ts

@@ -1,70 +1,70 @@
 import { ApiVersion } from './static';
 
 type ApiNotificationEntity_v1 = {
-    id: string;
-    appKey: string;
-    emailPriority: number;
-    fallbackHtml: string;
-    targetAzureUniqueId: string;
-    title: string;
-    card: string;
-    created: string;
-    createdBy: CreatedBy_v1;
-    createdByApplication: CreatedByApplication_v1;
-    seenByUser: boolean;
-    seen: string;
-    sourceSystem: SourceSystem_v1;
+  id: string;
+  appKey: string;
+  emailPriority: number;
+  fallbackHtml: string;
+  targetAzureUniqueId: string;
+  title: string;
+  card: string;
+  created: string;
+  createdBy: CreatedBy_v1;
+  createdByApplication: CreatedByApplication_v1;
+  seenByUser: boolean;
+  seen: string;
+  sourceSystem: SourceSystem_v1;
 };
 
 type SourceSystem_v1 = {
-    name: string;
-    subSystem: string;
-    identifier: string;
+  name: string;
+  subSystem: string;
+  identifier: string;
 };
 
 type CreatedByApplication_v1 = {
-    id: string;
-    title: string;
+  id: string;
+  title: string;
 };
 
 type CreatedBy_v1 = {
-    id: string;
-    name: string;
-    jobTitle: string;
-    mail: string;
-    accountType: string;
+  id: string;
+  name: string;
+  jobTitle: string;
+  mail: string;
+  accountType: string;
 };
 
 type ApiNotificationEntity_v2 = unknown;
 
 type ApiNotificationEntityTypes = {
-    [ApiVersion.v1]: ApiNotificationEntity_v1;
-    [ApiVersion.v2]: ApiNotificationEntity_v2;
+  [ApiVersion.v1]: ApiNotificationEntity_v1;
+  [ApiVersion.v2]: ApiNotificationEntity_v2;
 };
 
 export type ApiNotificationEntity<T extends string = ApiVersion> = T extends ApiVersion
-    ? ApiNotificationEntityTypes[T]
-    : unknown;
+  ? ApiNotificationEntityTypes[T]
+  : unknown;
 
 /**User notification Settings */
 type ApiNotificationSettingsEntity_v1 = {
-    email: boolean;
-    delayInMinutes: number;
-    appConfig: AppConfig_v1[];
+  email: boolean;
+  delayInMinutes: number;
+  appConfig: AppConfig_v1[];
 };
 
 type AppConfig_v1 = {
-    appKey: string;
-    enabled: boolean;
+  appKey: string;
+  enabled: boolean;
 };
 
 type ApiNotificationSettingsEntity_v2 = unknown;
 
 type ApiNotificationSettingEntityTypes = {
-    [ApiVersion.v1]: ApiNotificationSettingsEntity_v1;
-    [ApiVersion.v2]: ApiNotificationSettingsEntity_v2;
+  [ApiVersion.v1]: ApiNotificationSettingsEntity_v1;
+  [ApiVersion.v2]: ApiNotificationSettingsEntity_v2;
 };
 
 export type ApiNotificationSettingsEntity<T extends string = ApiVersion> = T extends ApiVersion
-    ? ApiNotificationSettingEntityTypes[T]
-    : unknown;
+  ? ApiNotificationSettingEntityTypes[T]
+  : unknown;

package/src/notification/client.ts

@@ -1,170 +1,150 @@
-import { IHttpClient } from '@equinor/fusion-framework-module-http';
-import { ClientMethod } from '../types';
-import { GetNotificationFn, GetNotificationResult } from './notification/get';
+import type { IHttpClient } from '@equinor/fusion-framework-module-http';
+import type { ClientMethod } from '../types';
+import type { GetNotificationFn, GetNotificationResult } from './notification/get';
 import {
-    createNotification,
-    deleteNotification,
-    getNotificationById,
-    getNotifications,
-    updateSeenByUser,
+  createNotification,
+  deleteNotification,
+  getNotificationById,
+  getNotifications,
+  updateSeenByUser,
 } from './notification';
 import { ApiVersion } from './static';
-import { PatchNotificationFn, PatchNotificationResult } from './notification/patch';
-import { GetNotificationsFn, GetNotificationsResult } from './notification/getAll';
-import { PostNotificationResult, PostNotificationFn } from './notification/post';
-import { DeleteNotificationFn, DeleteNotificationResult } from './notification/delete';
+import type { PatchNotificationFn, PatchNotificationResult } from './notification/patch';
+import type { GetNotificationsFn, GetNotificationsResult } from './notification/getAll';
+import type { PostNotificationResult, PostNotificationFn } from './notification/post';
+import type { DeleteNotificationFn, DeleteNotificationResult } from './notification/delete';
 import updateUserNotificationSettings, {
-    PutUserNotificationSettingsFn,
-    PutUserNotificationSettingsResult,
+  type PutUserNotificationSettingsFn,
+  type PutUserNotificationSettingsResult,
 } from './settings/put';
 import getUserNotificationSettings, {
-    GetUserNotificationSettingsFn,
-    GetUserNotificationsSettingsResult,
+  type GetUserNotificationSettingsFn,
+  type GetUserNotificationsSettingsResult,
 } from './settings/get';
 
 export class NotificationApiClient<
-    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 all notifications
-     * @see {@link getAll/client}
-     */
-    public getAll<
-        TVersion extends string = keyof typeof ApiVersion,
-        TResult = GetNotificationsResult<TVersion>,
-    >(
-        version: TVersion,
-        ...args: Parameters<GetNotificationsFn<TVersion, TMethod, TClient, TResult>>
-    ): GetNotificationsResult<TVersion, TMethod, TResult> {
-        const fn = getNotifications<TVersion, TMethod, TClient>(
-            this._client,
-            version,
-            this._method,
-        );
-        return fn<TResult>(...args);
-    }
+  /**
+   * Fetch all notifications
+   * @see {@link getAll/client}
+   */
+  public getAll<
+    TVersion extends string = keyof typeof ApiVersion,
+    TResult = GetNotificationsResult<TVersion>,
+  >(
+    version: TVersion,
+    ...args: Parameters<GetNotificationsFn<TVersion, TMethod, TClient, TResult>>
+  ): GetNotificationsResult<TVersion, TMethod, TResult> {
+    const fn = getNotifications<TVersion, TMethod, TClient>(this._client, version, this._method);
+    return fn<TResult>(...args);
+  }
 
-    /**
-     * Fetch notification by id
-     * @see {@link getById/client}
-     */
-    public getById<
-        TVersion extends string = keyof typeof ApiVersion,
-        TResult = GetNotificationResult<TVersion>,
-    >(
-        version: TVersion,
-        ...args: Parameters<GetNotificationFn<TVersion, TMethod, TClient, TResult>>
-    ): GetNotificationResult<TVersion, TMethod, TResult> {
-        const fn = getNotificationById<TVersion, TMethod, TClient>(
-            this._client,
-            version,
-            this._method,
-        );
-        return fn<TResult>(...args);
-    }
+  /**
+   * Fetch notification by id
+   * @see {@link getById/client}
+   */
+  public getById<
+    TVersion extends string = keyof typeof ApiVersion,
+    TResult = GetNotificationResult<TVersion>,
+  >(
+    version: TVersion,
+    ...args: Parameters<GetNotificationFn<TVersion, TMethod, TClient, TResult>>
+  ): GetNotificationResult<TVersion, TMethod, TResult> {
+    const fn = getNotificationById<TVersion, TMethod, TClient>(this._client, version, this._method);
+    return fn<TResult>(...args);
+  }
 
-    /**
-     * Set notification seen by user
-     * @see {@link setSeenByUser/client}
-     */
-    public setSeenByUser<
-        TVersion extends string = keyof typeof ApiVersion,
-        TResult = PatchNotificationResult<TVersion>,
-    >(
-        version: TVersion,
-        ...args: Parameters<PatchNotificationFn<TVersion, TMethod, TClient, TResult>>
-    ): PatchNotificationResult<TVersion, TMethod, TResult> {
-        const fn = updateSeenByUser<TVersion, TMethod, TClient>(
-            this._client,
-            version,
-            this._method,
-        );
-        return fn<TResult>(...args);
-    }
+  /**
+   * Set notification seen by user
+   * @see {@link setSeenByUser/client}
+   */
+  public setSeenByUser<
+    TVersion extends string = keyof typeof ApiVersion,
+    TResult = PatchNotificationResult<TVersion>,
+  >(
+    version: TVersion,
+    ...args: Parameters<PatchNotificationFn<TVersion, TMethod, TClient, TResult>>
+  ): PatchNotificationResult<TVersion, TMethod, TResult> {
+    const fn = updateSeenByUser<TVersion, TMethod, TClient>(this._client, version, this._method);
+    return fn<TResult>(...args);
+  }
 
-    /**
-     * Create a notification
-     * @see {@link create/client}
-     */
-    public create<
-        TVersion extends string = keyof typeof ApiVersion,
-        TResult = PostNotificationResult<TVersion>,
-    >(
-        version: TVersion,
-        ...args: Parameters<PostNotificationFn<TVersion, TMethod, TClient, TResult>>
-    ): PostNotificationResult<TVersion, TMethod, TResult> {
-        const fn = createNotification<TVersion, TMethod, TClient>(
-            this._client,
-            version,
-            this._method,
-        );
-        return fn<TResult>(...args);
-    }
+  /**
+   * Create a notification
+   * @see {@link create/client}
+   */
+  public create<
+    TVersion extends string = keyof typeof ApiVersion,
+    TResult = PostNotificationResult<TVersion>,
+  >(
+    version: TVersion,
+    ...args: Parameters<PostNotificationFn<TVersion, TMethod, TClient, TResult>>
+  ): PostNotificationResult<TVersion, TMethod, TResult> {
+    const fn = createNotification<TVersion, TMethod, TClient>(this._client, version, this._method);
+    return fn<TResult>(...args);
+  }
 
-    /**
-     * Delete a notification
-     * @see {@link delete/client}
-     */
-    public delete<
-        TVersion extends string = keyof typeof ApiVersion,
-        TResult = PostNotificationResult<TVersion>,
-    >(
-        version: TVersion,
-        ...args: Parameters<DeleteNotificationFn<TVersion, TMethod, TClient, TResult>>
-    ): DeleteNotificationResult<TVersion, TMethod, TResult> {
-        const fn = deleteNotification<TVersion, TMethod, TClient>(
-            this._client,
-            version,
-            this._method,
-        );
-        return fn<TResult>(...args);
-    }
-    /**
-     * Get users notification settings
-     * @see {@link getSettings/client}
-     */
-    public getSettings<
-        TVersion extends string = keyof typeof ApiVersion,
-        TResult = PostNotificationResult<TVersion>,
-    >(
-        version: TVersion,
-        ...args: Parameters<GetUserNotificationSettingsFn<TVersion, TMethod, TClient, TResult>>
-    ): GetUserNotificationsSettingsResult<TVersion, TMethod, TResult> {
-        const fn = getUserNotificationSettings<TVersion, TMethod, TClient>(
-            this._client,
-            version,
-            this._method,
-        );
-        return fn<TResult>(...args);
-    }
-    /**
-     * Update user notification settings
-     * @see {@link updateSettings/client}
-     */
-    public updateSettings<
-        TVersion extends string = keyof typeof ApiVersion,
-        TResult = PostNotificationResult<TVersion>,
-    >(
-        version: TVersion,
-        ...args: Parameters<PutUserNotificationSettingsFn<TVersion, TMethod, TClient, TResult>>
-    ): PutUserNotificationSettingsResult<TVersion, TMethod, TResult> {
-        const fn = updateUserNotificationSettings<TVersion, TMethod, TClient>(
-            this._client,
-            version,
-            this._method,
-        );
-        return fn<TResult>(...args);
-    }
+  /**
+   * Delete a notification
+   * @see {@link delete/client}
+   */
+  public delete<
+    TVersion extends string = keyof typeof ApiVersion,
+    TResult = PostNotificationResult<TVersion>,
+  >(
+    version: TVersion,
+    ...args: Parameters<DeleteNotificationFn<TVersion, TMethod, TClient, TResult>>
+  ): DeleteNotificationResult<TVersion, TMethod, TResult> {
+    const fn = deleteNotification<TVersion, TMethod, TClient>(this._client, version, this._method);
+    return fn<TResult>(...args);
+  }
+  /**
+   * Get users notification settings
+   * @see {@link getSettings/client}
+   */
+  public getSettings<
+    TVersion extends string = keyof typeof ApiVersion,
+    TResult = PostNotificationResult<TVersion>,
+  >(
+    version: TVersion,
+    ...args: Parameters<GetUserNotificationSettingsFn<TVersion, TMethod, TClient, TResult>>
+  ): GetUserNotificationsSettingsResult<TVersion, TMethod, TResult> {
+    const fn = getUserNotificationSettings<TVersion, TMethod, TClient>(
+      this._client,
+      version,
+      this._method,
+    );
+    return fn<TResult>(...args);
+  }
+  /**
+   * Update user notification settings
+   * @see {@link updateSettings/client}
+   */
+  public updateSettings<
+    TVersion extends string = keyof typeof ApiVersion,
+    TResult = PostNotificationResult<TVersion>,
+  >(
+    version: TVersion,
+    ...args: Parameters<PutUserNotificationSettingsFn<TVersion, TMethod, TClient, TResult>>
+  ): PutUserNotificationSettingsResult<TVersion, TMethod, TResult> {
+    const fn = updateUserNotificationSettings<TVersion, TMethod, TClient>(
+      this._client,
+      version,
+      this._method,
+    );
+    return fn<TResult>(...args);
+  }
 }
 
 export default NotificationApiClient;

package/src/notification/notification/delete/client.ts

@@ -1,13 +1,13 @@
-import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
-import { ClientMethod } from '../../../types';
-import { ApiVersion } from '../../static';
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ClientMethod } from '../../../types';
+import type { ApiVersion } from '../../static';
 
 import { generateParameters } from './generate-parameters';
 
 import type {
-    DeleteNotificationArgs,
-    DeleteNotificationResponse,
-    DeleteNotificationResult,
+  DeleteNotificationArgs,
+  DeleteNotificationResponse,
+  DeleteNotificationResult,
 } from './types';
 
 /**
@@ -17,21 +17,21 @@ import type {
  * @param method - client method to call
  */
 export const deleteNotification =
-    <
-        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 = DeleteNotificationResponse<TVersion>>(
-        args: DeleteNotificationArgs<TVersion>,
-        init?: ClientRequestInit<TClient, T>,
-    ): DeleteNotificationResult<TVersion, TMethod, T> =>
-        client[method](
-            ...generateParameters<T, TVersion, TClient>(version, args, init),
-        ) as DeleteNotificationResult<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 = DeleteNotificationResponse<TVersion>>(
+    args: DeleteNotificationArgs<TVersion>,
+    init?: ClientRequestInit<TClient, T>,
+  ): DeleteNotificationResult<TVersion, TMethod, T> =>
+    client[method](
+      ...generateParameters<T, TVersion, TClient>(version, args, init),
+    ) as DeleteNotificationResult<TVersion, TMethod, T>;
 
 export default deleteNotification;

package/src/notification/notification/delete/generate-endpoint.ts

@@ -6,19 +6,18 @@ import type { DeleteNotificationArgs } from './types';
  * Method for generating endpoint for getting notification by id
  */
 export const generateEndpoint = <TVersion extends string = keyof typeof ApiVersion>(
-    version: TVersion,
-    args: DeleteNotificationArgs<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 `/notification/${id}/?${String(params)}`;
-        }
+  version: TVersion,
+  args: DeleteNotificationArgs<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 `/notification/${id}/?${String(params)}`;
     }
+  }
 };