@equinor/fusion-framework-module-context 2.0.14 → 3.0.0

package/dist/types/ContextConfigBuilder.d.ts

@@ -2,7 +2,7 @@ import type { AnyModule, ModuleInitializerArgs, Modules, ModuleType } from '@equ
 import type { QueryCtorOptions, QueryFn } from '@equinor/fusion-query';
 import type { GetContextParameters } from './client/ContextClient';
 import type { ContextModuleConfig, ContextModuleConfigurator, IContextModuleConfigurator } from './configurator';
-import type { ContextItem, QueryContextParameters } from './types';
+import type { ContextItem, QueryContextParameters, RelatedContextParameters } from './types';
 export type ContextConfigBuilderCallback = <TDeps extends Array<AnyModule> = []>(builder: ContextConfigBuilder<TDeps, ModuleInitializerArgs<IContextModuleConfigurator, TDeps>>) => void | Promise<void>;
 export declare class ContextConfigBuilder<TModules extends Array<AnyModule> = [], TInit extends ModuleInitializerArgs<any, any> = ModuleInitializerArgs<ContextModuleConfigurator, TModules>> {
     #private;
@@ -13,8 +13,11 @@ export declare class ContextConfigBuilder<TModules extends Array<AnyModule> = []
     setContextType(type: ContextModuleConfig['contextType']): void;
     setContextFilter(filter: ContextModuleConfig['contextFilter']): void;
     setContextParameterFn(fn: ContextModuleConfig['contextParameterFn']): void;
+    setValidateContext(fn: ContextModuleConfig['validateContext']): void;
+    setResolveContext(fn: ContextModuleConfig['resolveContext']): void;
     setContextClient(client: {
         get: QueryFn<ContextItem, GetContextParameters> | QueryCtorOptions<ContextItem, GetContextParameters>;
         query: QueryFn<ContextItem[], QueryContextParameters> | QueryCtorOptions<ContextItem[], QueryContextParameters>;
+        related?: QueryFn<ContextItem[], RelatedContextParameters> | QueryCtorOptions<ContextItem[], RelatedContextParameters>;
     }, expire?: number): void;
 }

package/dist/types/ContextProvider.d.ts

@@ -1,7 +1,7 @@
 import { Observable } from 'rxjs';
 import { ContextModuleConfig } from './configurator';
 import { ContextClient } from './client/ContextClient';
-import { ContextItem, QueryContextParameters } from './types';
+import { ContextItem, QueryContextParameters, RelatedContextParameters } from './types';
 import { ModuleType } from '@equinor/fusion-framework-module';
 import { EventModule, FrameworkEvent, FrameworkEventInit } from '@equinor/fusion-framework-module-event';
 import Query from '@equinor/fusion-query';
@@ -12,6 +12,11 @@ export interface IContextProvider {
     currentContext: ContextItem | undefined;
     queryContext(search: string): Observable<Array<ContextItem>>;
     queryContextAsync(search: string): Promise<Array<ContextItem>>;
+    validateContext(item: ContextItem<Record<string, unknown>>): boolean;
+    resolveContext: (current: ContextItem) => Observable<ContextItem>;
+    resolveContextAsync: (current: ContextItem) => Promise<ContextItem>;
+    relatedContexts: (args: RelatedContextParameters) => Observable<Array<ContextItem<Record<string, unknown>>>>;
+    relatedContextsAsync: (args: RelatedContextParameters) => Promise<Array<ContextItem<Record<string, unknown>>>>;
     clearCurrentContext: VoidFunction;
 }
 export declare class ContextProvider implements IContextProvider {
@@ -26,8 +31,17 @@ export declare class ContextProvider implements IContextProvider {
         event?: ModuleType<EventModule>;
         parentContext?: IContextProvider;
     });
+    setCurrentContext(context: ContextItem<Record<string, unknown>>, opt?: {
+        validate?: boolean;
+        resolve?: boolean;
+    }): Promise<ContextItem<Record<string, unknown>>>;
     queryContext(search: string): Observable<Array<ContextItem>>;
     queryContextAsync(search: string): Promise<Array<ContextItem>>;
+    validateContext(item: ContextItem<Record<string, unknown>>): boolean;
+    resolveContext(item: ContextItem<Record<string, unknown>>): Observable<ContextItem<Record<string, unknown>>>;
+    resolveContextAsync(item: ContextItem<Record<string, unknown>>): Promise<ContextItem<Record<string, unknown>>>;
+    relatedContexts(args: RelatedContextParameters): Observable<Array<ContextItem<Record<string, unknown>>>>;
+    relatedContextsAsync(args: RelatedContextParameters): Promise<Array<ContextItem<Record<string, unknown>>>>;
     clearCurrentContext(): void;
     dispose(): void;
 }
@@ -41,5 +55,15 @@ declare module '@equinor/fusion-framework-module-event' {
             next: ContextItem | undefined;
             previous: ContextItem | undefined;
         }, IContextProvider>>;
+        onParentContextChanged: FrameworkEvent<FrameworkEventInit<{
+            context: ContextItem | undefined;
+        }, IContextProvider>>;
+        onSetContextResolve: FrameworkEvent<FrameworkEventInit<{
+            context: ContextItem;
+        }, IContextProvider>>;
+        onSetContextResolved: FrameworkEvent<FrameworkEventInit<{
+            input: ContextItem;
+            result?: ContextItem | null;
+        }, IContextProvider>>;
     }
 }

package/dist/types/configurator.d.ts

@@ -1,13 +1,15 @@
 import { ModuleInitializerArgs } from '@equinor/fusion-framework-module';
 import { ServicesModule, IApiProvider } from '@equinor/fusion-framework-module-services';
 import { QueryCtorOptions } from '@equinor/fusion-query';
-import { ContextFilterFn, ContextItem, QueryContextParameters } from './types';
+import { ContextFilterFn, ContextItem, QueryContextParameters, RelatedContextParameters } from './types';
 import { GetContextParameters } from './client/ContextClient';
 import { ContextConfigBuilderCallback } from './ContextConfigBuilder';
+import { IContextProvider } from 'ContextProvider';
 export interface ContextModuleConfig {
     client: {
         get: QueryCtorOptions<ContextItem, GetContextParameters>;
         query: QueryCtorOptions<ContextItem[], QueryContextParameters>;
+        related?: QueryCtorOptions<ContextItem[], RelatedContextParameters>;
     };
     contextType?: string[];
     contextFilter?: ContextFilterFn;
@@ -15,6 +17,8 @@ export interface ContextModuleConfig {
         search: string;
         type: ContextModuleConfig['contextType'];
     }) => string | QueryContextParameters;
+    resolveContext?: (this: IContextProvider, item: ContextItem | null) => ReturnType<IContextProvider['resolveContext']>;
+    validateContext?: (this: IContextProvider, item: ContextItem | null) => ReturnType<IContextProvider['validateContext']>;
 }
 export interface IContextModuleConfigurator {
     addConfigBuilder: (init: ContextConfigBuilderCallback) => void;

package/dist/types/selectors.d.ts

@@ -1,3 +1,4 @@
 import type { ContextItem } from './types';
 export declare const getContextSelector: (response: Response) => Promise<ContextItem>;
 export declare const queryContextSelector: (response: Response) => Promise<ContextItem[]>;
+export declare const relatedContextSelector: (response: Response) => Promise<ContextItem[]>;

package/dist/types/types.d.ts

@@ -23,4 +23,10 @@ export type QueryContextParameters = {
         externalId?: string;
     };
 };
+export type RelatedContextParameters = {
+    item: ContextItem;
+    filter?: {
+        type?: string[];
+    };
+};
 export type ContextFilterFn = (items: ContextItem[]) => ContextItem[];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@equinor/fusion-framework-module-context",
-    "version": "2.0.14",
+    "version": "3.0.0",
     "description": "",
     "main": "./dist/esm/index.js",
     "exports": {
@@ -31,18 +31,18 @@
         "directory": "packages/modules/context"
     },
     "dependencies": {
-        "@equinor/fusion-query": "^2.0.7",
+        "@equinor/fusion-query": "^3.0.0",
         "fast-deep-equal": "^3.1.3"
     },
     "devDependencies": {
-        "@equinor/fusion-framework-module": "^2.0.1",
-        "@equinor/fusion-framework-module-event": "^2.0.1",
-        "@equinor/fusion-framework-module-services": "^2.5.0",
+        "@equinor/fusion-framework-module": "^3.0.0",
+        "@equinor/fusion-framework-module-event": "^3.0.0",
+        "@equinor/fusion-framework-module-services": "^3.0.0",
         "rxjs": "^7.5.7"
     },
     "peerDependencies": {
         "@equinor/fusion-framework-module": ">=1.2.5",
         "rxjs": "^7.5.7"
     },
-    "gitHead": "dd4ed92c8f1d020f3b537172b4fe7788aeae99e7"
+    "gitHead": "3462d21feac22290eec2dce3b00602da22a7a74d"
 }

package/src/ContextConfigBuilder.ts

@@ -15,7 +15,7 @@ import type {
     IContextModuleConfigurator,
 } from './configurator';
 
-import type { ContextItem, QueryContextParameters } from './types';
+import type { ContextItem, QueryContextParameters, RelatedContextParameters } from './types';
 
 export type ContextConfigBuilderCallback = <TDeps extends Array<AnyModule> = []>(
     builder: ContextConfigBuilder<TDeps, ModuleInitializerArgs<IContextModuleConfigurator, TDeps>>
@@ -57,6 +57,14 @@ export class ContextConfigBuilder<
         this.config.contextParameterFn = fn;
     }
 
+    setValidateContext(fn: ContextModuleConfig['validateContext']) {
+        this.config.validateContext = fn;
+    }
+
+    setResolveContext(fn: ContextModuleConfig['resolveContext']) {
+        this.config.resolveContext = fn;
+    }
+
     setContextClient(
         client: {
             get:
@@ -65,6 +73,9 @@ export class ContextConfigBuilder<
             query:
                 | QueryFn<ContextItem[], QueryContextParameters>
                 | QueryCtorOptions<ContextItem[], QueryContextParameters>;
+            related?:
+                | QueryFn<ContextItem[], RelatedContextParameters>
+                | QueryCtorOptions<ContextItem[], RelatedContextParameters>;
         },
         expire = 1 * 60 * 1000
     ): void {
@@ -91,5 +102,19 @@ export class ContextConfigBuilder<
                       }
                     : client.query,
         };
+        if (client.related) {
+            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+            this.config.client!.related =
+                typeof client.related === 'function'
+                    ? {
+                          // TODO - might cast to checksum
+                          key: (args) => JSON.stringify(args),
+                          client: {
+                              fn: client.related,
+                          },
+                          expire,
+                      }
+                    : client.related;
+        }
     }
 }

package/src/ContextProvider.ts

@@ -1,10 +1,10 @@
-import { lastValueFrom, Observable, Subscription } from 'rxjs';
-import { map, pairwise } from 'rxjs/operators';
+import { lastValueFrom, Observable, Subscription, throwError } from 'rxjs';
+import { filter, map, pairwise, switchMap } from 'rxjs/operators';
 
 import { ContextModuleConfig } from './configurator';
 
 import { ContextClient } from './client/ContextClient';
-import { ContextItem, QueryContextParameters } from './types';
+import { ContextItem, QueryContextParameters, RelatedContextParameters } from './types';
 import { ModuleType } from '@equinor/fusion-framework-module';
 import {
     EventModule,
@@ -27,12 +27,22 @@ export interface IContextProvider {
     currentContext: ContextItem | undefined;
     queryContext(search: string): Observable<Array<ContextItem>>;
     queryContextAsync(search: string): Promise<Array<ContextItem>>;
+    validateContext(item: ContextItem<Record<string, unknown>>): boolean;
+    resolveContext: (current: ContextItem) => Observable<ContextItem>;
+    resolveContextAsync: (current: ContextItem) => Promise<ContextItem>;
+    relatedContexts: (
+        args: RelatedContextParameters
+    ) => Observable<Array<ContextItem<Record<string, unknown>>>>;
+    relatedContextsAsync: (
+        args: RelatedContextParameters
+    ) => Promise<Array<ContextItem<Record<string, unknown>>>>;
     clearCurrentContext: VoidFunction;
 }
 
 export class ContextProvider implements IContextProvider {
     #contextClient: ContextClient;
     #contextQuery: Query<Array<ContextItem>, QueryContextParameters>;
+    #contextRelated?: Query<Array<ContextItem>, RelatedContextParameters>;
 
     #event?: ModuleType<EventModule>;
 
@@ -59,24 +69,7 @@ export class ContextProvider implements IContextProvider {
     }
 
     set currentContext(context: ContextItem | undefined) {
-        if (this.#event) {
-            /** notify listeners that context is about to change */
-            this.#event
-                .dispatchEvent('onCurrentContextChange', {
-                    source: this,
-                    canBubble: true,
-                    cancelable: true,
-                    detail: { context },
-                })
-                .then((e) => {
-                    /** check if setting context was prevented by listener */
-                    if (!e.canceled) {
-                        this.#contextClient.setCurrentContext(context);
-                    }
-                });
-        } else {
-            this.#contextClient.setCurrentContext(context);
-        }
+        context ? this.setCurrentContext(context) : this.clearCurrentContext();
     }
 
     constructor(args: {
@@ -86,11 +79,19 @@ export class ContextProvider implements IContextProvider {
     }) {
         const { config, event, parentContext } = args;
 
+        config.resolveContext && (this.resolveContext = config.resolveContext?.bind(this));
+        config.validateContext && (this.validateContext = config.validateContext?.bind(this));
+
         this.#contextType = config.contextType;
         this.#contextFilter = config.contextFilter;
 
         this.#contextClient = new ContextClient(config.client.get);
         this.#contextQuery = new Query(config.client.query);
+
+        if (config.client.related) {
+            this.#contextRelated = new Query(config.client.related);
+        }
+
         this.#contextParameterFn =
             config.contextParameterFn ??
             ((args: Parameters<Required<ContextModuleConfig>['contextParameterFn']>[0]) => ({
@@ -127,13 +128,104 @@ export class ContextProvider implements IContextProvider {
 
         if (parentContext) {
             this.#subscriptions.add(
-                parentContext.contextClient.currentContext$.subscribe(
-                    (next) => (this.currentContext = next)
-                )
+                parentContext.contextClient.currentContext$
+                    .pipe(
+                        switchMap(async (next) => {
+                            if (next) {
+                                const onParentContextChanged = await this.#event?.dispatchEvent(
+                                    'onParentContextChanged',
+                                    {
+                                        source: this,
+                                        detail: next,
+                                        cancelable: true,
+                                    }
+                                );
+                                return { next, canceled: onParentContextChanged?.canceled };
+                            }
+                            return { next };
+                        }),
+                        filter((x) => !x.canceled),
+                        map(({ next }) => next)
+                    )
+                    .subscribe((next) => {
+                        if (next) {
+                            try {
+                                this.setCurrentContext(next, {
+                                    validate: true,
+                                    resolve: true,
+                                });
+                            } catch (err) {
+                                console.warn('ContextProvider::onParentContextChanged', err);
+                            }
+                        } else {
+                            this.clearCurrentContext();
+                        }
+                    })
             );
         }
     }
 
+    public async setCurrentContext(
+        context: ContextItem<Record<string, unknown>>,
+        opt?: { validate?: boolean; resolve?: boolean }
+    ): Promise<ContextItem<Record<string, unknown>>> {
+        if (context === this.currentContext) {
+            return context;
+        }
+        if (opt?.validate && !this.validateContext(context)) {
+            if (opt.resolve) {
+                /** notify listeners about to resolve invalid context */
+                const onSetContextResolve = await this.#event?.dispatchEvent(
+                    'onSetContextResolve',
+                    {
+                        source: this,
+                        cancelable: true,
+                        detail: { context },
+                    }
+                );
+                if (onSetContextResolve?.canceled) {
+                    throw Error('resolving of context was canceled');
+                }
+
+                try {
+                    const resolvedContext = await this.resolveContextAsync(context);
+                    /** notify listeners about to resolved invalid context */
+                    const onSetContextResolved = await this.#event?.dispatchEvent(
+                        'onSetContextResolved',
+                        {
+                            source: this,
+                            cancelable: true,
+                            detail: { input: context, result: resolvedContext },
+                        }
+                    );
+                    if (onSetContextResolved?.canceled) {
+                        throw Error('resolving of context was canceled');
+                    }
+                    return this.setCurrentContext(resolvedContext);
+                } catch (err) {
+                    console.error('failed to resolve context', context, err);
+                    this.clearCurrentContext();
+                }
+            }
+            throw Error('failed to validate provided context');
+        }
+
+        const onCurrentContextChange = await this.#event?.dispatchEvent('onCurrentContextChange', {
+            source: this,
+            canBubble: true,
+            cancelable: true,
+            detail: { context: context },
+        });
+
+        if (onCurrentContextChange?.canceled) {
+            throw Error('change of context was aborted');
+        }
+
+        this.#contextClient.setCurrentContext(context);
+
+        return context;
+    }
+
     public queryContext(search: string): Observable<Array<ContextItem>> {
         const query$ = this.queryClient
             .query(
@@ -151,8 +243,60 @@ export class ContextProvider implements IContextProvider {
         return lastValueFrom(this.queryContext(search));
     }
 
+    public validateContext(item: ContextItem<Record<string, unknown>>): boolean {
+        if (!this.#contextType) return true;
+        return this.#contextType.map((x) => x.toLowerCase()).includes(item.type.id.toLowerCase());
+    }
+
+    public resolveContext(
+        item: ContextItem<Record<string, unknown>>
+    ): Observable<ContextItem<Record<string, unknown>>> {
+        return this.relatedContexts({ item, filter: { type: this.#contextType } }).pipe(
+            map((x) => x.filter((item) => this.validateContext(item))),
+            map((values) => {
+                const value = values.shift();
+                if (!value) {
+                    throw Error('failed to resolve context');
+                }
+                if (values.length) {
+                    console.warn(
+                        'ContextProvider::relatedContext',
+                        'multiple items found 🤣',
+                        values
+                    );
+                }
+                return value;
+            })
+        );
+    }
+
+    public resolveContextAsync(
+        item: ContextItem<Record<string, unknown>>
+    ): Promise<ContextItem<Record<string, unknown>>> {
+        return lastValueFrom(this.resolveContext(item));
+    }
+
+    public relatedContexts(
+        args: RelatedContextParameters
+    ): Observable<Array<ContextItem<Record<string, unknown>>>> {
+        if (!this.#contextRelated) {
+            return throwError(() =>
+                Error(
+                    'ContextProvider::relatedContexts - no client defined for resolving related context'
+                )
+            );
+        }
+        return this.#contextRelated.query(args).pipe(map(({ value }) => value));
+    }
+
+    public relatedContextsAsync(
+        args: RelatedContextParameters
+    ): Promise<Array<ContextItem<Record<string, unknown>>>> {
+        return lastValueFrom(this.relatedContexts(args));
+    }
+
     public clearCurrentContext() {
-        this.currentContext = undefined;
+        this.#contextClient.setCurrentContext(undefined);
     }
 
     dispose() {
@@ -183,5 +327,31 @@ declare module '@equinor/fusion-framework-module-event' {
                 IContextProvider
             >
         >;
+        onParentContextChanged: FrameworkEvent<
+            FrameworkEventInit<
+                {
+                    context: ContextItem | undefined;
+                },
+                IContextProvider
+            >
+        >;
+
+        onSetContextResolve: FrameworkEvent<
+            FrameworkEventInit<
+                {
+                    context: ContextItem;
+                },
+                IContextProvider
+            >
+        >;
+        onSetContextResolved: FrameworkEvent<
+            FrameworkEventInit<
+                {
+                    input: ContextItem;
+                    result?: ContextItem | null;
+                },
+                IContextProvider
+            >
+        >;
     }
 }

package/src/configurator.ts

@@ -1,15 +1,22 @@
 import { ModuleInitializerArgs, ModulesInstanceType } from '@equinor/fusion-framework-module';
 import { ServicesModule, IApiProvider } from '@equinor/fusion-framework-module-services';
-import { getContextSelector, queryContextSelector } from './selectors';
+import { getContextSelector, queryContextSelector, relatedContextSelector } from './selectors';
 import { QueryCtorOptions } from '@equinor/fusion-query';
-import { ContextFilterFn, ContextItem, QueryContextParameters } from './types';
+import {
+    ContextFilterFn,
+    ContextItem,
+    QueryContextParameters,
+    RelatedContextParameters,
+} from './types';
 import { GetContextParameters } from './client/ContextClient';
 import { ContextConfigBuilder, ContextConfigBuilderCallback } from './ContextConfigBuilder';
+import { IContextProvider } from 'ContextProvider';
 
 export interface ContextModuleConfig {
     client: {
         get: QueryCtorOptions<ContextItem, GetContextParameters>;
         query: QueryCtorOptions<ContextItem[], QueryContextParameters>;
+        related?: QueryCtorOptions<ContextItem[], RelatedContextParameters>;
     };
     contextType?: string[];
     contextFilter?: ContextFilterFn;
@@ -21,6 +28,16 @@ export interface ContextModuleConfig {
         search: string;
         type: ContextModuleConfig['contextType'];
     }) => string | QueryContextParameters;
+
+    resolveContext?: (
+        this: IContextProvider,
+        item: ContextItem | null
+    ) => ReturnType<IContextProvider['resolveContext']>;
+
+    validateContext?: (
+        this: IContextProvider,
+        item: ContextItem | null
+    ) => ReturnType<IContextProvider['validateContext']>;
 }
 
 export interface IContextModuleConfigurator {
@@ -87,6 +104,20 @@ export class ContextModuleConfigurator implements IContextModuleConfigurator {
                     key: (args) => JSON.stringify(args),
                     expire: this.defaultExpireTime,
                 },
+                related: {
+                    client: {
+                        fn: (args) => {
+                            return contextClient.related(
+                                'v1',
+                                { id: args.item.id, query: { filter: args.filter } },
+                                { selector: relatedContextSelector }
+                            );
+                        },
+                    },
+                    // TODO - might cast to checksum
+                    key: (args) => JSON.stringify(args),
+                    expire: this.defaultExpireTime,
+                },
             };
         })();
 

package/src/selectors.ts

@@ -1,6 +1,7 @@
 import { ApiVersion, ApiContextEntity } from '@equinor/fusion-framework-module-services/context';
 import type { GetContextResponse } from '@equinor/fusion-framework-module-services/context/get';
 import type { QueryContextResponse } from '@equinor/fusion-framework-module-services/context/query';
+import type { RelatedContextResponse } from '@equinor/fusion-framework-module-services/context/related';
 import type { ContextItem, ContextItemType } from './types';
 
 const parseContextType = (type: GetContextResponse<'v1'>['type']): ContextItemType => ({
@@ -33,3 +34,8 @@ export const queryContextSelector = async (response: Response): Promise<ContextI
     const result = (await response.json()) as QueryContextResponse<'v1'>;
     return result.map(parseContextItem);
 };
+
+export const relatedContextSelector = async (response: Response): Promise<ContextItem[]> => {
+    const result = (await response.json()) as RelatedContextResponse<'v1'>;
+    return result.map(parseContextItem);
+};

package/src/types.ts

@@ -26,4 +26,6 @@ export type QueryContextParameters = {
     };
 };
 
+export type RelatedContextParameters = { item: ContextItem; filter?: { type?: string[] } };
+
 export type ContextFilterFn = (items: ContextItem[]) => ContextItem[];