@equinor/fusion-framework-react-components-people-provider 0.0.0-context-error-20240131144633

package/dist/types/PersonController.d.ts

@@ -0,0 +1,54 @@
+import { Observable } from 'rxjs';
+import type { ApiPerson, PeopleApiClient } from '@equinor/fusion-framework-module-services/people';
+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';
+type GetPersonResult = GetPersonApiResponse<'v4', {
+    azureId: '';
+    expand: ['positions', 'manager'];
+}>;
+type PersonSearchResult = QueryPersonApiResponse<'v2'>;
+type MatcherArgs = {
+    upn: string;
+    azureId?: string;
+} | {
+    upn?: string;
+    azureId: string;
+};
+type ResolverArgs<T> = T extends object ? {
+    [K in keyof T]: T[K];
+} & {
+    signal?: AbortSignal;
+} : {
+    signal?: AbortSignal;
+};
+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>;
+}
+export type PersonControllerOptions = {
+    fallbackImage?: Blob;
+};
+export declare class PersonController implements IPersonController {
+    #private;
+    constructor(client: PeopleApiClient, options?: PersonControllerOptions);
+    search(args: {
+        search: string;
+        signal?: AbortSignal;
+    }): Observable<PersonSearchResult>;
+    getPhoto(args: ResolverArgs<MatcherArgs>): Observable<string>;
+    getPerson(args: ResolverArgs<MatcherArgs>): Observable<GetPersonResult>;
+    getPersonInfo(args: ResolverArgs<MatcherArgs>): Observable<ApiPerson<'v2'>>;
+    protected _getPersonByUpn(upn: string, signal?: AbortSignal): Observable<GetPersonResult>;
+    _getPersonByAzureId(azureId: string, signal?: AbortSignal): Observable<GetPersonResult>;
+    protected _getPersonInfoById(azureId: string, signal?: AbortSignal): Observable<ApiPerson<'v2'>>;
+    protected _getPersonInfoByUpn(upn: string, signal?: AbortSignal): Observable<ApiPerson<'v2'>>;
+    protected _getPersonPhotoByAzureId(azureId: string, signal?: AbortSignal): Observable<string>;
+    protected _getPersonPhotoByUpn(upn: string, signal?: AbortSignal): Observable<string>;
+    protected _personCache$(args: MatcherArgs): Observable<GetPersonResult>;
+    protected _queryCache$(args: MatcherArgs): Observable<ApiPerson<'v2'>>;
+}
+export {};

package/dist/types/create-resolver.d.ts

@@ -0,0 +1,4 @@
+import { PersonResolver } from '@equinor/fusion-wc-person';
+import { IPersonController } from './PersonController';
+export declare const createResolver: (controller: IPersonController) => PersonResolver;
+export default createResolver;

package/dist/types/index.d.ts

@@ -0,0 +1 @@
+export { PeopleResolverProvider, default } from './PeopleResolverProvider';

package/dist/types/makeResolver.d.ts

@@ -0,0 +1,6 @@
+/// <reference types="react" />
+import { PersonControllerOptions } from './PersonController';
+import { IApiProvider } from '@equinor/fusion-framework-module-services';
+export declare const makeResolver: (services: IApiProvider, options?: PersonControllerOptions) => import("react").LazyExoticComponent<({ children }: {
+    readonly children?: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element>;

package/dist/types/types.d.ts

@@ -0,0 +1,5 @@
+import type { ApiResponse as PersonDetailApiResponse } from '@equinor/fusion-framework-module-services/people/get';
+export type ApiPerson = PersonDetailApiResponse<'v4', {
+    azureId: '';
+    expand: ['positions', 'manager'];
+}>;

package/dist/types/version.d.ts

@@ -0,0 +1 @@
+export declare const version = "1.1.12";

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@equinor/fusion-framework-react-components-people-provider",
+  "version": "0.0.0-context-error-20240131144633",
+  "description": "",
+  "main": "dist/esm/index.js",
+  "exports": {
+    ".": "./dist/esm/index.js"
+  },
+  "types": "./dist/types/index.d.ts",
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/equinor/fusion-framework.git",
+    "directory": "packages/react/components/people-provider"
+  },
+  "dependencies": {
+    "rxjs": "^7.8.1",
+    "@equinor/fusion-framework-module-services": "^3.2.3",
+    "@equinor/fusion-framework-react": "^0.0.0-context-error-20240131144633",
+    "@equinor/fusion-framework-react-module": "^3.0.7",
+    "@equinor/fusion-framework-react-module-bookmark": "^0.0.0-context-error-20240131144633",
+    "@equinor/fusion-query": "^4.0.5"
+  },
+  "devDependencies": {
+    "@equinor/fusion-wc-person": "^2.2.0",
+    "@types/react": "^18.2.20",
+    "react": "^18.2.0",
+    "typescript": "^5.1.3",
+    "@equinor/fusion-framework-module-app": "^5.2.12",
+    "@equinor/fusion-framework-module-bookmark": "^1.1.0",
+    "@equinor/fusion-framework-module-event": "^4.0.7"
+  },
+  "peerDependencies": {
+    "@types/react": "^17.0.0 || ^18.0.0",
+    "react": "^17.0.0 || ^18.0.0"
+  },
+  "peerDependenciesMeta": {
+    "@types/react": {
+      "optional": true
+    }
+  },
+  "scripts": {
+    "build": "tsc -b"
+  }
+}

package/src/PeopleResolver.tsx

@@ -0,0 +1,31 @@
+import { useEffect, useRef } from 'react';
+
+import {
+    PersonProviderElement,
+    PersonAvatarElement,
+    PersonCardElement,
+    PersonResolver,
+    PersonListItemElement,
+    PersonSelectElement,
+} from '@equinor/fusion-wc-person';
+
+PersonProviderElement;
+PersonAvatarElement;
+PersonCardElement;
+PersonListItemElement;
+PersonSelectElement;
+
+export { PersonResolver };
+
+export const PeopleResolverComponent = (
+    props: React.PropsWithChildren<{ resolver: PersonResolver }>,
+) => {
+    const { resolver, children } = props;
+    const ref = useRef<PersonProviderElement | null>(null);
+    useEffect(() => {
+        if (ref.current && resolver) {
+            ref.current.resolver = resolver;
+        }
+    }, [ref, resolver]);
+    return <fwc-person-provider ref={ref}>{children}</fwc-person-provider>;
+};

package/src/PeopleResolverProvider.tsx

@@ -0,0 +1,25 @@
+import { PropsWithChildren, Suspense, useMemo } from 'react';
+import { ServicesModule } from '@equinor/fusion-framework-module-services';
+import { useModule } from '@equinor/fusion-framework-react-module';
+import { makeResolver } from './makeResolver';
+import { PersonControllerOptions } from './PersonController';
+
+type PeopleResolverProviderProps = PropsWithChildren<{
+    readonly options?: PersonControllerOptions;
+}>;
+
+export const PeopleResolverProvider = (props: PeopleResolverProviderProps) => {
+    const { children, options } = props;
+    const services = useModule<ServicesModule>('services');
+    if (!services) {
+        throw Error('missing service module');
+    }
+    const Component = useMemo(() => makeResolver(services, options), [services, options]);
+    return (
+        <Suspense fallback={<span>TODO</span>}>
+            <Component>{children}</Component>
+        </Suspense>
+    );
+};
+
+export default PeopleResolverProvider;

package/src/PersonController.ts

@@ -0,0 +1,248 @@
+import { EMPTY, Observable, concat, from, fromEvent, of } from 'rxjs';
+import { catchError, filter, find, map, switchMap, take, takeUntil } 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 { Query } from '@equinor/fusion-query';
+import { queryValue } from '@equinor/fusion-query/operators';
+
+import { ApiProviderError } from '@equinor/fusion-framework-module-services/provider';
+
+type GetPersonResult = GetPersonApiResponse<
+    'v4',
+    { azureId: ''; expand: ['positions', 'manager'] }
+>;
+
+type PersonSearchResult = QueryPersonApiResponse<'v2'>;
+
+type MatcherArgs = { upn: string; azureId?: string } | { upn?: string; azureId: string };
+
+type ResolverArgs<T> = T extends object
+    ? { [K in keyof T]: T[K] } & { signal?: AbortSignal }
+    : { signal?: AbortSignal };
+
+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;
+    };
+
+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>;
+}
+
+export type PersonControllerOptions = {
+    fallbackImage?: Blob;
+};
+
+export class PersonController implements IPersonController {
+    #personQuery: Query<GetPersonResult, ResolverArgs<{ azureId: string }>>;
+    #personSearchQuery: Query<PersonSearchResult, ResolverArgs<{ search: string }>>;
+    #personPhotoQuery: Query<Blob, ResolverArgs<{ azureId: string }>>;
+
+    constructor(client: PeopleApiClient, options?: PersonControllerOptions) {
+        const expire = 3 * 60 * 1000;
+        this.#personQuery = new Query({
+            expire,
+            queueOperator: 'merge',
+            key: ({ azureId }) => azureId,
+            client: {
+                fn: ({ azureId }, signal): Observable<GetPersonResult> => {
+                    return client.get(
+                        'v4',
+                        'json$',
+                        { azureId, expand: ['manager', 'positions'] },
+                        { signal },
+                    );
+                },
+            },
+        });
+        this.#personSearchQuery = new Query({
+            expire,
+            queueOperator: 'merge',
+            key: ({ search }) => search,
+            client: {
+                fn: ({ search }, signal) => {
+                    return client.query('v2', 'json$', { search }, { signal });
+                },
+            },
+        });
+        this.#personPhotoQuery = new Query({
+            expire,
+            queueOperator: 'merge',
+            key: ({ azureId }) => azureId,
+            client: {
+                fn: ({ azureId }, signal) => {
+                    return client.photo('v2', 'blob$', { azureId }, { signal }).pipe(
+                        catchError((err) => {
+                            const apiError = err as ApiProviderError;
+                            if (apiError.response.status === 404 && options?.fallbackImage) {
+                                return of(options?.fallbackImage);
+                            }
+                            return of(err);
+                        }),
+                    );
+                },
+            },
+        });
+    }
+
+    public search(args: { search: string; signal?: AbortSignal }): Observable<PersonSearchResult> {
+        const { search, signal } = args;
+        return this.#personSearchQuery.query({ search }, { signal }).pipe(queryValue);
+    }
+
+    /** TODO why does this need to have data?!? */
+    public getPhoto(args: ResolverArgs<MatcherArgs>): Observable<string> {
+        const { azureId, upn, signal } = args;
+
+        if (azureId) {
+            return this._getPersonPhotoByAzureId(azureId, signal);
+        } else if (upn) {
+            return this._getPersonPhotoByUpn(upn, signal);
+        }
+        throw Error('invalid args provided');
+    }
+
+    public getPerson(args: ResolverArgs<MatcherArgs>): Observable<GetPersonResult> {
+        const { azureId, upn, signal } = args;
+        if (azureId) {
+            return this._getPersonByAzureId(azureId, signal);
+        } else if (upn) {
+            return this._getPersonByUpn(upn, signal);
+        }
+        throw Error('invalid args provided');
+    }
+
+    public getPersonInfo(args: ResolverArgs<MatcherArgs>): Observable<ApiPerson<'v2'>> {
+        const { azureId, upn, signal } = args;
+        if (azureId) {
+            return this._getPersonInfoById(azureId, signal);
+        } else if (upn) {
+            return this._getPersonInfoByUpn(upn, signal);
+        }
+        throw Error('invalid args provided');
+    }
+
+    protected _getPersonByUpn(upn: string, signal?: AbortSignal): Observable<GetPersonResult> {
+        const abort$ = signal ? fromEvent(signal, 'abort') : EMPTY;
+        return concat(
+            this._personCache$({ upn }),
+            this._getPersonInfoByUpn(upn, signal).pipe(
+                filter(isApiPerson('v2')),
+                switchMap(({ azureUniqueId: azureId }) => {
+                    return this._getPersonByAzureId(azureId, signal);
+                }),
+            ),
+        ).pipe(
+            /** */
+            filter(isApiPerson('v4')),
+            takeUntil(abort$),
+        );
+    }
+
+    public _getPersonByAzureId(azureId: string, signal?: AbortSignal): Observable<GetPersonResult> {
+        return this.#personQuery.query({ azureId }, { signal }).pipe(queryValue);
+    }
+
+    protected _getPersonInfoById(
+        azureId: string,
+        signal?: AbortSignal,
+    ): Observable<ApiPerson<'v2'>> {
+        const abort$ = signal ? fromEvent(signal, 'abort') : EMPTY;
+        return concat(
+            /** */
+            this._personCache$({ azureId }),
+            this._queryCache$({ azureId }),
+            this._getPersonByAzureId(azureId, signal),
+        ).pipe(
+            /** */
+            filter(isApiPerson('v2')),
+            takeUntil(abort$),
+        );
+    }
+
+    protected _getPersonInfoByUpn(upn: string, signal?: AbortSignal): Observable<ApiPerson<'v2'>> {
+        const matcher = personMatcher({ upn });
+        const abort$ = signal ? fromEvent(signal, 'abort') : EMPTY;
+        return concat(
+            this._personCache$({ upn }),
+            this._queryCache$({ upn }),
+            this.#personSearchQuery.query({ search: upn }, { signal }).pipe(
+                /** extract first match, should only be 0 or 1 */
+                map((x) => x.value.find(matcher)),
+                /** type cast and end stream */
+                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(
+            /** */
+            take(1),
+            map((result) => URL.createObjectURL(result.value)),
+        );
+    }
+
+    protected _getPersonPhotoByUpn(upn: string, signal?: AbortSignal) {
+        return this._getPersonInfoByUpn(upn, signal).pipe(
+            /** */
+            take(1),
+            switchMap((x) => this._getPersonPhotoByAzureId(x.azureUniqueId, signal)),
+        );
+    }
+
+    protected _personCache$(args: MatcherArgs): Observable<GetPersonResult> {
+        const mather = personMatcher(args);
+        return this.#personQuery.cache.state$.pipe(
+            /** make subscription cold */
+            take(1),
+            /** map out cached ApiPerson_v2 which matches upn  */
+            map((x) => Object.values(x).find((x) => mather(x.value))?.value),
+            find(isApiPerson('v4')),
+            filter(isApiPerson('v4')),
+        );
+    }
+
+    protected _queryCache$(args: MatcherArgs): Observable<ApiPerson<'v2'>> {
+        const mather = personMatcher(args);
+        return this.#personSearchQuery.cache.state$.pipe(
+            /** make subscription cold */
+            take(1),
+            switchMap((entry) => {
+                /** expand cache records */
+                return from(Object.values(entry)).pipe(
+                    /** find matching cache record item */
+                    map((x) => x.value.find((x) => mather(x))),
+                    /** type cast and end stream */
+                    find(isApiPerson('v2')),
+                );
+            }),
+            find(isApiPerson('v2')),
+            filter(isApiPerson('v2')),
+        );
+    }
+}

package/src/create-resolver.ts

@@ -0,0 +1,47 @@
+import { firstValueFrom, map } from 'rxjs';
+
+import { PersonDetails, PersonInfo, PersonResolver } from '@equinor/fusion-wc-person';
+import { IPersonController } from './PersonController';
+
+export const createResolver = (controller: IPersonController): PersonResolver => ({
+    getDetails(args) {
+        return firstValueFrom(
+            controller.getPerson(args).pipe(
+                /** TODO */
+                map((x) => ({ ...x, azureId: x.azureUniqueId }) as unknown as PersonDetails),
+            ),
+        );
+    },
+    getInfo(args) {
+        return firstValueFrom(
+            controller.getPersonInfo(args).pipe(
+                /** TODO */
+                map((x) => ({ ...x, azureId: x.azureUniqueId }) as unknown as PersonInfo),
+            ),
+        );
+    },
+    getPhoto(args) {
+        return firstValueFrom(controller.getPhoto(args));
+    },
+    search(args) {
+        return firstValueFrom(
+            controller.search(args).pipe(
+                map((x) =>
+                    x.map(
+                        (x) =>
+                            ({
+                                ...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,
+                    ),
+                ),
+            ),
+        );
+    },
+});
+
+export default createResolver;

package/src/index.ts

@@ -0,0 +1 @@
+export { PeopleResolverProvider, default } from './PeopleResolverProvider';

package/src/makeResolver.tsx

@@ -0,0 +1,19 @@
+import { lazy } from 'react';
+import { PeopleResolverComponent } from './PeopleResolver';
+import { PersonController, PersonControllerOptions } from './PersonController';
+import { createResolver } from './create-resolver';
+import { IApiProvider } from '@equinor/fusion-framework-module-services';
+
+export const makeResolver = (services: IApiProvider, options?: PersonControllerOptions) => {
+    return lazy(async () => {
+        const client = await services.createPeopleClient();
+        const controller = new PersonController(client, options);
+        const resolver = createResolver(controller);
+        const Component = ({ children }: { readonly children?: React.ReactNode }) => (
+            <PeopleResolverComponent resolver={resolver}>{children}</PeopleResolverComponent>
+        );
+        return {
+            default: Component,
+        };
+    });
+};

package/src/types.ts

@@ -0,0 +1,6 @@
+import type { ApiResponse as PersonDetailApiResponse } from '@equinor/fusion-framework-module-services/people/get';
+
+export type ApiPerson = PersonDetailApiResponse<
+    'v4',
+    { azureId: ''; expand: ['positions', 'manager'] }
+>;

package/src/version.ts

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

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "extends": "../../tsconfig.react.json",
+  "compilerOptions": {
+    "outDir": "dist/esm",
+    "rootDir": "src",
+    "declarationDir": "./dist/types"
+  },
+  "references": [
+    {
+      "path": "../../framework"
+    },
+    {
+      "path": "../../../modules/services"
+    }
+  ],
+  "include": [
+    "src/**/*"
+  ],
+  "exclude": [
+    "node_modules",
+    "lib"
+  ]
+}