@equinor/fusion-framework-module-services 0.0.0-next-20230915111233

package/src/context/related/client.ts

@@ -0,0 +1,35 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+
+import { ApiVersion } from '..';
+
+import { generateParameters } from './generate-parameters';
+
+import type {
+    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>;
+
+export default relatedContexts;

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

@@ -0,0 +1,63 @@
+import buildOdataQuery from 'odata-query';
+
+import { UnsupportedApiVersion } from '../../errors';
+
+import { ApiVersion } from '..';
+
+import type {
+    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);
+};
+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);
+};
+
+const createSearchParameters = (args: string | RelatedContextOdataParameters) => {
+    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)}`;
+        }
+    }
+};
+
+export default generateEndpoint;

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

@@ -0,0 +1,23 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+
+import { ApiVersion } from '..';
+
+import { generateEndpoint } from './generate-endpoint';
+
+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,
+>(
+    version: TVersion,
+    args: RelatedContextArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>,
+): ApiClientArguments<TClient, TResult> => {
+    const path = generateEndpoint(version, args);
+    return [path, init];
+};
+
+export default generateParameters;

package/src/context/related/index.ts

@@ -0,0 +1,8 @@
+export { ApiVersion, ApiContextEntity } from '..';
+
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';
+
+export * from './types';
+
+export { relatedContexts, default } from './client';

package/src/context/related/types.ts

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

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

package/src/context/types.ts

@@ -0,0 +1 @@
+export { ClientMethodType, ClientMethod, ApiClientArguments } from '..';

package/src/errors.ts

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

package/src/index.ts

@@ -0,0 +1,6 @@
+export * from './types';
+export type { ServicesModule, ServicesModuleKey } from './module';
+
+export { ApiConfigurator, IApiConfigurator } from './configurator';
+export { ApiProvider, IApiProvider } from './provider';
+export { default, module, enableServices, configureServices } from './module';

package/src/module.ts

@@ -0,0 +1,104 @@
+import type {
+    IModuleConfigurator,
+    IModulesConfigurator,
+    Module,
+} from '@equinor/fusion-framework-module';
+import type { HttpModule, IHttpClientProvider } from '@equinor/fusion-framework-module-http';
+import type {
+    ServiceDiscoveryModule,
+    ServiceDiscoveryProvider,
+} from '@equinor/fusion-framework-module-service-discovery';
+
+import { IApiConfigurator, ApiConfigurator } from './configurator';
+import { IApiProvider, ApiProvider } from './provider';
+
+import type { ApiClientFactory } from './types';
+
+export type ServicesModuleKey = 'services';
+
+export const moduleKey: ServicesModuleKey = 'services';
+
+export type ServicesModule = Module<
+    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}`);
+    };
+
+/**
+ *  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;
+
+            config.createClient = createDefaultClient(http, serviceDiscovery);
+        }
+        if (!config.createClient) {
+            throw Error('missing configuration for creating API client');
+        }
+        return new ApiProvider(config as Required<IApiConfigurator>);
+    },
+};
+
+/**
+ * Method for enabling the Service module
+ * @param config - configuration object
+ */
+export const enableServices = (
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    config: IModulesConfigurator<any, any>,
+): void => {
+    config.addConfig({ module });
+};
+
+/**
+ * @example
+ * ```ts
+ * config.addConfig(x => x.createClient(...));
+ * ```
+ * @param configure - Callback for configuring the module
+ * @returns Configuration object
+ */
+export const configureServices = (
+    configure: (configurator: IApiConfigurator) => void,
+): IModuleConfigurator<ServicesModule> => {
+    return {
+        module,
+        configure,
+    };
+};
+
+declare module '@equinor/fusion-framework-module' {
+    interface Modules {
+        services: ServicesModule;
+    }
+}
+
+export default module;

package/src/notification/api-models.ts

@@ -0,0 +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;
+};
+
+type SourceSystem_v1 = {
+    name: string;
+    subSystem: string;
+    identifier: string;
+};
+
+type CreatedByApplication_v1 = {
+    id: string;
+    title: string;
+};
+
+type CreatedBy_v1 = {
+    id: string;
+    name: string;
+    jobTitle: string;
+    mail: string;
+    accountType: string;
+};
+
+type ApiNotificationEntity_v2 = unknown;
+
+type ApiNotificationEntityTypes = {
+    [ApiVersion.v1]: ApiNotificationEntity_v1;
+    [ApiVersion.v2]: ApiNotificationEntity_v2;
+};
+
+export type ApiNotificationEntity<T extends string = ApiVersion> = T extends ApiVersion
+    ? ApiNotificationEntityTypes[T]
+    : unknown;
+
+/**User notification Settings */
+type ApiNotificationSettingsEntity_v1 = {
+    email: boolean;
+    delayInMinutes: number;
+    appConfig: AppConfig_v1[];
+};
+
+type AppConfig_v1 = {
+    appKey: string;
+    enabled: boolean;
+};
+
+type ApiNotificationSettingsEntity_v2 = unknown;
+
+type ApiNotificationSettingEntityTypes = {
+    [ApiVersion.v1]: ApiNotificationSettingsEntity_v1;
+    [ApiVersion.v2]: ApiNotificationSettingsEntity_v2;
+};
+
+export type ApiNotificationSettingsEntity<T extends string = ApiVersion> = T extends ApiVersion
+    ? ApiNotificationSettingEntityTypes[T]
+    : unknown;

package/src/notification/client.ts

@@ -0,0 +1,170 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ClientMethod } from '../types';
+import { GetNotificationFn, GetNotificationResult } from './notification/get';
+import {
+    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 updateUserNotificationSettings, {
+    PutUserNotificationSettingsFn,
+    PutUserNotificationSettingsResult,
+} from './settings/put';
+import getUserNotificationSettings, {
+    GetUserNotificationSettingsFn,
+    GetUserNotificationsSettingsResult,
+} from './settings/get';
+
+export class NotificationApiClient<
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+> {
+    get Version(): typeof ApiVersion {
+        return ApiVersion;
+    }
+
+    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 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);
+    }
+
+    /**
+     * 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);
+    }
+}
+
+export default NotificationApiClient;

package/src/notification/index.ts

@@ -0,0 +1,6 @@
+export { NotificationApiClient, default } from './client';
+
+export { ApiVersion } from './static';
+
+export * from './api-models';
+export * from './types';

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

@@ -0,0 +1,37 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../../../types';
+import { ApiVersion } from '../../static';
+
+import { generateParameters } from './generate-parameters';
+
+import type {
+    DeleteNotificationArgs,
+    DeleteNotificationResponse,
+    DeleteNotificationResult,
+} from './types';
+
+/**
+ * Method for deleting notification item from notifications service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @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>;
+
+export default deleteNotification;

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

@@ -0,0 +1,24 @@
+import { UnsupportedApiVersion } from '../../../errors';
+import { ApiVersion } from '../..';
+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)}`;
+        }
+    }
+};

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

@@ -0,0 +1,32 @@
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ApiVersion } from '../../static';
+import { ApiClientArguments } from '../../types';
+
+import { generateEndpoint } from './generate-endpoint';
+import { DeleteNotificationArgs } from './types';
+
+/** function for creating http client arguments  */
+export const generateParameters = <
+    TResult,
+    TVersion extends string = keyof typeof ApiVersion,
+    TClient extends IHttpClient = IHttpClient,
+>(
+    version: TVersion,
+    args: DeleteNotificationArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>,
+): ApiClientArguments<TClient, TResult> => {
+    const path = generateEndpoint(version, args);
+
+    const headers = new Headers();
+    headers.append('content-type', 'application/json');
+
+    const requestParams: ClientRequestInit<TClient, TResult> = Object.assign(
+        {},
+        { method: 'delete', headers: headers },
+        init,
+    );
+
+    return [path, requestParams];
+};
+
+export default generateParameters;

package/src/notification/notification/delete/index.ts

@@ -0,0 +1,8 @@
+export { ApiVersion } from '../..';
+
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';
+
+export * from './types';
+
+export { deleteNotification as getNotificationById, default } from './client';