@equinor/fusion-framework-module-services 3.1.5 → 3.2.1

package/src/people/client.ts

@@ -0,0 +1,109 @@
+import { IHttpClient, ClientRequestInit } from '@equinor/fusion-framework-module-http/client';
+
+import type { ClientDataMethod, ClientMethod } from '../types';
+import { ApiVersion } from './static';
+
+import {
+    client as personDetailClient,
+    ApiResponse as PersonDetailApiResponse,
+    ApiResult as PersonDetailResult,
+    SupportedApiVersion as PersonDetailSupportedApiVersion,
+    ApiRequestArgs as PersonDetailApiRequestArgs,
+} from './person-details';
+
+import {
+    client as personQueryClient,
+    ApiResponse as PersonQueryApiResponse,
+    ApiResult as PersonQueryResult,
+    SupportedApiVersion as PersonQuerySupportedApiVersion,
+    ApiRequestArgs as PersonQueryApiRequestArgs,
+} from './query';
+
+import {
+    client as personPhotoClient,
+    ApiResponse as PersonPhotoApiResponse,
+    ApiResult as PersonPhotoResult,
+    SupportedApiVersion as PersonPhotoSupportedApiVersion,
+    ApiRequestArgs as PersonPhotoApiRequestArgs,
+} from './person-photo';
+
+export class PeopleApiClient<
+    // TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+    TClient extends IHttpClient = IHttpClient,
+> {
+    get Version(): typeof ApiVersion {
+        return ApiVersion;
+    }
+
+    constructor(protected _client: TClient) {}
+
+    /**
+     * Fetch person by id
+     */
+    public get<
+        TVersion extends PersonDetailSupportedApiVersion,
+        TArgs extends PersonDetailApiRequestArgs<TVersion>,
+        TResult extends PersonDetailApiResponse<TVersion, TArgs>,
+        TMethod extends keyof ClientMethod<TResult>,
+    >(
+        version: TVersion,
+        method: TMethod,
+        args: TArgs,
+        init?: ClientRequestInit<TClient, TResult>,
+    ): PersonDetailResult<TVersion, TArgs, TMethod, TResult> {
+        const fn = personDetailClient<TVersion, TMethod, TClient, TArgs>(
+            this._client,
+            version,
+            method,
+        );
+        return fn(args, init);
+    }
+
+    /**
+     * Query person service
+     */
+    public query<
+        TVersion extends PersonQuerySupportedApiVersion,
+        TArgs extends PersonQueryApiRequestArgs<TVersion>,
+        TResult = PersonQueryApiResponse<TVersion>,
+        TMethod extends keyof ClientMethod<TResult> = keyof ClientMethod<TResult>,
+    >(
+        version: TVersion,
+        method: TMethod,
+        args: TArgs,
+        init?: ClientRequestInit<TClient, TResult>,
+    ): PersonQueryResult<TVersion, TMethod, TResult> {
+        const fn = personQueryClient<TVersion, TMethod, TClient>(this._client, version, method);
+        return fn<TResult>(args, init);
+    }
+
+    /**
+     * Photo person service
+     */
+    public photo<
+        TVersion extends PersonPhotoSupportedApiVersion,
+        TArgs extends PersonPhotoApiRequestArgs<TVersion>,
+        TResult extends Blob = PersonPhotoApiResponse<TVersion>,
+        TMethod extends keyof ClientDataMethod = keyof ClientDataMethod,
+    >(
+        version: TVersion,
+        method: TMethod,
+        args: TArgs,
+        init?: ClientRequestInit<TClient, TResult>,
+    ): PersonPhotoResult<TMethod> {
+        const fn = personPhotoClient<TVersion, TMethod, TClient>(this._client, version, method);
+        return fn<TResult>(args, init);
+    }
+}
+
+// const oo = new PeopleApiClient(null).get('v4', 'fetch', { azureId: '123' });
+// const o2 = await new PeopleApiClient(null).get('v4', 'fetch', {
+//     azureId: '123',
+//     expand: ['roles'],
+// });
+// const o3 = await new PeopleApiClient(null).get('v4', 'fetch', {
+//     azureId: '123',
+//     expand: ['companies', 'roles'],
+// });
+
+export default PeopleApiClient;

package/src/people/index.ts

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

package/src/people/person-details/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, TArgs>>(
+        args: TArgs,
+        init?: ClientRequestInit<TClient, T>,
+    ): ApiResult<TVersion, TArgs, TMethod, T> =>
+        client[method](
+            ...generateParameters<T, TVersion, TClient>(version, args, init),
+        ) as ApiResult<TVersion, TArgs, TMethod, T>;
+
+export default client;

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

@@ -0,0 +1,28 @@
+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.v4: {
+            const { azureId, expand } = args;
+            const params = new URLSearchParams();
+            params.append('api-version', apiVersion);
+            if (expand) {
+                params.append('$expand', expand.join(','));
+            }
+            return `/persons/${azureId}?${String(params)}`;
+        }
+        default: {
+            throw new UnsupportedApiVersion(version);
+        }
+    }
+};

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

@@ -5,6 +5,7 @@ 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> {
     /**
@@ -26,6 +27,10 @@ export interface IApiProvider<TClient extends IHttpClient = IHttpClient> {
     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> = {
@@ -102,4 +107,9 @@ export class ApiProvider<TClient extends IHttpClient = IHttpClient>
         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

@@ -38,4 +38,9 @@ export type ClientMethod<T = unknown> = {
     json$: StreamResponse<T>;
 };
 
+export type ClientDataMethod = {
+    blob: Blob;
+    blob$: StreamResponse<Blob>;
+};
+
 export type ClientMethodType = keyof ClientMethod;

package/src/version.ts

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