feat(people-resolver): add person suggestion API and client integration

Author: eikeland

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

@@ -48,5 +48,41 @@ export type ApiPersonMap = {
 export type ApiPerson<T extends keyof typeof ApiVersion | ApiVersion> = T extends ApiVersion
   ? ApiPersonMap[T]
   : T extends keyof typeof ApiVersion
-    ? ApiPersonMap[(typeof ApiVersion)[T]]
-    : unknown;
+  ? ApiPersonMap[(typeof ApiVersion)[T]]
+  : unknown;
+
+
+export type ApiSuggestionPerson = {
+  accountType?: 'Employee' | 'Consultant' | 'Enterprise' | 'EnterpriseExternal' | 'External' | 'Local' | 'TemporaryEmployee' | 'Unknown';
+  jobTitle?: string;
+  department?: string;
+  fullDepartment?: string;
+  employeeNumber?: string;
+  managerAzureUniqueId?: string;
+  upn?: string;
+  mobilePhone?: string;
+}
+
+export type ApiSuggestionApplication = {
+  applicationId: string;
+  applicationName?: string;
+  servicePrincipalType: 'Application' | 'ManagedIdentity' | 'ServicePrincipal';
+};
+
+export type ApiSuggestionValue = {
+  azureUniqueId: string;
+  name?: string;
+  accountType: 'Person' | 'SystemAccount' | 'Unknown';
+  person?: ApiSuggestionPerson;
+  application?: ApiSuggestionApplication;
+  avatarColor: string;
+  avatarUrl: string;
+  isExpired: boolean;
+};
+
+export type ApiSuggestions = {
+  totalCount: number;
+  count: number;
+  '@nextPage': string | null;
+  value: Array<ApiSuggestionValue>;
+};

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

@@ -27,6 +27,12 @@ import {
   type ApiRequestArgs as PersonPhotoApiRequestArgs,
 } from './person-photo';
 
+import {
+  client as personSuggestClient,
+  type ApiResponse as PersonSuggestApiResponse,
+  type ApiResult as PersonSuggestResult,
+} from './suggest';
+
 export class PeopleApiClient<
   // TMethod extends keyof ClientMethod<unknown> = keyof ClientMethod<unknown>,
   TClient extends IHttpClient = IHttpClient,
@@ -35,7 +41,7 @@ export class PeopleApiClient<
     return ApiVersion;
   }
 
-  constructor(protected _client: TClient) {}
+  constructor(protected _client: TClient) { }
 
   /**
    * Fetch person by id
@@ -90,6 +96,20 @@ export class PeopleApiClient<
     const fn = personPhotoClient<TVersion, TMethod, TClient>(this._client, version, method);
     return fn<TResult>(args, init);
   }
+
+  /**
+  * Suggest person service
+  */
+  public suggest<
+    TResult = PersonSuggestApiResponse,
+    TMethod extends keyof ClientMethod<TResult> = keyof ClientMethod<TResult>,
+  >(
+    method: TMethod,
+    init?: ClientRequestInit<TClient, TResult>,
+  ): PersonSuggestResult<TMethod, TResult> {
+    const fn = personSuggestClient<TMethod, TClient>(this._client, method);
+    return fn<TResult>(init);
+  }
 }
 
 // const oo = new PeopleApiClient(null).get('v4', 'fetch', { azureId: '123' });

packages/modules/services/src/people/suggest/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/suggest/generate-endpoint.ts

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

packages/modules/services/src/people/suggest/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/suggest/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/suggest/types.ts

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

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

@@ -5,6 +5,7 @@ import type { ApiPerson, PeopleApiClient } from '@equinor/fusion-framework-modul
 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 { Query } from '@equinor/fusion-query';
 import { queryValue } from '@equinor/fusion-query/operators';
 
@@ -25,26 +26,27 @@ type ResolverArgs<T> = T extends object
 
 const personMatcher =
   (args: MatcherArgs) =>
-  <T extends { azureUniqueId?: string; upn?: string }>(value: T): value is T => {
-    const { azureId, upn } = args;
-    if (azureId && upn) {
-      return (
-        value.upn?.toLocaleLowerCase() === upn.toLocaleLowerCase() &&
-        value.azureUniqueId === azureId
-      );
-    } else if (azureId) {
-      return value.azureUniqueId === azureId;
-    } else if (upn) {
-      return value.upn?.toLocaleLowerCase() === upn.toLocaleLowerCase();
-    }
-    return false;
-  };
+    <T extends { azureUniqueId?: string; upn?: string }>(value: T): value is T => {
+      const { azureId, upn } = args;
+      if (azureId && upn) {
+        return (
+          value.upn?.toLocaleLowerCase() === upn.toLocaleLowerCase() &&
+          value.azureUniqueId === azureId
+        );
+      } else if (azureId) {
+        return value.azureUniqueId === azureId;
+      } else if (upn) {
+        return value.upn?.toLocaleLowerCase() === upn.toLocaleLowerCase();
+      }
+      return false;
+    };
 
 export interface IPersonController {
   getPerson(args: ResolverArgs<MatcherArgs>): Observable<GetPersonResult>;
   getPersonInfo(args: ResolverArgs<MatcherArgs>): Observable<ApiPerson<'v2'>>;
   getPhoto(args: ResolverArgs<MatcherArgs>): Observable<string>;
   search(args: ResolverArgs<{ search: string }>): Observable<PersonSearchResult>;
+  suggest(args: ResolverArgs<{ search: string }>): Observable<SuggestPersonApiResponse>;
 }
 
 export type PersonControllerOptions = {
@@ -55,6 +57,7 @@ export class PersonController implements IPersonController {
   #personQuery: Query<GetPersonResult, ResolverArgs<{ azureId: string }>>;
   #personSearchQuery: Query<PersonSearchResult, ResolverArgs<{ search: string }>>;
   #personPhotoQuery: Query<Blob, ResolverArgs<{ azureId: string }>>;
+  #personSuggestQuery: Query<SuggestPersonApiResponse, ResolverArgs<{ search: string }>>;
 
   constructor(client: PeopleApiClient, options?: PersonControllerOptions) {
     const expire = 3 * 60 * 1000;
@@ -112,9 +115,25 @@ export class PersonController implements IPersonController {
         },
       },
     });
+    this.#personSuggestQuery = new Query({
+      expire,
+      queueOperator: 'merge',
+      key: ({ search }) => search,
+      client: {
+        fn: ({ search }, signal) => {
+          return client.suggest('json$', { method: 'POST', body: JSON.stringify({ queryString: search }), 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> {
+
     const { search, signal } = args;
     return this.#personSearchQuery.query({ search }, { signal }).pipe(queryValue);
   }

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

@@ -42,6 +42,11 @@ export const createResolver = (controller: IPersonController): PersonResolver =>
       ),
     );
   },
+  suggest(args) {
+    return firstValueFrom(
+      controller.suggest(args)
+    );
+  },
 });
 
 export default createResolver;