@equinor/fusion-framework-module-services 0.1.0

package/dist/types/context/api-models.d.ts

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

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

@@ -0,0 +1,13 @@
+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';
+export declare class ContextApiClient<TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TClient extends IHttpClient = IHttpClient> {
+    protected _client: TClient;
+    protected _method: TMethod;
+    get Version(): typeof ApiVersion;
+    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>;
+}
+export default ContextApiClient;

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

@@ -0,0 +1,4 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ClientMethod, GetContextArgs, GetContextResponse, GetContextResult } from './types';
+export declare const getContext: <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 = GetContextResponse<TVersion>>(args: GetContextArgs<TVersion>, init?: ClientRequestInit<TClient, T> | undefined) => GetContextResult<TVersion, TMethod, T>;
+export default getContext;

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

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

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

@@ -0,0 +1,4 @@
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { ApiClientArguments, GetContextArgs } 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: GetContextArgs<TVersion>, init?: ClientRequestInit<TClient, TResult> | undefined) => ApiClientArguments<TClient, TResult>;
+export default generateParameters;

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

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

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

@@ -0,0 +1,19 @@
+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';
+declare type GetContextArgs_v1 = {
+    id: string;
+};
+declare type GetContextArgs_v2 = GetContextArgs_v1;
+declare type GetContextArgsTypes = {
+    [ApiVersion.v1]: GetContextArgs_v1;
+    [ApiVersion.v2]: GetContextArgs_v2;
+};
+export declare type GetContextArgs<T extends string> = T extends keyof typeof ApiVersion ? GetContextArgsTypes[typeof ApiVersion[T]] : unknown;
+declare type GetContextResponseTypes = {
+    [ApiVersion.v1]: ApiContextEntity<ApiVersion.v1>;
+    [ApiVersion.v2]: ApiContextEntity<ApiVersion.v2>;
+};
+export declare type GetContextResponse<T> = T extends keyof typeof ApiVersion ? GetContextResponseTypes[typeof ApiVersion[T]] : unknown;
+export declare 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 declare type GetContextResult<TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = GetContextResponse<TVersion>> = ClientMethod<TResult>[TMethod];

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

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

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

@@ -0,0 +1,4 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { QueryContextArgs, QueryContextResponse, QueryContextResult, ClientMethod } from './types';
+export declare const queryContext: <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 = QueryContextResponse<TVersion>>(args: QueryContextArgs<TVersion>, init?: ClientRequestInit<TClient, T> | undefined) => QueryContextResult<TVersion, TMethod, T>;
+export default queryContext;

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

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

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

@@ -0,0 +1,4 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+import type { QueryContextArgs, 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: QueryContextArgs<TVersion>, init?: ClientRequestInit<TClient, TResult> | undefined) => ApiClientArguments<TClient, TResult>;
+export default generateParameters;

package/dist/types/context/query/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 { queryContext, default } from './client';

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

@@ -0,0 +1,32 @@
+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 declare type QueryContextOdataFilter = {
+    type?: string[];
+    externalId?: string;
+};
+export declare type QueryContextOdataParameters = {
+    search?: string;
+    filter?: QueryContextOdataFilter;
+};
+declare type QueryContextArgs_v1 = {
+    query: string | QueryContextOdataParameters;
+    includeDeleted?: boolean;
+};
+declare type QueryContextArgs_v2 = QueryContextArgs_v1;
+declare type SearchContextArgTypes = {
+    [ApiVersion.v1]: QueryContextArgs_v1;
+    [ApiVersion.v2]: QueryContextArgs_v2;
+};
+export declare type QueryContextArgs<T> = T extends keyof typeof ApiVersion ? SearchContextArgTypes[typeof ApiVersion[T]] : {
+    query: {
+        search: string;
+    };
+};
+declare type QueryContextResponseTypes = {
+    [ApiVersion.v1]: Array<ApiContextEntity<ApiVersion.v1>>;
+    [ApiVersion.v2]: Array<ApiContextEntity<ApiVersion.v2>>;
+};
+export declare type QueryContextResponse<T> = T extends keyof typeof ApiVersion ? QueryContextResponseTypes[typeof ApiVersion[T]] : unknown;
+export declare 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 declare type QueryContextResult<TVersion extends string = keyof typeof ApiVersion, TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>, TResult = QueryContextResponse<TVersion>> = ClientMethod<TResult>[TMethod];

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

@@ -0,0 +1,4 @@
+export declare enum ApiVersion {
+    'v1' = "1.0",
+    'v2' = "2.0"
+}

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

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

package/dist/types/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class UnsupportedApiVersion extends Error {
+    readonly version: string | number;
+    constructor(version: string | number, cause?: unknown);
+}

package/dist/types/index.d.ts

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

package/dist/types/module.d.ts

@@ -0,0 +1,20 @@
+import type { IModuleConfigurator, IModulesConfigurator, Module } from '@equinor/fusion-framework-module';
+import type { HttpModule } from '@equinor/fusion-framework-module-http';
+import type { ServiceDiscoveryModule } from '@equinor/fusion-framework-module-service-discovery';
+import { IApiConfigurator } from './configurator';
+import { IApiProvider } from './provider';
+export declare type ServicesModuleKey = 'services';
+export declare const moduleKey: ServicesModuleKey;
+export declare type ServicesModule = Module<ServicesModuleKey, IApiProvider, IApiConfigurator, [
+    HttpModule,
+    ServiceDiscoveryModule
+]>;
+export declare const module: ServicesModule;
+export declare const enableServices: (config: IModulesConfigurator) => void;
+export declare const configureServices: (configure: (configurator: IApiConfigurator) => void) => IModuleConfigurator<ServicesModule>;
+declare module '@equinor/fusion-framework-module' {
+    interface Modules {
+        services: ServicesModule;
+    }
+}
+export default module;

package/dist/types/provider.d.ts

@@ -0,0 +1,22 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ClientMethod } from './types';
+import { ApiClientFactory } from './types';
+import { ContextApiClient } from './context';
+export declare enum Service {
+    Context = "context"
+}
+declare type ApiServices<TMethod extends keyof ClientMethod, TClient extends IHttpClient> = {
+    [Service.Context]: ContextApiClient<TMethod, TClient>;
+};
+export interface IApiProvider<TClient extends IHttpClient = IHttpClient> {
+    createApiClient<TService extends Service, TMethod extends keyof ClientMethod>(name: TService, version: TMethod): Promise<ApiServices<TMethod, TClient>[TService]>;
+}
+declare type ApiProviderCtorArgs<TClient extends IHttpClient = IHttpClient> = {
+    createClient: ApiClientFactory<TClient>;
+};
+export declare class ApiProvider<TClient extends IHttpClient = IHttpClient> implements IApiProvider<TClient> {
+    protected _createClientFn: ApiClientFactory<TClient>;
+    constructor({ createClient }: ApiProviderCtorArgs<TClient>);
+    createApiClient<TService extends Service, TMethod extends keyof ClientMethod>(name: TService, method: TMethod): Promise<ApiServices<TMethod, TClient>[TService]>;
+}
+export {};

package/dist/types/types.d.ts

@@ -0,0 +1,13 @@
+import { ClientRequestInit, IHttpClient, FetchResponse, StreamResponse } from '@equinor/fusion-framework-module-http/client';
+export declare type ApiClientFactory<TClient extends IHttpClient = IHttpClient> = (name: string) => Promise<TClient>;
+export declare type ApiClientArguments<TClient extends IHttpClient, TResult = unknown> = [
+    path: string,
+    init?: ClientRequestInit<TClient, TResult>
+];
+export declare type ClientMethod<T = unknown> = {
+    fetch: Promise<FetchResponse<T>>;
+    json: Promise<T>;
+    fetch$: StreamResponse<FetchResponse<T>>;
+    json$: StreamResponse<T>;
+};
+export declare type ClientMethodType = keyof ClientMethod;

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@equinor/fusion-framework-module-services",
+  "version": "0.1.0",
+  "description": "",
+  "sideEffects": false,
+  "main": "dist/esm/index.js",
+  "types": "index.d.ts",
+  "typesVersions": {
+    ">=4.2": {
+      "*": [
+        "dist/types/*"
+      ],
+      "context": [
+        "dist/types/context/index"
+      ],
+      "context/get": [
+        "dist/types/context/get/index"
+      ],
+      "context/query": [
+        "dist/types/context/query/index"
+      ]
+    }
+  },
+  "exports": {
+    ".": "./dist/esm/index.js",
+    "./context": "./dist/esm/context/index.js",
+    "./context/get": "./dist/esm/context/get-context/index.js",
+    "./errors": "./dist/esm/errors.js",
+    "./package.json": "./package.json"
+  },
+  "scripts": {
+    "build": "npm run build:typescript",
+    "build:typescript": "tsc -b --verbose",
+    "prepack": "npm run build"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/equinor/fusion-framework.git",
+    "directory": "packages/module-services"
+  },
+  "dependencies": {
+    "odata-query": "^7.0.3"
+  },
+  "devDependencies": {
+    "@equinor/fusion-framework-module": "^1.1.3",
+    "@equinor/fusion-framework-module-http": "^2.0.10",
+    "@equinor/fusion-framework-module-service-discovery": "^1.0.7"
+  },
+  "peerDependencies": {
+    "@equinor/fusion-framework-module": "^1.1.3",
+    "odata-query": "^7.0.3"
+  },
+  "gitHead": "8b7efac3ab5b1db6531a89b884714dd90cb482e8"
+}

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,49 @@
+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';
+
+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);
+    }
+}
+
+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 '@equinor/fusion-framework-module-services/context';
+
+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 '@equinor/fusion-framework-module-services/errors';
+import { ApiVersion } from '@equinor/fusion-framework-module-services/context';
+
+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 '@equinor/fusion-framework-module-services/context';
+
+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 '@equinor/fusion-framework-module-services/context';
+
+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,52 @@
+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';
+
+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 '@equinor/fusion-framework-module-services/context';
+
+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;