@equinor/fusion-framework-module-services 0.1.0

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

@@ -0,0 +1,65 @@
+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 {
+    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.keys(parameters).reduce((acc, key) => {
+        switch (key) {
+            case 'filter':
+                return {
+                    ...acc,
+                    [key]: buildOdataFilter(parameters['filter'] 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 '@equinor/fusion-framework-module-services/context';
+
+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 '@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/src/context/query/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 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];

package/src/context/static.ts

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

package/src/context/types.ts

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

package/src/errors.ts

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

package/src/index.ts

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

package/src/module.ts

@@ -0,0 +1,101 @@
+import type {
+    IModuleConfigurator,
+    IModulesConfigurator,
+    Module,
+} from '@equinor/fusion-framework-module';
+import type { HttpModule, IHttpClientProvider } from '@equinor/fusion-framework-module-http';
+import type {
+    ServiceDiscoveryModule,
+    ServiceDiscoveryProvider,
+} from '@equinor/fusion-framework-module-service-discovery';
+
+import { IApiConfigurator, ApiConfigurator } from './configurator';
+import { IApiProvider, ApiProvider } from './provider';
+
+import type { ApiClientFactory } from './types';
+
+export type ServicesModuleKey = 'services';
+
+export const moduleKey: ServicesModuleKey = 'services';
+
+export type ServicesModule = Module<
+    ServicesModuleKey,
+    IApiProvider,
+    IApiConfigurator,
+    [HttpModule, ServiceDiscoveryModule]
+>;
+
+/**
+ * Method to trying to resolve method for creating an IHttpClient
+ */
+const createDefaultClient =
+    (http: IHttpClientProvider, serviceDiscovery?: ServiceDiscoveryProvider): ApiClientFactory =>
+    async (name: string) => {
+        if (http.hasClient(name)) {
+            return http.createClient(name);
+        }
+        if (serviceDiscovery) {
+            return serviceDiscovery.createClient(name);
+        }
+        throw Error(`failed to create http client for service ${name}`);
+    };
+
+/**
+ *  Configure http-client
+ */
+export const module: ServicesModule = {
+    name: moduleKey,
+    configure: () => new ApiConfigurator(),
+    initialize: async ({ ref, config, requireInstance, hasModule }) => {
+        /** we can not create this callback within the configuration, since it might require other modules. */
+        if (!config.createClient) {
+            const http = await requireInstance('http');
+            const serviceDiscovery: ServiceDiscoveryProvider | undefined = hasModule(
+                'serviceDiscovery'
+            )
+                ? /** if the module is within module, await creation */
+                  await requireInstance('serviceDiscovery')
+                : /** try to load parent service discovery provider */
+                  ref?.serviceDiscovery;
+
+            config.createClient = createDefaultClient(http, serviceDiscovery);
+        }
+        if (!config.createClient) {
+            throw Error('missing configuration for creating API client');
+        }
+        return new ApiProvider(config as Required<IApiConfigurator>);
+    },
+};
+
+/**
+ * Method for enabling the Service module
+ * @param config - configuration object
+ */
+export const enableServices = (config: IModulesConfigurator): void => {
+    config.addConfig({ module });
+};
+
+/**
+ * @example
+ * ```ts
+ * config.addConfig(x => x.createClient(...));
+ * ```
+ * @param configure - Callback for configuring the module
+ * @returns Configuration object
+ */
+export const configureServices = (
+    configure: (configurator: IApiConfigurator) => void
+): IModuleConfigurator<ServicesModule> => {
+    return {
+        module,
+        configure,
+    };
+};
+
+declare module '@equinor/fusion-framework-module' {
+    interface Modules {
+        services: ServicesModule;
+    }
+}
+
+export default module;

package/src/provider.ts

@@ -0,0 +1,51 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ClientMethod } from './types';
+
+import { ApiClientFactory } from './types';
+import { ContextApiClient } from './context';
+
+export enum Service {
+    Context = 'context',
+}
+
+type ApiServices<TMethod extends keyof ClientMethod, TClient extends IHttpClient> = {
+    [Service.Context]: ContextApiClient<TMethod, TClient>;
+};
+
+export interface IApiProvider<TClient extends IHttpClient = IHttpClient> {
+    /**
+     * @param name - Name of the service to use
+     * @param version - Version of the service to use
+     */
+    createApiClient<TService extends Service, TMethod extends keyof ClientMethod>(
+        name: TService,
+        version: TMethod
+    ): Promise<ApiServices<TMethod, TClient>[TService]>;
+}
+
+
+type ApiProviderCtorArgs<TClient extends IHttpClient = IHttpClient> = {
+    /** method for creating IHttpClients for api clients */
+    createClient: ApiClientFactory<TClient>;
+};
+
+export class ApiProvider<TClient extends IHttpClient = IHttpClient>
+    implements IApiProvider<TClient>
+{
+    protected _createClientFn: ApiClientFactory<TClient>;
+    constructor({ createClient }: ApiProviderCtorArgs<TClient>) {
+        this._createClientFn = createClient;
+    }
+
+    public async createApiClient<TService extends Service, TMethod extends keyof ClientMethod>(
+        name: TService,
+        method: TMethod
+    ): Promise<ApiServices<TMethod, TClient>[TService]> {
+        const httpClient = await this._createClientFn(name);
+        switch (name) {
+            case Service.Context:
+                return new ContextApiClient(httpClient, method);
+        }
+        throw Error(`could not create api client for [${name}]`);
+    }
+}

package/src/types.ts

@@ -0,0 +1,41 @@
+import {
+    ClientRequestInit,
+    IHttpClient,
+    FetchResponse,
+    StreamResponse,
+} from '@equinor/fusion-framework-module-http/client';
+
+export type ApiClientFactory<TClient extends IHttpClient = IHttpClient> = (
+    name: string
+) => Promise<TClient>;
+
+export type ApiClientArguments<TClient extends IHttpClient, TResult = unknown> = [
+    path: string,
+    init?: ClientRequestInit<TClient, TResult>
+];
+
+/**
+ * Execute methods on the IHttpClient
+ */
+export type ClientMethod<T = unknown> = {
+    /**
+     * Fetch data async
+     * NOTE: data needs to be extracted from the response
+     */
+    fetch: Promise<FetchResponse<T>>;
+    /**
+     * Fetch JSON data from a service
+     */
+    json: Promise<T>;
+    /**
+     * Fetch data as an observable
+     * NOTE: data needs to be extracted from the response
+     */
+    fetch$: StreamResponse<FetchResponse<T>>;
+    /**
+     * Fetch JSON data from a service as observable
+     */
+    json$: StreamResponse<T>;
+};
+
+export type ClientMethodType = keyof ClientMethod;

package/tsconfig.json

@@ -0,0 +1,38 @@
+{
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "outDir": "dist/esm",
+    "rootDir": "src",
+    "declarationDir": "./dist/types",
+    "baseUrl": "src",
+    "paths": {
+      "@equinor/fusion-framework-module-services": [
+        "."
+      ],
+      "@equinor/fusion-framework-module-services/*": [
+        "./*"
+      ]
+    }
+  },
+  "references": [
+    {
+      "path": "../observable"
+    },
+    {
+      "path": "../module"
+    },
+    {
+      "path": "../module-http"
+    },
+    {
+      "path": "../module-service-discovery"
+    }
+  ],
+  "include": [
+    "src/**/*",
+  ],
+  "exclude": [
+    "node_modules",
+    "lib"
+  ]
+}