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

package/src/bookmarks/patch/types.ts

@@ -0,0 +1,45 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { ApiBookmarkEntityV1 } from '../api-models';
+import { PostBookmarksArgsV1 } from '../post';
+
+export type PatchBookmarkResult<
+    TVersion extends ApiVersions,
+    TPayload,
+> = PatchBookmarksVersions<TPayload>[TVersion]['result'];
+
+/** Returns args for PutBookmark based on version*/
+export type PatchBookmarkArgs<
+    TVersion extends ApiVersions,
+    TPayload = unknown,
+> = PatchBookmarksVersions<TPayload>[TVersion]['args'];
+
+/**Gets result type for PutBookmark call based on version and method */
+export type PatchBookmarksResult<
+    TVersion extends ApiVersions,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TPayload = unknown,
+    TResult = PatchBookmarkResult<TVersion, TPayload>,
+> = ClientMethod<TResult>[TMethod];
+
+export type PatchBookmarkFn<
+    TVersion extends ApiVersions,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+    TPayload = unknown,
+    TResult = PatchBookmarkResult<TVersion, TPayload>,
+> = (
+    args: PatchBookmarkArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>,
+) => PatchBookmarksResult<TVersion, TMethod, TPayload, TResult>;
+
+export interface PatchBookmarksArgsV1<T = unknown> extends Partial<PostBookmarksArgsV1<T>> {
+    id: string;
+}
+
+export type PatchBookmarksVersions<TPayload = unknown> = {
+    ['v1']: { args: PatchBookmarksArgsV1<TPayload>; result: ApiBookmarkEntityV1<TPayload> };
+};
+
+export type ApiVersions = keyof PatchBookmarksVersions<unknown>;

package/src/bookmarks/post/client.ts

@@ -0,0 +1,30 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { generateParameters } from './generate-parameters';
+import { ApiVersions, PostBookmarkArgs, PostBookmarkResult, PostBookmarksResult } from './types';
+
+/**
+ * Method for fetching bookmark by it`s id from bookmark service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @param method - client method to call
+ */
+export const postBookmark =
+    <
+        TVersion extends ApiVersions = ApiVersions,
+        TMethod extends keyof ClientMethod = keyof ClientMethod,
+        TClient extends IHttpClient = IHttpClient,
+    >(
+        client: TClient,
+        version: TVersion,
+        method: TMethod = 'json' as TMethod,
+    ) =>
+    <TResult = PostBookmarkResult<TVersion, unknown>>(
+        args: PostBookmarkArgs<TVersion>,
+        init?: ClientRequestInit<TClient, TResult>,
+    ): PostBookmarksResult<TVersion, TMethod, unknown, TResult> =>
+        client[method](
+            ...generateParameters<TResult, TVersion, TClient>(version, args, init),
+        ) as PostBookmarksResult<TVersion, TMethod, unknown, TResult>;
+
+export default postBookmark;

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

@@ -0,0 +1,18 @@
+import { ApiVersions, PostBookmarkArgs } from './types';
+
+/**
+ * Method for generating endpoint for getting bookmark by id
+ */
+export const generateEndpoint = <TVersion extends ApiVersions>(
+    version: TVersion,
+    _args: PostBookmarkArgs<TVersion>,
+) => {
+    switch (version) {
+        case 'v1':
+        default: {
+            const params = new URLSearchParams();
+            params.append('api-version', version);
+            return `/bookmarks?${String(params)}`;
+        }
+    }
+};

package/src/bookmarks/post/generate-parameters.ts

@@ -0,0 +1,28 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import { ApiClientArguments } from '../..';
+import { generateEndpoint } from './generate-endpoint';
+import { ApiVersions, PostBookmarkArgs } from './types';
+
+/** function for creating http client arguments  */
+export const generateParameters = <
+    TResult,
+    TVersion extends ApiVersions,
+    TClient extends IHttpClient = IHttpClient,
+>(
+    version: TVersion,
+    args: PostBookmarkArgs<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];
+};

package/src/bookmarks/post/index.ts

@@ -0,0 +1,6 @@
+export * from './types';
+
+export { postBookmark, default } from './client';
+
+export { generateEndpoint } from './generate-endpoint';
+export { generateParameters } from './generate-parameters';

package/src/bookmarks/post/types.ts

@@ -0,0 +1,58 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ClientMethod } from '../..';
+import { ApiBookmarkEntityV1 } from '../api-models';
+
+export type PostBookmarkResult<
+    TVersion extends ApiVersions,
+    TPayload,
+> = PostBookmarksVersions<TPayload>[TVersion]['result'];
+
+/** Returns args for GetBookmark based on version*/
+export type PostBookmarkArgs<
+    TVersion extends ApiVersions,
+    TPayload = unknown,
+> = PostBookmarksVersions<TPayload>[TVersion]['args'];
+
+/**Gets result type for GetBookmark call based on version and method */
+export type PostBookmarksResult<
+    TVersion extends ApiVersions,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TPayload = unknown,
+    TResult = PostBookmarkResult<TVersion, TPayload>,
+> = ClientMethod<TResult>[TMethod];
+
+export type PostBookmarkFn<
+    TVersion extends ApiVersions,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+    TPayload = unknown,
+    TResult = PostBookmarkResult<TVersion, TPayload>,
+> = (
+    args: PostBookmarkArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>,
+) => PostBookmarksResult<TVersion, TMethod, TPayload, TResult>;
+
+export interface PostBookmarksArgsV1<T = unknown> {
+    /** Display name of the bookmark */
+    name: string;
+    description?: string;
+    /** Is the bookmark shared with others */
+    isShared: boolean;
+    /** Name of the app it belongs too, should correspond to a fusion appkey */
+    appKey: string;
+    contextId?: string;
+    /** Any JSON object to store as the bookmark payload */
+    payload: T;
+    sourceSystem?: {
+        identifier?: string;
+        name?: string;
+        subSystem?: string;
+    };
+}
+
+export type PostBookmarksVersions<TPayload = unknown> = {
+    ['v1']: { args: PostBookmarksArgsV1<TPayload>; result: ApiBookmarkEntityV1<TPayload> };
+};
+
+export type ApiVersions = keyof PostBookmarksVersions<unknown>;

package/src/bookmarks/types.ts

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

package/src/configurator.ts

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

package/src/context/api-models.ts

@@ -0,0 +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;
+};
+
+type ApiContextEntity_v2 = unknown;
+
+type ApiContextEntityTypes = {
+    [ApiVersion.v1]: ApiContextEntity_v1;
+    [ApiVersion.v2]: ApiContextEntity_v2;
+};
+
+export type ApiContextEntity<T extends string = ApiVersion> = T extends ApiVersion
+    ? ApiContextEntityTypes[T]
+    : unknown;
+
+/** === types === */
+
+type ApiContextType_v1 = {
+    id: string;
+    isChildType: boolean;
+    parentTypeIds: string[] | null;
+};
+
+type ApiContextType_v2 = unknown;
+
+type ApiContextTypeTypes = {
+    [ApiVersion.v1]: ApiContextType_v1;
+    [ApiVersion.v2]: ApiContextType_v2;
+};
+
+export type ApiContextType<T extends ApiVersion> = ApiContextTypeTypes[T];

package/src/context/client.ts

@@ -0,0 +1,76 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+
+import type { ClientMethod } from './types';
+import { ApiVersion } from './static';
+
+import { getContext, GetContextFn, GetContextResponse, GetContextResult } from './get';
+
+import { queryContext, QueryContextFn, QueryContextResponse, QueryContextResult } from './query';
+
+import {
+    RelatedContextFn,
+    RelatedContextResponse,
+    RelatedContextResult,
+    relatedContexts,
+} from './related';
+
+export class ContextApiClient<
+    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 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 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

@@ -0,0 +1,33 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+
+import { ApiVersion } from '..';
+
+import { generateParameters } from './generate-parameters';
+
+import type { ClientMethod, GetContextArgs, GetContextResponse, GetContextResult } from './types';
+
+/**
+ * Method for fetching context item from context service
+ * @param client - client for execution of request
+ * @param version - version of API to call
+ * @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>;
+
+export default getContext;

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

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

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

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

package/src/context/get/index.ts

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

package/src/context/get/types.ts

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

package/src/context/index.ts

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

package/src/context/query/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 {
+    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>;
+
+export default queryContext;

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

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

package/src/context/query/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 { 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,
+>(
+    version: TVersion,
+    args: QueryContextArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>,
+): ApiClientArguments<TClient, TResult> => {
+    const path = generateEndpoint(version, args);
+    return [path, init];
+};
+
+export default generateParameters;

package/src/context/query/index.ts

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

package/src/context/query/types.ts

@@ -0,0 +1,56 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+
+import { ApiVersion, ApiContextEntity, ClientMethod } from '..';
+
+export { ApiClientArguments, ClientMethod } from '..';
+
+export type QueryContextOdataFilter = {
+    type?: string[];
+    externalId?: string;
+};
+
+export type QueryContextOdataParameters = {
+    search?: string;
+    filter?: QueryContextOdataFilter;
+};
+
+type QueryContextArgs_v1 = {
+    query: string | QueryContextOdataParameters;
+    includeDeleted?: boolean;
+};
+
+type QueryContextArgs_v2 = QueryContextArgs_v1;
+
+type SearchContextArgTypes = {
+    [ApiVersion.v1]: QueryContextArgs_v1;
+    [ApiVersion.v2]: QueryContextArgs_v2;
+};
+
+export type QueryContextArgs<T> = T extends keyof typeof ApiVersion
+    ? SearchContextArgTypes[(typeof ApiVersion)[T]]
+    : { query: { search: string } };
+
+type QueryContextResponseTypes = {
+    [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;
+
+export type QueryContextFn<
+    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>,
+) => QueryContextResult<TVersion, TMethod, TResult>;
+
+export type QueryContextResult<
+    TVersion extends string = keyof typeof ApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = QueryContextResponse<TVersion>,
+> = ClientMethod<TResult>[TMethod];