feat(people-resolver): implement person resolve API and client integration

- Added new API types for resolving person data.
- Introduced client methods for resolving persons, including endpoint generation and parameter handling.
- Updated the PeopleApiClient to include resolve functionality.
- Enhanced PersonController to support resolving persons by Azure IDs.
- Integrated resolve functionality into the createResolver method.

This update expands the capabilities of the people resolver, allowing for more comprehensive person data retrieval.

Author: eikeland

packages/modules/services/package.json

@@ -54,6 +54,14 @@
       "import": "./dist/esm/people/query/index.js",
       "types": "./dist/types/people/query/index.d.ts"
     },
+    "./people/suggest": {
+      "import": "./dist/esm/people/suggest/index.js",
+      "types": "./dist/types/people/suggest/index.d.ts"
+    },
+    "./people/resolve": {
+      "import": "./dist/esm/people/resolve/index.js",
+      "types": "./dist/types/people/resolve/index.d.ts"
+    },
     "./people/photo": {
       "import": "./dist/esm/people/person-photo/index.js",
       "types": "./dist/types/people/person-photo/index.d.ts"

packages/modules/services/src/people/api-models.ts

@@ -86,3 +86,13 @@ export type ApiSuggestions = {
   '@nextPage': string | null;
   value: Array<ApiSuggestionValue>;
 };
+
+export type ApiResolveItem = {
+  success: boolean;
+  statusCode: number;
+  errorMessage: string | null;
+  indentifier: string;
+  account: ApiSuggestionValue | null;
+};
+
+export type ApiResolved = Array<ApiResolveItem>;

packages/modules/services/src/people/client.ts

@@ -33,6 +33,12 @@ import {
   type ApiResult as PersonSuggestResult,
 } from './suggest';
 
+import {
+  client as personResolveClient,
+  type ApiResponse as PersonResolveApiResponse,
+  type ApiResult as PersonResolveResult,
+} from './resolve';
+
 export class PeopleApiClient<
   // TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
   TClient extends IHttpClient = IHttpClient,
@@ -110,16 +116,20 @@ export class PeopleApiClient<
     const fn = personSuggestClient<TMethod, TClient>(this._client, method);
     return fn<TResult>(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'],
-// });
+  /**
+  * Resolve person service
+  */
+  public resolve<
+    TResult = PersonResolveApiResponse,
+    TMethod extends keyof ClientMethod<TResult> = keyof ClientMethod<TResult>,
+  >(
+    method: TMethod,
+    init?: ClientRequestInit<TClient, TResult>,
+  ): PersonResolveResult<TMethod, TResult> {
+    const fn = personResolveClient<TMethod, TClient>(this._client, method);
+    return fn<TResult>(init);
+  }
+}
 
 export default PeopleApiClient;

packages/modules/services/src/people/resolve/client.ts

@@ -0,0 +1,29 @@
+import type { ClientRequestInit, IHttpClient } from '@equinor/fusion-framework-module-http/client';
+
+import { generateParameters } from './generate-parameters';
+
+import type { ClientMethod } from '../../types';
+import type { ApiResponse, ApiResult } from './types';
+
+/**
+ * Method for fetching context item from context service
+ * @param client - client for execution of request
+ * @param method - client method to call
+ */
+export const client =
+  <
+    TMethod extends keyof ClientMethod = keyof ClientMethod,
+    TClient extends IHttpClient = IHttpClient,
+  >(
+    client: TClient,
+    method: TMethod = 'json' as TMethod,
+  ) =>
+    <T = ApiResponse>(
+      init?: ClientRequestInit<TClient, T>,
+    ): ApiResult<TMethod, T> =>
+      client[method](...generateParameters<T, TClient>(init)) as ApiResult<
+        TMethod,
+        T
+      >;
+
+export default client;

packages/modules/services/src/people/resolve/generate-endpoint.ts

@@ -0,0 +1,6 @@
+/**
+ * Method for generating endpoint for getting people suggestions
+ */
+export const generateEndpoint = () => {
+  return '/people-picker/resolve';
+};

packages/modules/services/src/people/resolve/generate-parameters.ts

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

packages/modules/services/src/people/resolve/index.ts

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

packages/modules/services/src/people/resolve/types.ts

@@ -0,0 +1,9 @@
+import type { ApiResolved } from '../api-models';
+import type { ClientMethod } from '../../types';
+
+export type ApiResponse = ApiResolved;
+
+export type ApiResult<
+  TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
+  TResult = ApiResponse,
+> = ClientMethod<TResult>[TMethod];

packages/react/components/people-resolver/src/PersonController.ts

@@ -1,11 +1,12 @@
 import { EMPTY, type Observable, concat, from, fromEvent, of } from 'rxjs';
-import { catchError, filter, find, map, switchMap, take, takeUntil } from 'rxjs/operators';
+import { catchError, filter, find, map, switchMap, take, takeUntil, tap } from 'rxjs/operators';
 
 import type { ApiPerson, PeopleApiClient } from '@equinor/fusion-framework-module-services/people';
 import { isApiPerson } from '@equinor/fusion-framework-module-services/people/utils';
 import type { ApiResponse as GetPersonApiResponse } from '@equinor/fusion-framework-module-services/people/get';
 import type { ApiResponse as QueryPersonApiResponse } from '@equinor/fusion-framework-module-services/people/query';
 import type { ApiResponse as SuggestPersonApiResponse } from '@equinor/fusion-framework-module-services/people/suggest';
+import type { ApiResponse as ResolvePersonApiResponse } from '@equinor/fusion-framework-module-services/people/resolve';
 import { Query } from '@equinor/fusion-query';
 import { queryValue } from '@equinor/fusion-query/operators';
 
@@ -47,6 +48,7 @@ export interface IPersonController {
   getPhoto(args: ResolverArgs<MatcherArgs>): Observable<string>;
   search(args: ResolverArgs<{ search: string }>): Observable<PersonSearchResult>;
   suggest(args: ResolverArgs<{ search: string }>): Observable<SuggestPersonApiResponse>;
+  resolve(args: ResolverArgs<{ azureIds: string[] }>): Observable<ResolvePersonApiResponse>;
 }
 
 export type PersonControllerOptions = {
@@ -58,6 +60,7 @@ export class PersonController implements IPersonController {
   #personSearchQuery: Query<PersonSearchResult, ResolverArgs<{ search: string }>>;
   #personPhotoQuery: Query<Blob, ResolverArgs<{ azureId: string }>>;
   #personSuggestQuery: Query<SuggestPersonApiResponse, ResolverArgs<{ search: string }>>;
+  #personResolveQuery: Query<ResolvePersonApiResponse, ResolverArgs<{ azureIds: string[] }>>;
 
   constructor(client: PeopleApiClient, options?: PersonControllerOptions) {
     const expire = 3 * 60 * 1000;
@@ -125,15 +128,29 @@ export class PersonController implements IPersonController {
         },
       },
     });
+    this.#personResolveQuery = new Query({
+      expire,
+      queueOperator: 'merge',
+      key: ({ azureIds }) => azureIds.join(),
+      client: {
+        fn: ({ azureIds }, signal) => {
+          return client.resolve('json$', { method: 'POST', body: JSON.stringify({ azureUniqueIds: azureIds }), signal });
+        },
+      },
+    });
   }
 
   public suggest(args: ResolverArgs<{ search: string }>): Observable<SuggestPersonApiResponse> {
     const { search, signal } = args;
     return this.#personSuggestQuery.query({ search }, { signal }).pipe(queryValue);
   }
 
-  public search(args: { search: string; signal?: AbortSignal }): Observable<PersonSearchResult> {
+  public resolve(args: ResolverArgs<{ azureIds: string[] }>): Observable<ResolvePersonApiResponse> {
+    const { azureIds, signal } = args;
+    return this.#personResolveQuery.query({ azureIds }, { signal }).pipe(queryValue);
+  }
 
+  public search(args: { search: string; signal?: AbortSignal }): Observable<PersonSearchResult> {
     const { search, signal } = args;
     return this.#personSearchQuery.query({ search }, { signal }).pipe(queryValue);
   }
@@ -218,25 +235,23 @@ export class PersonController implements IPersonController {
         find(isApiPerson('v2')),
       ),
     ).pipe(
-      /** */
       find(isApiPerson('v2')),
       filter(isApiPerson('v2')),
-      filter(isApiPerson('v2')),
       takeUntil(abort$),
     );
   }
 
   protected _getPersonPhotoByAzureId(azureId: string, signal?: AbortSignal): Observable<string> {
     return this.#personPhotoQuery.query({ azureId }, { signal }).pipe(
-      /** */
+      /** make subscription cold */
       take(1),
       map((result) => URL.createObjectURL(result.value)),
     );
   }
 
   protected _getPersonPhotoByUpn(upn: string, signal?: AbortSignal) {
     return this._getPersonInfoByUpn(upn, signal).pipe(
-      /** */
+      /** make subscription cold */
       take(1),
       switchMap((x) => this._getPersonPhotoByAzureId(x.azureUniqueId, signal)),
     );
@@ -272,4 +287,18 @@ export class PersonController implements IPersonController {
       filter(isApiPerson('v2')),
     );
   }
+
+  protected _resolveCache$(args: { azureIds: string[] }): Observable<ResolvePersonApiResponse> {
+    const { azureIds } = args;
+    return this.#personResolveQuery.cache.state$.pipe(
+      /** make subscription cold */
+      take(1),
+      switchMap((entry) => {
+        return from(Object.values(entry)).pipe(
+          filter(({ args }) => args.azureIds.join() === azureIds.join()),
+          map(({ value }) => value),
+        );
+      }),
+    );
+  }
 }

packages/react/components/people-resolver/src/create-resolver.ts

@@ -32,20 +32,17 @@ export const createResolver = (controller: IPersonController): PersonResolver =>
               ({
                 ...x,
                 azureId: x.azureUniqueId,
-                // TODO
-                // @asbjornhaland
-                // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-                // @ts-ignore https://github.com/equinor/fusion-web-components/issues/804
               }) as unknown as PersonInfo,
           ),
         ),
       ),
     );
   },
   suggest(args) {
-    return firstValueFrom(
-      controller.suggest(args)
-    );
+    return firstValueFrom(controller.suggest(args));
+  },
+  resolve(args) {
+    return firstValueFrom(controller.resolve(args));
   },
 });