@equinor/fusion-framework-module-services 2.1.0 → 2.2.0

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

@@ -0,0 +1,24 @@
+import { UnsupportedApiVersion } from '@equinor/fusion-framework-module-services/errors';
+import { ApiVersion } from '@equinor/fusion-framework-module-services/notification';
+import type { PatchNotificationArgs } from './types';
+
+/**
+ * Method for generating endpoint for getting notification by id
+ */
+export const generateEndpoint = <TVersion extends string = keyof typeof ApiVersion>(
+    version: TVersion,
+    args: PatchNotificationArgs<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/patch/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 { PatchNotificationArgs } 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: PatchNotificationArgs<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: 'patch', body: JSON.stringify(args), headers: headers },
+        init
+    );
+
+    return [path, requestParams];
+};
+
+export default generateParameters;

package/src/notification/notification/patch/index.ts

@@ -0,0 +1,8 @@
+export { ApiVersion } from '@equinor/fusion-framework-module-services/notification';
+
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';
+
+export * from './types';
+
+export { updateSeenByUser as getNotificationById, default } from './client';

package/src/notification/notification/patch/types.ts

@@ -0,0 +1,45 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../../../types';
+import { ApiNotificationEntity } from '../../api-models';
+import { ApiVersion } from '../../static';
+
+type PatchNotificationArgs_v1 = {
+    id: string;
+    seenByUser: boolean;
+};
+
+type PatchNotificationArgs_v2 = PatchNotificationArgs_v1;
+
+type PatchNotificationArgsTypes = {
+    [ApiVersion.v1]: PatchNotificationArgs_v1;
+    [ApiVersion.v2]: PatchNotificationArgs_v2;
+};
+
+export type PatchNotificationArgs<T extends string> = T extends keyof typeof ApiVersion
+    ? PatchNotificationArgsTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+type PatchNotificationResponseTypes = {
+    [ApiVersion.v1]: ApiNotificationEntity<ApiVersion.v1>;
+    [ApiVersion.v2]: ApiNotificationEntity<ApiVersion.v2>;
+};
+
+export type PatchNotificationResponse<T> = T extends keyof typeof ApiVersion
+    ? PatchNotificationResponseTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+export type PatchNotificationFn<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+    TResult = PatchNotificationResponse<TVersion>
+> = (
+    args: PatchNotificationArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>
+) => PatchNotificationResult<TVersion, TMethod, TResult>;
+
+export type PatchNotificationResult<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = PatchNotificationResponse<TVersion>
+> = ClientMethod<TResult>[TMethod];

package/src/notification/notification/post/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 {
+    PostNotificationArgs,
+    PostNotificationResult,
+    PostNotificationResponse,
+} from './types';
+
+/**
+ * Method for creating a notification item
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export const createNotification =
+    <
+        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 = PostNotificationResponse<TVersion>>(
+        args: PostNotificationArgs<TVersion>,
+        init?: ClientRequestInit<TClient, T>
+    ): PostNotificationResult<TVersion, TMethod, T> =>
+        client[method](
+            ...generateParameters<T, TVersion, TClient>(version, args, init)
+        ) as PostNotificationResult<TVersion, TMethod, T>;
+
+export default createNotification;

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

@@ -0,0 +1,25 @@
+import { UnsupportedApiVersion } from '@equinor/fusion-framework-module-services/errors';
+import { ApiVersion } from '@equinor/fusion-framework-module-services/notification';
+
+import type { PostNotificationArgs } from './types';
+
+/**
+ * Method for generating endpoint for getting all notifications
+ */
+export const generateEndpoint = <TVersion extends string = keyof typeof ApiVersion>(
+    version: TVersion,
+    args: PostNotificationArgs<TVersion>
+) => {
+    const apiVersion = ApiVersion[version as keyof typeof ApiVersion] ?? version;
+    switch (apiVersion) {
+        case ApiVersion.v2:
+            throw new UnsupportedApiVersion(version);
+        case ApiVersion.v1:
+        default: {
+            const { userId } = args as { userId: string };
+            const params = new URLSearchParams();
+            params.append('api-version', apiVersion);
+            return `/person/${userId}/notifications/?${String(params)}`;
+        }
+    }
+};

package/src/notification/notification/post/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 { PostNotificationArgs } 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: PostNotificationArgs<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: 'post', body: JSON.stringify(args), headers: headers },
+        init
+    );
+
+    return [path, requestParams];
+};
+
+export default generateParameters;

package/src/notification/notification/post/index.ts

@@ -0,0 +1,8 @@
+export { ApiVersion } from '@equinor/fusion-framework-module-services/notification';
+
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';
+
+export * from './types';
+
+export { createNotification as getNotificationById, default } from './client';

package/src/notification/notification/post/types.ts

@@ -0,0 +1,57 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../../../types';
+import { ApiNotificationEntity } from '../../api-models';
+import { ApiVersion } from '../../static';
+
+type SourceSystem_v1 = {
+    name: string;
+    subSystem: string;
+    identifier: string;
+};
+
+type PostNotificationArgs_v1 = {
+    appKey: string;
+    emailPriority: number;
+    fallbackHtml: string;
+    title: string;
+    description: string;
+    card: string;
+    sourceSystem: SourceSystem_v1;
+    originalCreatorUniqueId: string;
+};
+
+type PostNotificationArgs_v2 = PostNotificationArgs_v1;
+
+type PostNotificationArgsTypes = {
+    [ApiVersion.v1]: PostNotificationArgs_v1;
+    [ApiVersion.v2]: PostNotificationArgs_v2;
+};
+
+export type PostNotificationArgs<T extends string> = T extends keyof typeof ApiVersion
+    ? PostNotificationArgsTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+type PostNotificationResponseTypes = {
+    [ApiVersion.v1]: Array<ApiNotificationEntity<ApiVersion.v1>>;
+    [ApiVersion.v2]: Array<ApiNotificationEntity<ApiVersion.v2>>;
+};
+
+export type PostNotificationResponse<T> = T extends keyof typeof ApiVersion
+    ? PostNotificationResponseTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+export type PostNotificationFn<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+    TResult = PostNotificationResponse<TVersion>
+> = (
+    args: PostNotificationArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>
+) => PostNotificationResult<TVersion, TMethod, TResult>;
+
+export type PostNotificationResult<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = PostNotificationResponse<TVersion>
+> = ClientMethod<TResult>[TMethod];

package/src/notification/settings/get/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 {
+    GetUserNotificationSettingsArgs,
+    GetUserNotificationsSettingsResult,
+    GetUserNotificationSettingsResponse,
+} from './types';
+
+/**
+ * Method for fetching user notification settings from the notifications service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export const getUserNotificationSettings =
+    <
+        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 = GetUserNotificationSettingsResponse<TVersion>>(
+        args: GetUserNotificationSettingsArgs<TVersion>,
+        init?: ClientRequestInit<TClient, T>
+    ): GetUserNotificationsSettingsResult<TVersion, TMethod, T> =>
+        client[method](
+            ...generateParameters<T, TVersion, TClient>(version, args, init)
+        ) as GetUserNotificationsSettingsResult<TVersion, TMethod, T>;
+
+export default getUserNotificationSettings;

package/src/notification/settings/get/generate-endpoint.ts

@@ -0,0 +1,25 @@
+import { UnsupportedApiVersion } from '@equinor/fusion-framework-module-services/errors';
+import { ApiVersion } from '@equinor/fusion-framework-module-services/notification';
+
+import type { GetUserNotificationSettingsArgs } from './types';
+
+/**
+ * Method for generating endpoint for getting all notifications
+ */
+export const generateEndpoint = <TVersion extends string = keyof typeof ApiVersion>(
+    version: TVersion,
+    args: GetUserNotificationSettingsArgs<TVersion>
+) => {
+    const apiVersion = ApiVersion[version as keyof typeof ApiVersion] ?? version;
+    switch (apiVersion) {
+        case ApiVersion.v2:
+            throw new UnsupportedApiVersion(version);
+        case ApiVersion.v1:
+        default: {
+            const { userId } = args as { userId: string };
+            const params = new URLSearchParams();
+            params.append('api-version', apiVersion);
+            return `/person/${userId}/notifications/settings/?${String(params)}`;
+        }
+    }
+};

package/src/notification/settings/get/generate-parameters.ts

@@ -0,0 +1,22 @@
+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 { GetUserNotificationSettingsArgs } 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: GetUserNotificationSettingsArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>
+): ApiClientArguments<TClient, TResult> => {
+    const path = generateEndpoint(version, args);
+    return [path, init];
+};
+
+export default generateParameters;

package/src/notification/settings/get/index.ts

@@ -0,0 +1,8 @@
+export { ApiVersion } from '@equinor/fusion-framework-module-services/notification';
+
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';
+
+export * from './types';
+
+export { getUserNotificationSettings, default } from './client';

package/src/notification/settings/get/types.ts

@@ -0,0 +1,44 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../../../types';
+import { ApiNotificationSettingsEntity } from '../../api-models';
+import { ApiVersion } from '../../static';
+
+type GetUserNotificationSettingsArgs_v1 = {
+    userId: string;
+};
+
+type GetUserNotificationSettingsArgs_v2 = GetUserNotificationSettingsArgs_v1;
+
+type GetUserNotificationSettingsArgsTypes = {
+    [ApiVersion.v1]: GetUserNotificationSettingsArgs_v1;
+    [ApiVersion.v2]: GetUserNotificationSettingsArgs_v2;
+};
+
+export type GetUserNotificationSettingsArgs<T extends string> = T extends keyof typeof ApiVersion
+    ? GetUserNotificationSettingsArgsTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+type GetUserNotificationSettingsResponseTypes = {
+    [ApiVersion.v1]: ApiNotificationSettingsEntity<ApiVersion.v1>;
+    [ApiVersion.v2]: ApiNotificationSettingsEntity<ApiVersion.v2>;
+};
+
+export type GetUserNotificationSettingsResponse<T> = T extends keyof typeof ApiVersion
+    ? GetUserNotificationSettingsResponseTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+export type GetUserNotificationSettingsFn<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+    TResult = GetUserNotificationSettingsResponse<TVersion>
+> = (
+    args: GetUserNotificationSettingsArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>
+) => GetUserNotificationsSettingsResult<TVersion, TMethod, TResult>;
+
+export type GetUserNotificationsSettingsResult<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = GetUserNotificationSettingsResponse<TVersion>
+> = ClientMethod<TResult>[TMethod];

package/src/notification/settings/put/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 {
+    PutUserNotificationSettingsArgs,
+    PutUserNotificationSettingsResult,
+    PutUserNotificationSettingsResponse,
+} from './types';
+
+/**
+ * Method for fetching user notification settings from the notifications service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export const updateUserNotificationSettings =
+    <
+        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 = PutUserNotificationSettingsResponse<TVersion>>(
+        args: PutUserNotificationSettingsArgs<TVersion>,
+        init?: ClientRequestInit<TClient, T>
+    ): PutUserNotificationSettingsResult<TVersion, TMethod, T> =>
+        client[method](
+            ...generateParameters<T, TVersion, TClient>(version, args, init)
+        ) as PutUserNotificationSettingsResult<TVersion, TMethod, T>;
+
+export default updateUserNotificationSettings;

package/src/notification/settings/put/generate-endpoint.ts

@@ -0,0 +1,25 @@
+import { UnsupportedApiVersion } from '@equinor/fusion-framework-module-services/errors';
+import { ApiVersion } from '@equinor/fusion-framework-module-services/notification';
+
+import type { PutUserNotificationSettingsArgs } from './types';
+
+/**
+ * Method for generating endpoint for getting all notifications
+ */
+export const generateEndpoint = <TVersion extends string = keyof typeof ApiVersion>(
+    version: TVersion,
+    args: PutUserNotificationSettingsArgs<TVersion>
+) => {
+    const apiVersion = ApiVersion[version as keyof typeof ApiVersion] ?? version;
+    switch (apiVersion) {
+        case ApiVersion.v2:
+            throw new UnsupportedApiVersion(version);
+        case ApiVersion.v1:
+        default: {
+            const { userId } = args as { userId: string };
+            const params = new URLSearchParams();
+            params.append('api-version', apiVersion);
+            return `/person/${userId}/notifications/settings/?${String(params)}`;
+        }
+    }
+};

package/src/notification/settings/put/generate-parameters.ts

@@ -0,0 +1,34 @@
+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 { PutUserNotificationSettingsArgs } 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: PutUserNotificationSettingsArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>
+): ApiClientArguments<TClient, TResult> => {
+    const path = generateEndpoint(version, args);
+    //add versions switch case later
+
+    //Not sure why this is needed, defaults to application/problem+json failing the request
+    const headers = new Headers();
+    headers.append('content-type', 'application/json');
+
+    const requestParams: ClientRequestInit<TClient, TResult> = Object.assign(
+        {},
+        { method: 'put', body: JSON.stringify(args), headers: headers },
+        init
+    );
+
+    return [path, requestParams];
+};
+
+export default generateParameters;

package/src/notification/settings/put/index.ts

@@ -0,0 +1,8 @@
+export { ApiVersion } from '@equinor/fusion-framework-module-services/notification';
+
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';
+
+export * from './types';
+
+export { updateUserNotificationSettings, default } from './client';

package/src/notification/settings/put/types.ts

@@ -0,0 +1,38 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../../../types';
+import { ApiNotificationSettingsEntity } from '../../api-models';
+import { ApiVersion } from '../../static';
+
+type PutUserNotificationSettingsArgsTypes = {
+    [ApiVersion.v1]: ApiNotificationSettingsEntity<ApiVersion.v1>;
+    [ApiVersion.v2]: ApiNotificationSettingsEntity<ApiVersion.v2>;
+};
+
+export type PutUserNotificationSettingsArgs<T extends string> = T extends keyof typeof ApiVersion
+    ? PutUserNotificationSettingsArgsTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+type GetUserNotificationSettingsResponseTypes = {
+    [ApiVersion.v2]: ApiNotificationSettingsEntity<ApiVersion.v2>;
+    [ApiVersion.v1]: ApiNotificationSettingsEntity<ApiVersion.v1>;
+};
+
+export type PutUserNotificationSettingsResponse<T> = T extends keyof typeof ApiVersion
+    ? GetUserNotificationSettingsResponseTypes[(typeof ApiVersion)[T]]
+    : unknown;
+
+export type PutUserNotificationSettingsFn<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+    TResult = PutUserNotificationSettingsResponse<TVersion>
+> = (
+    args: PutUserNotificationSettingsArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>
+) => PutUserNotificationSettingsResult<TVersion, TMethod, TResult>;
+
+export type PutUserNotificationSettingsResult<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = PutUserNotificationSettingsResponse<TVersion>
+> = ClientMethod<TResult>[TMethod];

package/src/notification/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/notification/types.ts

@@ -0,0 +1,5 @@
+export {
+    ClientMethodType,
+    ClientMethod,
+    ApiClientArguments,
+} from '@equinor/fusion-framework-module-services';

package/src/provider.ts

@@ -4,6 +4,7 @@ import { ClientMethod } from './types';
 import { ApiClientFactory } from './types';
 import { ContextApiClient } from './context';
 import BookmarksApiClient from './bookmarks/client';
+import { NotificationApiClient } from './notification';
 
 export interface IApiProvider<TClient extends IHttpClient = IHttpClient> {
     /**
@@ -34,6 +35,13 @@ export class ApiProvider<TClient extends IHttpClient = IHttpClient>
         this._createClientFn = createClient;
     }
 
+    public async createNotificationClient<TMethod extends keyof ClientMethod>(
+        method: TMethod
+    ): Promise<NotificationApiClient<TMethod, TClient>> {
+        const httpClient = await this._createClientFn('notification');
+        return new NotificationApiClient(httpClient, method);
+    }
+
     public async createBookmarksClient<TMethod extends keyof ClientMethod, TPayload = unknown>(
         method: TMethod
     ): Promise<BookmarksApiClient<TMethod, TClient, TPayload>> {