@equinor/fusion-framework-module-context 3.1.2 → 4.0.0-next.0

package/dist/types/ContextConfigBuilder.d.ts

@@ -15,6 +15,7 @@ export declare class ContextConfigBuilder<TModules extends Array<AnyModule> = []
     setContextParameterFn(fn: ContextModuleConfig['contextParameterFn']): void;
     setValidateContext(fn: ContextModuleConfig['validateContext']): void;
     setResolveContext(fn: ContextModuleConfig['resolveContext']): void;
+    setSkipInitialContext(skip: ContextModuleConfig['skipInitialContext']): void;
     setContextClient(client: {
         get: QueryFn<ContextItem, GetContextParameters> | QueryCtorOptions<ContextItem, GetContextParameters>;
         query: QueryFn<ContextItem[], QueryContextParameters> | QueryCtorOptions<ContextItem[], QueryContextParameters>;

package/dist/types/ContextProvider.d.ts

@@ -1,4 +1,4 @@
-import { Observable } from 'rxjs';
+import { Observable, Subscription } from 'rxjs';
 import { ContextModuleConfig } from './configurator';
 import { ContextClient } from './client/ContextClient';
 import { ContextItem, QueryContextParameters, RelatedContextParameters } from './types';
@@ -18,6 +18,16 @@ export interface IContextProvider {
     relatedContexts: (args: RelatedContextParameters) => Observable<Array<ContextItem<Record<string, unknown>>>>;
     relatedContextsAsync: (args: RelatedContextParameters) => Promise<Array<ContextItem<Record<string, unknown>>>>;
     clearCurrentContext: VoidFunction;
+    setCurrentContextById(id: string): Observable<ContextItem<Record<string, unknown>>>;
+    setCurrentContextByIdAsync(id: string): Promise<ContextItem<Record<string, unknown>>>;
+    setCurrentContext(context: ContextItem<Record<string, unknown>>, opt?: {
+        validate?: boolean;
+        resolve?: boolean;
+    }): Observable<ContextItem<Record<string, unknown>>>;
+    setCurrentContextAsync(context: ContextItem<Record<string, unknown>>, opt?: {
+        validate?: boolean;
+        resolve?: boolean;
+    }): Promise<ContextItem<Record<string, unknown>>>;
 }
 export declare class ContextProvider implements IContextProvider {
     #private;
@@ -31,9 +41,18 @@ export declare class ContextProvider implements IContextProvider {
         event?: ModuleType<EventModule>;
         parentContext?: IContextProvider;
     });
+    connectParentContextAsync(provider: IContextProvider, opt?: {
+        setCurrent?: boolean;
+    }): Promise<Subscription>;
+    setCurrentContextById(id: string): Observable<ContextItem<Record<string, unknown>>>;
+    setCurrentContextByIdAsync(id: string): Promise<ContextItem<Record<string, unknown>>>;
     setCurrentContext(context: ContextItem<Record<string, unknown>>, opt?: {
         validate?: boolean;
         resolve?: boolean;
+    }): Observable<ContextItem<Record<string, unknown>>>;
+    setCurrentContextAsync(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>>;

package/dist/types/client/ContextClient.d.ts

@@ -14,5 +14,6 @@ export declare class ContextClient extends Observable<ContextItem> {
     constructor(options: QueryCtorOptions<ContextItem, GetContextParameters>);
     setCurrentContext(idOrItem?: string | ContextItem): void;
     resolveContext(id: string): Observable<ContextItem>;
+    dispose(): void;
 }
 export default ContextClient;

package/dist/types/configurator.d.ts

@@ -13,6 +13,7 @@ export interface ContextModuleConfig {
     };
     contextType?: string[];
     contextFilter?: ContextFilterFn;
+    skipInitialContext?: boolean;
     contextParameterFn?: (args: {
         search: string;
         type: ContextModuleConfig['contextType'];

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@equinor/fusion-framework-module-context",
-    "version": "3.1.2",
+    "version": "4.0.0-next.0",
     "description": "",
     "main": "./dist/esm/index.js",
     "exports": {
@@ -44,5 +44,5 @@
         "@equinor/fusion-framework-module": ">=1.2.5",
         "rxjs": "^7.5.7"
     },
-    "gitHead": "6983a4f2bf1fb24c086abcba53c2349d39f34a21"
+    "gitHead": "cdf3599bbf7ed06c1664edd9cb755a6f7b0284dd"
 }

package/src/ContextConfigBuilder.ts

@@ -65,6 +65,10 @@ export class ContextConfigBuilder<
         this.config.resolveContext = fn;
     }
 
+    setSkipInitialContext(skip: ContextModuleConfig['skipInitialContext']) {
+        this.config.skipInitialContext = skip;
+    }
+
     setContextClient(
         client: {
             get:

package/src/ContextProvider.ts

@@ -1,5 +1,13 @@
-import { lastValueFrom, Observable, Subscription, throwError } from 'rxjs';
-import { filter, map, pairwise, switchMap } from 'rxjs/operators';
+import {
+    EMPTY,
+    firstValueFrom,
+    lastValueFrom,
+    Observable,
+    of,
+    Subscription,
+    throwError,
+} from 'rxjs';
+import { catchError, filter, map, pairwise, switchMap } from 'rxjs/operators';
 
 import { ContextModuleConfig } from './configurator';
 
@@ -37,6 +45,19 @@ export interface IContextProvider {
         args: RelatedContextParameters
     ) => Promise<Array<ContextItem<Record<string, unknown>>>>;
     clearCurrentContext: VoidFunction;
+
+    setCurrentContextById(id: string): Observable<ContextItem<Record<string, unknown>>>;
+    setCurrentContextByIdAsync(id: string): Promise<ContextItem<Record<string, unknown>>>;
+
+    setCurrentContext(
+        context: ContextItem<Record<string, unknown>>,
+        opt?: { validate?: boolean; resolve?: boolean }
+    ): Observable<ContextItem<Record<string, unknown>>>;
+
+    setCurrentContextAsync(
+        context: ContextItem<Record<string, unknown>>,
+        opt?: { validate?: boolean; resolve?: boolean }
+    ): Promise<ContextItem<Record<string, unknown>>>;
 }
 
 export class ContextProvider implements IContextProvider {
@@ -68,16 +89,32 @@ export class ContextProvider implements IContextProvider {
         return this.#contextClient.currentContext;
     }
 
+    /** @deprecated do not use, will be removed */
     set currentContext(context: ContextItem | undefined) {
-        context ? this.setCurrentContext(context) : this.clearCurrentContext();
+        console.warn(
+            '@deprecated',
+            'ContextProvider.currentContext',
+            'use setCurrentContextById|setCurrentContext|clearCurrentContext'
+        );
+        context ? this.setCurrentContextAsync(context) : this.clearCurrentContext();
     }
 
     constructor(args: {
         config: ContextModuleConfig;
         event?: ModuleType<EventModule>;
+        /** @deprecated use  ContextProvider.connectParentContext */
         parentContext?: IContextProvider;
     }) {
-        const { config, event, parentContext } = args;
+        const { config, event } = args;
+
+        if (args.parentContext) {
+            console.warn(
+                '@deprecated',
+                'parentContext as arg is deprecated, use ContextProvider.connectParentContext'
+            );
+        }
+
+        this.#event = event;
 
         config.resolveContext && (this.resolveContext = config.resolveContext?.bind(this));
         config.validateContext && (this.validateContext = config.validateContext?.bind(this));
@@ -99,25 +136,21 @@ export class ContextProvider implements IContextProvider {
                 filter: { type: args.type },
             }));
 
-        if (event) {
-            this.#event = event;
-
-            /** this might be moved to client, to await prevention of event */
+        if (this.#event) {
             this.#subscriptions.add(
                 this.#contextClient.currentContext$
                     .pipe(pairwise())
                     .subscribe(([previous, next]) => {
-                        event.dispatchEvent('onCurrentContextChanged', {
+                        this.#event?.dispatchEvent('onCurrentContextChanged', {
                             source: this,
                             canBubble: true,
                             detail: { previous, next },
                         });
                     })
             );
-
             this.#subscriptions.add(
                 /** observe event from child modules */
-                event.addEventListener('onCurrentContextChanged', (e) => {
+                this.#event.addEventListener('onCurrentContextChanged', (e) => {
                     /** loop prevention */
                     if (e.source !== this) {
                         this.currentContext = e.detail.next;
@@ -125,112 +158,195 @@ export class ContextProvider implements IContextProvider {
                 })
             );
         }
+    }
 
-        if (parentContext) {
-            this.#subscriptions.add(
-                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(async (next) => {
-                        if (next) {
-                            try {
-                                await this.setCurrentContext(next, {
-                                    validate: true,
-                                    resolve: true,
-                                });
-                            } catch (err) {
-                                console.warn('ContextProvider::onParentContextChanged', err);
-                            }
-                        } else {
-                            this.clearCurrentContext();
+    public async connectParentContextAsync(
+        provider: IContextProvider,
+        opt?: { setCurrent?: boolean }
+    ): Promise<Subscription> {
+        const parentContext$ = provider.currentContext$.pipe(
+            filter((next) => this.currentContext !== next),
+            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),
+            switchMap(({ next }) => {
+                if (!next) {
+                    this.clearCurrentContext();
+                    return EMPTY;
+                }
+                return this.setCurrentContext(next, {
+                    validate: true,
+                    resolve: true,
+                }).pipe(
+                    catchError((err) => {
+                        console.warn(
+                            'ContextProvider::onParentContextChanged',
+                            'setCurrentContext',
+                            err
+                        );
+                        return EMPTY;
                     })
-            );
-        }
+                );
+            }),
+            catchError((err) => {
+                console.warn('ContextProvider::onParentContextChanged', 'unhandled exception', err);
+                return EMPTY;
+            })
+        );
+
+        const subscription = parentContext$.subscribe();
+        this.#subscriptions.add(subscription);
+
+        return new Promise((resolve, reject) => {
+            if (opt?.setCurrent && provider.currentContext) {
+                subscription.add(reject);
+                subscription.add(
+                    this.setCurrentContext(provider.currentContext, {
+                        validate: true,
+                        resolve: true,
+                    }).subscribe({
+                        error: (err) => {
+                            subscription.remove(reject);
+                            reject(err);
+                        },
+                        complete: () => {
+                            subscription.remove(reject);
+                            resolve(subscription);
+                        },
+                    })
+                );
+            } else {
+                return resolve(subscription);
+            }
+        });
+    }
+
+    public setCurrentContextById(id: string): Observable<ContextItem<Record<string, unknown>>> {
+        return new Observable((subscriber) => {
+            try {
+                this.#contextClient
+                    .resolveContext(id)
+                    .pipe(switchMap((item) => this.setCurrentContext(item)))
+                    .subscribe(subscriber);
+            } catch (err) {
+                subscriber.error(err);
+            }
+        });
     }
 
-    public async setCurrentContext(
+    public setCurrentContextByIdAsync(id: string): Promise<ContextItem<Record<string, unknown>>> {
+        return firstValueFrom(this.setCurrentContextById(id));
+    }
+
+    public 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',
-                    {
+    ): Observable<ContextItem<Record<string, unknown>>> {
+        return new Observable((subscriber) => {
+            if (context === this.currentContext) {
+                subscriber.next(context);
+                return subscriber.complete();
+            }
+            if (opt?.validate && !this.validateContext(context)) {
+                if (!opt.resolve) {
+                    /** cannot resolve context, and provided is invalid  */
+                    this.#event?.dispatchEvent('onSetContextValidationFailed', {
                         source: this,
-                        cancelable: true,
                         detail: { context },
-                    }
-                );
-                if (onSetContextResolve?.canceled) {
-                    throw Error('resolving of context was canceled');
+                    });
+                    return subscriber.error(Error('failed to validate provided context'));
                 }
+                if (opt.resolve) {
+                    return of(context)
+                        .pipe(
+                            /** notify event observers that context is about to get resolved */
+                            switchMap(async (context) => {
+                                const event = await this.#event?.dispatchEvent(
+                                    'onSetContextResolve',
+                                    {
+                                        source: this,
+                                        cancelable: true,
+                                        detail: { context },
+                                    }
+                                );
+                                if (event?.canceled) {
+                                    throw Error('resolving of context was canceled');
+                                }
+                                return context;
+                            }),
+                            /** execute resolve */
+                            switchMap((context) =>
+                                this.resolveContext(context).pipe(
+                                    map((resolved) => ({
+                                        context,
+                                        resolved,
+                                    }))
+                                )
+                            ),
+                            /** notify event observers that context was resolved */
+                            switchMap(async ({ context, resolved }) => {
+                                const event = await this.#event?.dispatchEvent(
+                                    'onSetContextResolved',
+                                    {
+                                        source: this,
+                                        cancelable: true,
+                                        detail: { context, resolved },
+                                    }
+                                );
+                                if (event?.canceled) {
+                                    throw Error('resolving of context was canceled');
+                                }
+                                return resolved;
+                            }),
+                            /** recursive set current context without validation and resolve */
+                            switchMap((resolved) => this.setCurrentContext(resolved))
+                        )
+                        .subscribe(subscriber);
+                }
+            }
 
-                try {
-                    const resolved = await this.resolveContextAsync(context);
-                    /** notify listeners about to resolved invalid context */
-                    const onSetContextResolved = await this.#event?.dispatchEvent(
-                        'onSetContextResolved',
-                        {
+            return of(context)
+                .pipe(
+                    switchMap(async (context) => {
+                        const event = await this.#event?.dispatchEvent('onCurrentContextChange', {
                             source: this,
+                            canBubble: true,
                             cancelable: true,
-                            detail: { context, resolved },
+                            detail: { context: context },
+                        });
+
+                        if (event?.canceled) {
+                            throw Error('change of context was aborted');
                         }
-                    );
-                    if (onSetContextResolved?.canceled) {
-                        throw Error('resolving of context was canceled');
-                    }
-                    return this.setCurrentContext(resolved);
-                } catch (error) {
-                    console.error('failed to resolve context', context, error);
-                    this.#event?.dispatchEvent('onSetContextResolveFailed', {
-                        source: this,
-                        detail: { context, error },
-                    });
-                }
-            }
-            this.#event?.dispatchEvent('onSetContextValidationFailed', {
-                source: this,
-                detail: { context },
-            });
-            throw Error('failed to validate provided context');
-        }
 
-        const onCurrentContextChange = await this.#event?.dispatchEvent('onCurrentContextChange', {
-            source: this,
-            canBubble: true,
-            cancelable: true,
-            detail: { context: context },
+                        return context;
+                    })
+                )
+                .subscribe((context) => {
+                    this.#contextClient.setCurrentContext(context);
+                    subscriber.next(context);
+                    subscriber.complete();
+                });
         });
+    }
 
-        if (onCurrentContextChange?.canceled) {
-            throw Error('change of context was aborted');
-        }
-
-        this.#contextClient.setCurrentContext(context);
-
-        return context;
+    public async setCurrentContextAsync(
+        context: ContextItem<Record<string, unknown>>,
+        opt?: { validate?: boolean; resolve?: boolean }
+    ): Promise<ContextItem<Record<string, unknown>>> {
+        return firstValueFrom(this.setCurrentContext(context, opt));
     }
 
     public queryContext(search: string): Observable<Array<ContextItem>> {
@@ -308,6 +424,7 @@ export class ContextProvider implements IContextProvider {
 
     dispose() {
         this.#subscriptions.unsubscribe();
+        this.#contextClient.dispose();
     }
 }
 

package/src/client/ContextClient.ts

@@ -47,6 +47,10 @@ export class ContextClient extends Observable<ContextItem> {
     public resolveContext(id: string): Observable<ContextItem> {
         return this.#client.query({ id }).pipe(map((x) => x.value));
     }
+
+    public dispose(): void {
+        this.#currentContext$.complete();
+    }
 }
 
 export default ContextClient;

package/src/configurator.ts

@@ -21,6 +21,9 @@ export interface ContextModuleConfig {
     contextType?: string[];
     contextFilter?: ContextFilterFn;
 
+    /** set initial context from parent, will await resolve */
+    skipInitialContext?: boolean;
+
     /**
      * Method for generating context query parameters.
      */

package/src/module.ts

@@ -23,8 +23,21 @@ export const module: ContextModule = {
     initialize: async (args) => {
         const config = await (args.config as ContextModuleConfigurator).createConfig(args);
         const event = args.hasModule('event') ? await args.requireInstance('event') : undefined;
-        const parentContext = (args.ref as ModulesInstance<[ContextModule]>)?.context;
-        return new ContextProvider({ config, event, parentContext });
+        const parentProvider = (args.ref as ModulesInstance<[ContextModule]>)?.context;
+        const provider = new ContextProvider({ config, event, parentContext: parentProvider });
+
+        // TODO add option for skipping this step
+        if (parentProvider) {
+            try {
+                await provider.connectParentContextAsync(parentProvider, {
+                    setCurrent: !config.skipInitialContext,
+                });
+            } catch (err) {
+                console.warn('provider.connectParentContext', 'failed to set parent context', err);
+            }
+        }
+
+        return provider;
     },
 
     dispose: (args) => {