@equinor/fusion-framework-module-services 2.3.0 → 2.5.0

package/dist/types/bookmarks/client.d.ts

@@ -3,7 +3,7 @@ import { ClientMethod } from '@equinor/fusion-framework-module-services/context'
 import { DeleteBookmarkResult, DeleteBookmarksFn, DeleteBookmarksResult } from './delete/types';
 import { ApiVersions, GetBookmarkResult, GetBookmarksFn, GetBookmarksResult } from './get/types';
 import { PostBookmarkResult, PostBookmarkFn, PostBookmarksResult } from './post/types';
-import { PutBookmarkFn as PatchBookmarkFn, PutBookmarkResult as PatchBookmarkResult, PutBookmarksResult as PatchBookmarksResult } from './patch';
+import { PatchBookmarkFn, PatchBookmarkResult, PatchBookmarksResult } from './patch';
 import { GetAllBookmarkResult, GetAllBookmarksResult } from './getAll';
 import { PostBookmarkFavoriteFn, PostBookmarksFavoriteResult } from './favorites/post';
 import { DeleteBookmarksFavoriteFn, DeleteBookmarksFavoriteResult } from './favorites/delete';

package/dist/types/bookmarks/patch/client.d.ts

@@ -1,5 +1,5 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ClientMethod } from '../..';
-import { PutBookmarkArgs, PutBookmarkResult, PutBookmarksResult } from './types';
-export declare const putBookmark: <TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>, TVersion extends "v1" = "v1", TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>>(client: TClient, version: TVersion, method?: TMethod) => <TResult = PutBookmarkResult<TVersion, unknown>>(args: PutBookmarkArgs<TVersion, unknown>, init?: ClientRequestInit<TClient, TResult> | undefined) => PutBookmarksResult<TVersion, TMethod, unknown, TResult>;
-export default putBookmark;
+import { PatchBookmarkArgs, PatchBookmarkResult, PatchBookmarksResult } from './types';
+export declare const patchBookmark: <TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>, TVersion extends "v1" = "v1", TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>>(client: TClient, version: TVersion, method?: TMethod) => <TResult = PatchBookmarkResult<TVersion, unknown>>(args: PatchBookmarkArgs<TVersion, unknown>, init?: ClientRequestInit<TClient, TResult> | undefined) => PatchBookmarksResult<TVersion, TMethod, unknown, TResult>;
+export default patchBookmark;

package/dist/types/bookmarks/patch/generate-endpoint.d.ts

@@ -1,2 +1,2 @@
-import { PutBookmarkArgs } from './types';
-export declare const generateEndpoint: <TVersion extends "v1">(version: TVersion, _args: PutBookmarkArgs<TVersion, unknown>) => string;
+import { PatchBookmarkArgs } from './types';
+export declare const generateEndpoint: <TVersion extends "v1">(version: TVersion, _args: PatchBookmarkArgs<TVersion, unknown>) => string;

package/dist/types/bookmarks/patch/generate-parameters.d.ts

@@ -1,4 +1,4 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ApiClientArguments } from '../..';
-import { PutBookmarkArgs } from './types';
-export declare const generateParameters: <TResult, TVersion extends "v1", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: PutBookmarkArgs<TVersion, unknown>, init?: ClientRequestInit<TClient, TResult> | undefined) => ApiClientArguments<TClient, TResult>;
+import { PatchBookmarkArgs } from './types';
+export declare const generateParameters: <TResult, TVersion extends "v1", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: PatchBookmarkArgs<TVersion, unknown>, init?: ClientRequestInit<TClient, TResult> | undefined) => ApiClientArguments<TClient, TResult>;

package/dist/types/bookmarks/patch/index.d.ts

@@ -1,4 +1,4 @@
 export * from './types';
-export { putBookmark, default } from './client';
-export { generateEndpoint as generatePutEndpoint } from './generate-endpoint';
-export { generateParameters as generatePutParameters } from './generate-parameters';
+export { patchBookmark, default } from './client';
+export { generateEndpoint as generatePatchEndpoint } from './generate-endpoint';
+export { generateParameters as generatePatchParameters } from './generate-parameters';

package/dist/types/bookmarks/patch/types.d.ts

@@ -3,17 +3,17 @@ import { ClientRequestInit } from '@equinor/fusion-framework-module-http/client'
 import { ClientMethod } from '../..';
 import { ApiBookmarkEntityV1 } from '../api-models';
 import { PostBookmarksArgsV1 } from '../post';
-export type PutBookmarkResult<TVersion extends ApiVersions, TPayload> = PutBookmarksVersions<TPayload>[TVersion]['result'];
-export type PutBookmarkArgs<TVersion extends ApiVersions, TPayload = unknown> = PutBookmarksVersions<TPayload>[TVersion]['args'];
-export type PutBookmarksResult<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TPayload = unknown, TResult = PutBookmarkResult<TVersion, TPayload>> = ClientMethod<TResult>[TMethod];
-export type PutBookmarkFn<TVersion extends ApiVersions, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient, TPayload = unknown, TResult = PutBookmarkResult<TVersion, TPayload>> = (args: PutBookmarkArgs<TVersion>, init?: ClientRequestInit<TClient, TResult>) => PutBookmarksResult<TVersion, TMethod, TPayload, TResult>;
-export interface PutBookmarksArgsV1<T = unknown> extends PostBookmarksArgsV1<T> {
+export type PatchBookmarkResult<TVersion extends ApiVersions, TPayload> = PatchBookmarksVersions<TPayload>[TVersion]['result'];
+export type PatchBookmarkArgs<TVersion extends ApiVersions, TPayload = unknown> = PatchBookmarksVersions<TPayload>[TVersion]['args'];
+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 PutBookmarksVersions<TPayload = unknown> = {
+export type PatchBookmarksVersions<TPayload = unknown> = {
     ['v1']: {
-        args: PutBookmarksArgsV1<TPayload>;
+        args: PatchBookmarksArgsV1<TPayload>;
         result: ApiBookmarkEntityV1<TPayload>;
     };
 };
-export type ApiVersions = keyof PutBookmarksVersions<unknown>;
+export type ApiVersions = keyof PatchBookmarksVersions<unknown>;

package/dist/types/context/client.d.ts

@@ -2,6 +2,7 @@ import { IHttpClient } from '@equinor/fusion-framework-module-http';
 import { ClientMethod, ApiVersion } from '@equinor/fusion-framework-module-services/context';
 import { GetContextFn, GetContextResponse, GetContextResult } from './get';
 import { QueryContextFn, QueryContextResponse, QueryContextResult } from './query';
+import { RelatedContextFn, RelatedContextResponse, RelatedContextResult } from './related';
 export declare class ContextApiClient<TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient> {
     protected _client: TClient;
     protected _method: TMethod;
@@ -9,5 +10,6 @@ export declare class ContextApiClient<TMethod extends keyof ClientMethod<unknown
     constructor(_client: TClient, _method: TMethod);
     get<TVersion extends string = keyof typeof ApiVersion, TResult = GetContextResponse<TVersion>>(version: TVersion, ...args: Parameters<GetContextFn<TVersion, TMethod, TClient, TResult>>): GetContextResult<TVersion, TMethod, TResult>;
     query<TVersion extends string = keyof typeof ApiVersion, TResult = QueryContextResponse<TVersion>>(version: TVersion, ...args: Parameters<QueryContextFn<TVersion, TMethod, TClient, TResult>>): QueryContextResult<TVersion, TMethod, TResult>;
+    related<TVersion extends string = keyof typeof ApiVersion, TResult = RelatedContextResponse<TVersion>>(version: TVersion, ...args: Parameters<RelatedContextFn<TVersion, TMethod, TClient, TResult>>): RelatedContextResult<TVersion, TMethod, TResult>;
 }
 export default ContextApiClient;

package/dist/types/context/related/client.d.ts

@@ -0,0 +1,4 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { RelatedContextArgs, RelatedContextResponse, RelatedContextResult, ClientMethod } from './types';
+export declare const relatedContexts: <TVersion extends string = "v1" | "v2", TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(client: TClient, version: TVersion, method?: TMethod) => <T = RelatedContextResponse<TVersion>>(args: RelatedContextArgs<TVersion>, init?: ClientRequestInit<TClient, T> | undefined) => RelatedContextResult<TVersion, TMethod, T>;
+export default relatedContexts;

package/dist/types/context/related/generate-endpoint.d.ts

@@ -0,0 +1,3 @@
+import type { RelatedContextArgs } from './types';
+export declare const generateEndpoint: <TVersion extends string = "v1" | "v2">(version: TVersion, args: RelatedContextArgs<TVersion>) => string;
+export default generateEndpoint;

package/dist/types/context/related/generate-parameters.d.ts

@@ -0,0 +1,4 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { RelatedContextArgs, ApiClientArguments } from './types';
+export declare const generateParameters: <TResult, TVersion extends string = "v1" | "v2", TClient extends IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response> = IHttpClient<import("@equinor/fusion-framework-module-http/client").FetchRequest, Response>>(version: TVersion, args: RelatedContextArgs<TVersion>, init?: ClientRequestInit<TClient, TResult> | undefined) => ApiClientArguments<TClient, TResult>;
+export default generateParameters;

package/dist/types/context/related/index.d.ts

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

package/dist/types/context/related/types.d.ts

@@ -0,0 +1,29 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+import { ApiVersion, ApiContextEntity, ClientMethod } from '@equinor/fusion-framework-module-services/context';
+export { ApiClientArguments, ClientMethod, } from '@equinor/fusion-framework-module-services/context';
+export type RelatedContextOdataFilter = {
+    type?: string[];
+};
+export type RelatedContextOdataParameters = {
+    search?: string;
+    filter?: RelatedContextOdataFilter;
+};
+type RelatedContextArgs_v1 = {
+    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<ApiContextEntity<ApiVersion.v1>>;
+    [ApiVersion.v2]: Array<ApiContextEntity<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/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@equinor/fusion-framework-module-services",
-    "version": "2.3.0",
+    "version": "2.5.0",
     "description": "",
     "sideEffects": false,
     "main": "dist/esm/index.js",
@@ -22,6 +22,9 @@
             "context/query": [
                 "dist/types/context/query/index"
             ],
+            "context/related": [
+                "dist/types/context/related/index"
+            ],
             "bookmarks": [
                 "dist/types/bookmarks/index"
             ]
@@ -63,5 +66,5 @@
         "@equinor/fusion-framework-module": ">=1.2.2",
         "odata-query": "^7.0.3"
     },
-    "gitHead": "2cec998dee5e0781c2cc2b327e2e119d12cd0046"
+    "gitHead": "dd4ed92c8f1d020f3b537172b4fe7788aeae99e7"
 }

package/src/bookmarks/client.ts

@@ -7,11 +7,7 @@ import getBookmark from './get/client';
 import { ApiVersions, GetBookmarkResult, GetBookmarksFn, GetBookmarksResult } from './get/types';
 import { PostBookmarkResult, PostBookmarkFn, PostBookmarksResult } from './post/types';
 import postBookmark from './post/client';
-import patchBookmark, {
-    PutBookmarkFn as PatchBookmarkFn,
-    PutBookmarkResult as PatchBookmarkResult,
-    PutBookmarksResult as PatchBookmarksResult,
-} from './patch';
+import patchBookmark, { PatchBookmarkFn, PatchBookmarkResult, PatchBookmarksResult } from './patch';
 import getAllBookmarks, { GetAllBookmarkResult, GetAllBookmarksResult } from './getAll';
 import addBookmarkFavorite, {
     PostBookmarkFavoriteFn,

package/src/bookmarks/patch/client.ts

@@ -1,7 +1,7 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ClientMethod } from '../..';
 import { generateParameters } from './generate-parameters';
-import { ApiVersions, PutBookmarkArgs, PutBookmarkResult, PutBookmarksResult } from './types';
+import { ApiVersions, PatchBookmarkArgs, PatchBookmarkResult, PatchBookmarksResult } from './types';
 
 /**
  * Method for updating bookmark
@@ -9,7 +9,7 @@ import { ApiVersions, PutBookmarkArgs, PutBookmarkResult, PutBookmarksResult } f
  * @param version - version of API to call
  * @param method - client method to call
  */
-export const putBookmark =
+export const patchBookmark =
     <
         TClient extends IHttpClient = IHttpClient,
         TVersion extends ApiVersions = ApiVersions,
@@ -19,12 +19,12 @@ export const putBookmark =
         version: TVersion,
         method: TMethod = 'json' as TMethod
     ) =>
-    <TResult = PutBookmarkResult<TVersion, unknown>>(
-        args: PutBookmarkArgs<TVersion>,
+    <TResult = PatchBookmarkResult<TVersion, unknown>>(
+        args: PatchBookmarkArgs<TVersion>,
         init?: ClientRequestInit<TClient, TResult>
-    ): PutBookmarksResult<TVersion, TMethod, unknown, TResult> =>
+    ): PatchBookmarksResult<TVersion, TMethod, unknown, TResult> =>
         client[method](
             ...generateParameters<TResult, TVersion, TClient>(version, args, init)
-        ) as PutBookmarksResult<TVersion, TMethod, unknown, TResult>;
+        ) as PatchBookmarksResult<TVersion, TMethod, unknown, TResult>;
 
-export default putBookmark;
+export default patchBookmark;

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

@@ -1,11 +1,11 @@
-import { ApiVersions, PutBookmarkArgs } from './types';
+import { ApiVersions, PatchBookmarkArgs } from './types';
 
 /**
  * Method for generating endpoint for getting bookmark by id
  */
 export const generateEndpoint = <TVersion extends ApiVersions>(
     version: TVersion,
-    _args: PutBookmarkArgs<TVersion>
+    _args: PatchBookmarkArgs<TVersion>
 ) => {
     switch (version) {
         case 'v1':

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

@@ -1,7 +1,7 @@
 import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
 import { ApiClientArguments } from '../..';
 import { generateEndpoint } from './generate-endpoint';
-import { ApiVersions, PutBookmarkArgs } from './types';
+import { ApiVersions, PatchBookmarkArgs } from './types';
 
 /** function for creating http client arguments  */
 export const generateParameters = <
@@ -10,7 +10,7 @@ export const generateParameters = <
     TClient extends IHttpClient = IHttpClient
 >(
     version: TVersion,
-    args: PutBookmarkArgs<TVersion>,
+    args: PatchBookmarkArgs<TVersion>,
     init?: ClientRequestInit<TClient, TResult>
 ): ApiClientArguments<TClient, TResult> => {
     const path = generateEndpoint(version, args);

package/src/bookmarks/patch/index.ts

@@ -1,6 +1,6 @@
 export * from './types';
 
-export { putBookmark, default } from './client';
+export { patchBookmark, default } from './client';
 
-export { generateEndpoint as generatePutEndpoint } from './generate-endpoint';
-export { generateParameters as generatePutParameters } from './generate-parameters';
+export { generateEndpoint as generatePatchEndpoint } from './generate-endpoint';
+export { generateParameters as generatePatchParameters } from './generate-parameters';

package/src/bookmarks/patch/types.ts

@@ -4,42 +4,42 @@ import { ClientMethod } from '../..';
 import { ApiBookmarkEntityV1 } from '../api-models';
 import { PostBookmarksArgsV1 } from '../post';
 
-export type PutBookmarkResult<
+export type PatchBookmarkResult<
     TVersion extends ApiVersions,
     TPayload
-> = PutBookmarksVersions<TPayload>[TVersion]['result'];
+> = PatchBookmarksVersions<TPayload>[TVersion]['result'];
 
 /** Returns args for PutBookmark based on version*/
-export type PutBookmarkArgs<
+export type PatchBookmarkArgs<
     TVersion extends ApiVersions,
     TPayload = unknown
-> = PutBookmarksVersions<TPayload>[TVersion]['args'];
+> = PatchBookmarksVersions<TPayload>[TVersion]['args'];
 
 /**Gets result type for PutBookmark call based on version and method */
-export type PutBookmarksResult<
+export type PatchBookmarksResult<
     TVersion extends ApiVersions,
     TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
     TPayload = unknown,
-    TResult = PutBookmarkResult<TVersion, TPayload>
+    TResult = PatchBookmarkResult<TVersion, TPayload>
 > = ClientMethod<TResult>[TMethod];
 
-export type PutBookmarkFn<
+export type PatchBookmarkFn<
     TVersion extends ApiVersions,
     TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
     TClient extends IHttpClient = IHttpClient,
     TPayload = unknown,
-    TResult = PutBookmarkResult<TVersion, TPayload>
+    TResult = PatchBookmarkResult<TVersion, TPayload>
 > = (
-    args: PutBookmarkArgs<TVersion>,
+    args: PatchBookmarkArgs<TVersion>,
     init?: ClientRequestInit<TClient, TResult>
-) => PutBookmarksResult<TVersion, TMethod, TPayload, TResult>;
+) => PatchBookmarksResult<TVersion, TMethod, TPayload, TResult>;
 
-export interface PutBookmarksArgsV1<T = unknown> extends PostBookmarksArgsV1<T> {
+export interface PatchBookmarksArgsV1<T = unknown> extends Partial<PostBookmarksArgsV1<T>> {
     id: string;
 }
 
-export type PutBookmarksVersions<TPayload = unknown> = {
-    ['v1']: { args: PutBookmarksArgsV1<TPayload>; result: ApiBookmarkEntityV1<TPayload> };
+export type PatchBookmarksVersions<TPayload = unknown> = {
+    ['v1']: { args: PatchBookmarksArgsV1<TPayload>; result: ApiBookmarkEntityV1<TPayload> };
 };
 
-export type ApiVersions = keyof PutBookmarksVersions<unknown>;
+export type ApiVersions = keyof PatchBookmarksVersions<unknown>;

package/src/context/client.ts

@@ -3,8 +3,16 @@ import { IHttpClient } from '@equinor/fusion-framework-module-http';
 import { ClientMethod, ApiVersion } from '@equinor/fusion-framework-module-services/context';
 
 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
@@ -44,6 +52,21 @@ export class ContextApiClient<
         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/related/client.ts

@@ -0,0 +1,35 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+
+import { ApiVersion } from '@equinor/fusion-framework-module-services/context';
+
+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,62 @@
+import buildOdataQuery from 'odata-query';
+
+import { UnsupportedApiVersion } from '@equinor/fusion-framework-module-services/errors';
+
+import { ApiVersion } from '@equinor/fusion-framework-module-services/context';
+
+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.keys(parameters).reduce((acc, key) => {
+        switch (key) {
+            case 'filter':
+                return {
+                    ...acc,
+                    [key]: buildOdataFilter(parameters['filter'] 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 '@equinor/fusion-framework-module-services/context';
+
+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 '@equinor/fusion-framework-module-services/context';
+
+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,63 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+
+import {
+    ApiVersion,
+    ApiContextEntity,
+    ClientMethod,
+} from '@equinor/fusion-framework-module-services/context';
+
+export {
+    ApiClientArguments,
+    ClientMethod,
+} from '@equinor/fusion-framework-module-services/context';
+
+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<ApiContextEntity<ApiVersion.v1>>;
+    [ApiVersion.v2]: Array<ApiContextEntity<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];