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

package/src/people/person-details/generate-parameters.ts

@@ -0,0 +1,22 @@
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+
+import { generateEndpoint } from './generate-endpoint';
+
+import type { ApiClientArguments } from '../../types';
+import type { ApiRequestArgs, SupportedApiVersion } from './types';
+
+/** function for creating http client arguments  */
+export const generateParameters = <
+    TResult,
+    TVersion extends SupportedApiVersion,
+    TClient extends IHttpClient = IHttpClient,
+>(
+    version: TVersion,
+    args: ApiRequestArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>,
+): ApiClientArguments<TClient, TResult> => {
+    const path = generateEndpoint(version, args);
+    return [path, init];
+};
+
+export default generateParameters;

package/src/people/person-details/index.ts

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

package/src/people/person-details/types.ts

@@ -0,0 +1,54 @@
+import { ApiVersion } from '../static';
+import type { ApiManager } from '../api-models';
+import type {
+    ApiCompanyInfo_v4,
+    ApiPersonContract_v4,
+    ApiPerson_v4,
+    ApiPersonPosition_v4,
+    ApiPersonRole_v4,
+} from '../api-models.v4';
+import { ClientMethod } from '../../types';
+
+export type SupportedApiVersion = Extract<keyof typeof ApiVersion, 'v4'>;
+
+type ApiRequestArgsMap = {
+    [ApiVersion.v4]: {
+        azureId: string;
+        expand?: Array<keyof ExpandMap[ApiVersion.v4]>;
+    };
+};
+
+export type AllowedArgs = ApiRequestArgsMap[keyof ApiRequestArgsMap];
+
+type ExpandMap = {
+    [ApiVersion.v4]: {
+        roles: Array<ApiPersonRole_v4>;
+        positions: Array<ApiPersonPosition_v4>;
+        contracts: Array<ApiPersonContract_v4>;
+        manager: ApiManager;
+        companies: Array<ApiCompanyInfo_v4>;
+    };
+};
+
+export type ApiRequestArgs<T extends SupportedApiVersion> =
+    ApiRequestArgsMap[(typeof ApiVersion)[T]];
+
+type ApiResponseTypes<TArgs extends AllowedArgs> = {
+    [ApiVersion.v4]: TArgs['expand'] extends Array<keyof ExpandMap[ApiVersion.v4]>
+        ? ApiPerson_v4 & {
+              [K in TArgs['expand'][number]]: ExpandMap[ApiVersion.v4][K];
+          }
+        : ApiPerson_v4;
+};
+
+export type ApiResponse<
+    T extends SupportedApiVersion,
+    TArgs extends AllowedArgs,
+> = ApiResponseTypes<TArgs>[(typeof ApiVersion)[T]];
+
+export type ApiResult<
+    TVersion extends SupportedApiVersion,
+    TArgs extends ApiRequestArgs<TVersion>,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = ApiResponse<TVersion, TArgs>,
+> = ClientMethod<TResult>[TMethod];

package/src/people/person-photo/client.ts

@@ -0,0 +1,33 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+
+import { generateParameters } from './generate-parameters';
+
+import type { ClientDataMethod } from '../../types';
+import type { ApiResponse, ApiRequestArgs, SupportedApiVersion } 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 client =
+    <
+        TVersion extends SupportedApiVersion,
+        TMethod extends keyof ClientDataMethod = keyof ClientDataMethod,
+        TClient extends IHttpClient = IHttpClient,
+        TArgs extends ApiRequestArgs<TVersion> = ApiRequestArgs<TVersion>,
+    >(
+        client: TClient,
+        version: TVersion,
+        method: TMethod = 'blob' as TMethod,
+    ) =>
+    <T extends Blob = ApiResponse<TVersion>>(
+        args: TArgs,
+        init?: ClientRequestInit<TClient, T>,
+    ): ClientDataMethod[TMethod] =>
+        client[method](
+            ...generateParameters<T, TVersion, TClient>(version, args, init),
+        ) as ClientDataMethod[TMethod];
+
+export default client;

package/src/people/person-photo/generate-endpoint.ts

@@ -0,0 +1,25 @@
+import { UnsupportedApiVersion } from '../../errors';
+import { ApiVersion } from '../static';
+
+import type { ApiRequestArgs, SupportedApiVersion } from './types';
+
+/**
+ * Method for generating endpoint for getting context by id
+ */
+export const generateEndpoint = <TVersion extends SupportedApiVersion>(
+    version: TVersion,
+    args: ApiRequestArgs<TVersion>,
+) => {
+    const apiVersion = ApiVersion[version as keyof typeof ApiVersion] ?? version;
+    switch (apiVersion) {
+        case ApiVersion.v2: {
+            const { azureId } = args;
+            const params = new URLSearchParams();
+            params.append('api-version', apiVersion);
+            return `/persons/${azureId}/photo?${String(params)}`;
+        }
+        default: {
+            throw new UnsupportedApiVersion(version);
+        }
+    }
+};

package/src/people/person-photo/generate-parameters.ts

@@ -0,0 +1,22 @@
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+
+import { generateEndpoint } from './generate-endpoint';
+
+import type { ApiClientArguments } from '../../types';
+import type { ApiRequestArgs, SupportedApiVersion } from './types';
+
+/** function for creating http client arguments  */
+export const generateParameters = <
+    TResult,
+    TVersion extends SupportedApiVersion,
+    TClient extends IHttpClient = IHttpClient,
+>(
+    version: TVersion,
+    args: ApiRequestArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>,
+): ApiClientArguments<TClient, TResult> => {
+    const path = generateEndpoint(version, args);
+    return [path, init];
+};
+
+export default generateParameters;

package/src/people/person-photo/index.ts

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

package/src/people/person-photo/types.ts

@@ -0,0 +1,24 @@
+import { ApiVersion } from '../static';
+import { ClientDataMethod } from '../../types';
+
+export type SupportedApiVersion = Extract<keyof typeof ApiVersion, 'v2'>;
+
+type ApiRequestArgsMap = {
+    [ApiVersion.v2]: {
+        azureId: string;
+    };
+};
+
+export type AllowedArgs = ApiRequestArgsMap[keyof ApiRequestArgsMap];
+
+export type ApiRequestArgs<T extends SupportedApiVersion> =
+    ApiRequestArgsMap[(typeof ApiVersion)[T]];
+
+type ApiResponseTypes = {
+    [ApiVersion.v2]: Blob;
+};
+
+export type ApiResponse<T extends SupportedApiVersion> = ApiResponseTypes[(typeof ApiVersion)[T]];
+
+export type ApiResult<TMethod extends keyof ClientDataMethod = keyof ClientDataMethod> =
+    ClientDataMethod[TMethod];

package/src/people/query/client.ts

@@ -0,0 +1,33 @@
+import { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+
+import { generateParameters } from './generate-parameters';
+
+import type { ClientMethod } from '../../types';
+import type { ApiResponse, ApiResult, ApiRequestArgs, SupportedApiVersion } 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 client =
+    <
+        TVersion extends SupportedApiVersion,
+        TMethod extends keyof ClientMethod = keyof ClientMethod,
+        TClient extends IHttpClient = IHttpClient,
+        TArgs extends ApiRequestArgs<TVersion> = ApiRequestArgs<TVersion>,
+    >(
+        client: TClient,
+        version: TVersion,
+        method: TMethod = 'json' as TMethod,
+    ) =>
+    <T = ApiResponse<TVersion>>(
+        args: TArgs,
+        init?: ClientRequestInit<TClient, T>,
+    ): ApiResult<TVersion, TMethod, T> =>
+        client[method](
+            ...generateParameters<T, TVersion, TClient>(version, args, init),
+        ) as ApiResult<TVersion, TMethod, T>;
+
+export default client;

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

@@ -0,0 +1,26 @@
+import { UnsupportedApiVersion } from '../../errors';
+import { ApiVersion } from '../static';
+
+import type { ApiRequestArgs, SupportedApiVersion } from './types';
+
+/**
+ * Method for generating endpoint for getting context by id
+ */
+export const generateEndpoint = <TVersion extends SupportedApiVersion>(
+    version: TVersion,
+    args: ApiRequestArgs<TVersion>,
+) => {
+    const apiVersion = ApiVersion[version as keyof typeof ApiVersion] ?? version;
+    switch (apiVersion) {
+        case ApiVersion.v2: {
+            const { search } = args;
+            const params = new URLSearchParams();
+            params.append('api-version', apiVersion);
+            params.append('$search', search);
+            return `/persons?${String(params)}`;
+        }
+        default: {
+            throw new UnsupportedApiVersion(version);
+        }
+    }
+};

package/src/people/query/generate-parameters.ts

@@ -0,0 +1,22 @@
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+
+import { generateEndpoint } from './generate-endpoint';
+
+import type { ApiClientArguments } from '../../types';
+import type { ApiRequestArgs, SupportedApiVersion } from './types';
+
+/** function for creating http client arguments  */
+export const generateParameters = <
+    TResult,
+    TVersion extends SupportedApiVersion,
+    TClient extends IHttpClient = IHttpClient,
+>(
+    version: TVersion,
+    args: ApiRequestArgs<TVersion>,
+    init?: ClientRequestInit<TClient, TResult>,
+): ApiClientArguments<TClient, TResult> => {
+    const path = generateEndpoint(version, args);
+    return [path, init];
+};
+
+export default generateParameters;

package/src/people/query/index.ts

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

package/src/people/query/types.ts

@@ -0,0 +1,28 @@
+import { ApiVersion } from '../static';
+import { ApiPerson_v2 } from '../api-models.v2';
+import { ClientMethod } from '../../types';
+
+export type SupportedApiVersion = Extract<keyof typeof ApiVersion, 'v2'>;
+
+type ApiRequestArgsMap = {
+    [ApiVersion.v2]: {
+        search: string;
+    };
+};
+
+export type AllowedArgs = ApiRequestArgsMap[keyof ApiRequestArgsMap];
+
+export type ApiRequestArgs<T extends SupportedApiVersion> =
+    ApiRequestArgsMap[(typeof ApiVersion)[T]];
+
+type ApiResponseTypes = {
+    [ApiVersion.v2]: Array<ApiPerson_v2>;
+};
+
+export type ApiResponse<T extends SupportedApiVersion> = ApiResponseTypes[(typeof ApiVersion)[T]];
+
+export type ApiResult<
+    TVersion extends SupportedApiVersion,
+    TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TResult = ApiResponse<TVersion>,
+> = ClientMethod<TResult>[TMethod];

package/src/people/static.ts

@@ -0,0 +1,4 @@
+export enum ApiVersion {
+    'v2' = '2.0',
+    'v4' = '4.0',
+}

package/src/provider.ts

@@ -0,0 +1,115 @@
+import { IHttpClient } from '@equinor/fusion-framework-module-http';
+import { ClientMethod } from './types';
+
+import { ApiClientFactory } from './types';
+import { ContextApiClient } from './context';
+import BookmarksApiClient from './bookmarks/client';
+import { NotificationApiClient } from './notification';
+import { PeopleApiClient } from './people/client';
+
+export interface IApiProvider<TClient extends IHttpClient = IHttpClient> {
+    /**
+     * @param method - Version of the service to use
+     */
+    createBookmarksClient<TMethod extends keyof ClientMethod, TPayload = unknown>(
+        method: TMethod,
+    ): Promise<BookmarksApiClient<TMethod, TClient, TPayload>>;
+
+    /**
+     * @param method - Version of the service to use
+     */
+    createContextClient<TMethod extends keyof ClientMethod>(
+        method: TMethod,
+    ): Promise<ContextApiClient<TMethod, TClient>>;
+    /**
+     * @param method - Version of the service to use
+     */
+    createNotificationClient<TMethod extends keyof ClientMethod>(
+        method: TMethod,
+    ): Promise<NotificationApiClient<TMethod, TClient>>;
+    /**
+     * @param method - Version of the service to use
+     */
+    createPeopleClient(): Promise<PeopleApiClient<TClient>>;
+}
+
+type ApiProviderCtorArgs<TClient extends IHttpClient = IHttpClient> = {
+    /** method for creating IHttpClients for api clients */
+    createClient: ApiClientFactory<TClient>;
+};
+
+// TODO move to own file
+type ApiProviderErrorResponse = {
+    type: ResponseType;
+    status: number;
+    statusText: string;
+    headers: Headers;
+    url: string;
+    data: unknown;
+};
+
+// TODO move to own file
+export class ApiProviderError extends Error {
+    readonly response: ApiProviderErrorResponse;
+
+    constructor(msg: string, response: ApiProviderErrorResponse, options?: ErrorOptions) {
+        super(msg, options);
+        this.response = response;
+        this.name = 'ApiProviderError';
+    }
+}
+
+// TODO move to own file
+const validateResponse = async (response: Response) => {
+    if (!response.ok) {
+        const { headers, status, statusText, type, url, bodyUsed } = response;
+        const isJson = headers.get('content-type')?.match(/application\/(\w*)?[+]?json/);
+        const data = !bodyUsed && (await (isJson ? response.json() : response.text()));
+        throw new ApiProviderError('failed to execute request, response was not ok', {
+            headers,
+            status,
+            statusText,
+            type,
+            url,
+            data,
+        });
+    }
+};
+
+export class ApiProvider<TClient extends IHttpClient = IHttpClient>
+    implements IApiProvider<TClient>
+{
+    protected _createClientFn: ApiClientFactory<TClient>;
+    constructor({ createClient }: ApiProviderCtorArgs<TClient>) {
+        this._createClientFn = createClient;
+    }
+
+    public async createNotificationClient<TMethod extends keyof ClientMethod>(
+        method: TMethod,
+    ): Promise<NotificationApiClient<TMethod, TClient>> {
+        const httpClient = await this._createClientFn('notification');
+        httpClient.responseHandler.add('validate_api_request', validateResponse);
+        return new NotificationApiClient(httpClient, method);
+    }
+
+    public async createBookmarksClient<TMethod extends keyof ClientMethod, TPayload = unknown>(
+        method: TMethod,
+    ): Promise<BookmarksApiClient<TMethod, TClient, TPayload>> {
+        const httpClient = await this._createClientFn('bookmarks');
+        httpClient.responseHandler.add('validate_api_request', validateResponse);
+        return new BookmarksApiClient(httpClient, method);
+    }
+
+    public async createContextClient<TMethod extends keyof ClientMethod>(
+        method: TMethod,
+    ): Promise<ContextApiClient<TMethod, TClient>> {
+        const httpClient = await this._createClientFn('context');
+        httpClient.responseHandler.add('validate_api_request', validateResponse);
+        return new ContextApiClient(httpClient, method);
+    }
+    public async createPeopleClient(): Promise<PeopleApiClient<TClient>> {
+        const httpClient = await this._createClientFn('people');
+        httpClient.responseHandler.add('validate_api_request', validateResponse);
+        return new PeopleApiClient(httpClient);
+    }
+}

package/src/types.ts

@@ -0,0 +1,46 @@
+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 ClientDataMethod = {
+    blob: Blob;
+    blob$: StreamResponse<Blob>;
+};
+
+export type ClientMethodType = keyof ClientMethod;

package/src/version.ts

@@ -0,0 +1,2 @@
+// Generated by genversion.
+export const version = '3.1.5';

package/tsconfig.json

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