@equinor/fusion-framework-module-context 4.0.2 → 4.0.4

package/dist/types/ContextProvider.d.ts

@@ -50,6 +50,10 @@ export declare class ContextProvider implements IContextProvider {
         validate?: boolean;
         resolve?: boolean;
     }): Observable<T>;
+    protected _setCurrentContext<T extends ContextItem<Record<string, unknown>> | null>(context: T, opt?: {
+        validate?: boolean;
+        resolve?: boolean;
+    }): Observable<T>;
     setCurrentContextAsync<T extends ContextItem<Record<string, unknown>> | null>(context: T, opt?: {
         validate?: boolean;
         resolve?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@equinor/fusion-framework-module-context",
-    "version": "4.0.2",
+    "version": "4.0.4",
     "description": "",
     "main": "./dist/esm/index.js",
     "exports": {
@@ -49,5 +49,5 @@
         "@equinor/fusion-framework-module": ">=1.2.5",
         "rxjs": "^7.5.7"
     },
-    "gitHead": "3cd1a9e01c56fc9afb72f2df474a7b066b4215c4"
+    "gitHead": "b369a37e2b205b8d91d9b9a8907195f7f673a344"
 }

package/src/ContextProvider.ts

@@ -1,13 +1,14 @@
+import { EMPTY, lastValueFrom, Observable, of, Subject, Subscription, throwError } from 'rxjs';
 import {
-    EMPTY,
-    firstValueFrom,
-    lastValueFrom,
-    Observable,
-    of,
-    Subscription,
-    throwError,
-} from 'rxjs';
-import { catchError, filter, map, pairwise, switchMap } from 'rxjs/operators';
+    catchError,
+    filter,
+    finalize,
+    map,
+    pairwise,
+    switchMap,
+    takeUntil,
+    tap,
+} from 'rxjs/operators';
 
 import { ContextModuleConfig } from './configurator';
 
@@ -73,6 +74,8 @@ export class ContextProvider implements IContextProvider {
     #contextFilter: ContextModuleConfig['contextFilter'];
     #contextParameterFn: Required<ContextModuleConfig['contextParameterFn']>;
 
+    #contextQueue = new Subject<Observable<ContextItem<Record<string, unknown>>>>();
+
     public get contextClient() {
         return this.#contextClient;
     }
@@ -159,6 +162,15 @@ export class ContextProvider implements IContextProvider {
                 })
             );
         }
+
+        this.#subscriptions.add(
+            this.#contextQueue
+                .pipe(
+                    switchMap((next) => next),
+                    tap((x) => console.debug('ContextProvider::#contextQueue', x))
+                )
+                .subscribe((context) => this.#contextClient.setCurrentContext(context ?? null))
+        );
     }
 
     public connectParentContext(
@@ -167,7 +179,7 @@ export class ContextProvider implements IContextProvider {
     ): Subscription {
         const parentContext$ = provider.currentContext$.pipe(
             // do not set context if parent has not initialized
-            filter((x) => x !== undefined),
+            filter((x): x is ContextItem | null => x !== undefined),
             filter((next, index) => {
                 if (opt?.skipFirst && index <= 1) {
                     console.debug(
@@ -177,7 +189,7 @@ export class ContextProvider implements IContextProvider {
                     );
                     return false;
                 }
-                return this.currentContext !== next;
+                return this.currentContext?.id !== next?.id;
             }),
             switchMap(async (next) => {
                 if (next) {
@@ -195,10 +207,6 @@ export class ContextProvider implements IContextProvider {
             }),
             filter((x) => !x.canceled),
             switchMap(({ next }) => {
-                if (!next) {
-                    this.clearCurrentContext();
-                    return EMPTY;
-                }
                 return this.setCurrentContext(next, {
                     validate: true,
                     resolve: true,
@@ -241,12 +249,58 @@ export class ContextProvider implements IContextProvider {
     }
 
     public setCurrentContextByIdAsync(id: string): Promise<ContextItem<Record<string, unknown>>> {
-        return firstValueFrom(this.setCurrentContextById(id));
+        return lastValueFrom(this.setCurrentContextById(id));
     }
 
+    /**
+     * Setting context is a complex operation, and might not happen immediately.
+     * When setting the context, a task is created and added to the queue.
+     * Once the task is completed, the returned observable will emit the value which will be the next state.
+     *
+     * Even tho this function returns a `Observable`, the task will be queued even tho nobody subscribes.
+     *
+     * If the observable is subscribe, unsubscribing __WILL__ abort the task and remove it from queue
+     *
+     * @param context context item which would be queue to set as current
+     */
     public setCurrentContext<T extends ContextItem<Record<string, unknown>> | null>(
         context: T,
         opt?: { validate?: boolean; resolve?: boolean }
+    ): Observable<T> {
+        /** signal for aborting the queue entry */
+        const abort$ = new Subject();
+
+        /** wrapper for returning an observable to the caller */
+        const subject$ = new Subject<T>();
+
+        const task$ = this._setCurrentContext(context, opt).pipe(
+            /** send context item which was set to the caller */
+            tap((x) => subject$.next(x)),
+            /** abort task on signal */
+            takeUntil(abort$),
+            /** close observable sent to caller */
+            finalize(() => subject$.complete()),
+            /** catch errors to not stall queue  */
+            catchError((err) => {
+                /** send the error to the caller  */
+                subject$.error(err);
+                /** skip setting any context */
+                return EMPTY;
+            })
+        );
+
+        /** add task to internal queue */
+        this.#contextQueue.next(task$ as Observable<ContextItem<Record<string, unknown>>>);
+
+        return subject$.pipe(
+            /** if caller subscribes, unsubscribe should abort queue entry */
+            finalize(() => abort$.next(true))
+        );
+    }
+
+    protected _setCurrentContext<T extends ContextItem<Record<string, unknown>> | null>(
+        context: T,
+        opt?: { validate?: boolean; resolve?: boolean }
     ): Observable<T> {
         return new Observable((subscriber) => {
             if (context === this.currentContext) {
@@ -331,7 +385,6 @@ export class ContextProvider implements IContextProvider {
                     })
                 )
                 .subscribe((context) => {
-                    this.#contextClient.setCurrentContext(context ?? null);
                     subscriber.next(context);
                     subscriber.complete();
                 });
@@ -342,7 +395,7 @@ export class ContextProvider implements IContextProvider {
         context: T,
         opt?: { validate?: boolean; resolve?: boolean }
     ): Promise<T> {
-        return firstValueFrom(this.setCurrentContext(context, opt));
+        return lastValueFrom(this.setCurrentContext(context, opt));
     }
 
     public queryContext(search: string): Observable<Array<ContextItem>> {
@@ -422,8 +475,8 @@ export class ContextProvider implements IContextProvider {
         return lastValueFrom(this.relatedContexts(args));
     }
 
-    public clearCurrentContext() {
-        this.setCurrentContextAsync(null);
+    public clearCurrentContext(): void {
+        this.setCurrentContext(null);
     }
 
     dispose() {

package/src/module.ts

@@ -68,9 +68,7 @@ export const module: ContextModule = {
                             },
                             complete: () => {
                                 // TODO - do we need to check first?
-                                provider.connectParentContext(parentProvider, {
-                                    skipFirst: !!provider.currentContext,
-                                });
+                                provider.connectParentContext(parentProvider);
                                 subscriber.complete();
                             },
                         })