@masterteam/delegations 0.0.56 → 0.0.57

package/fesm2022/masterteam-delegations.mjs

@@ -10,7 +10,7 @@ import { ModalService } from '@masterteam/components/modal';
 import { ToastService } from '@masterteam/components/toast';
 import { Icon } from '@masterteam/icons';
 import { Popover } from 'primeng/popover';
-import { EMPTY, switchMap, from, finalize, shareReplay, filter, catchError, throwError } from 'rxjs';
+import { EMPTY, switchMap, catchError, from, finalize, shareReplay, filter, throwError } from 'rxjs';
 import { HttpContextToken, HttpContext, HttpClient, HttpParams, HttpHeaders, HttpErrorResponse } from '@angular/common/http';
 import { handleApiRequest, REQUEST_CONTEXT, UserSearchFieldConfig, TextareaFieldConfig, DateFieldConfig, RadioButtonFieldConfig, MultiSelectFieldConfig, ToggleFieldConfig, ValidatorConfig } from '@masterteam/components';
 import { Button } from '@masterteam/components/button';
@@ -53,13 +53,21 @@ class StartDelegationSession {
     }
 }
 /**
- * Re-mint the session the user was in before they reloaded the page. Dispatched
- * by the state itself from the persisted delegation id — never a token.
+ * Re-mint the session the user was in before they reloaded the page, from the
+ * persisted delegation id — never a token.
+ *
+ * Pass `delegation` when the row is already in hand; otherwise the state loads
+ * the candidates itself, so a host can await this action **before** the
+ * authenticated shell mounts and boot straight into delegated mode instead of
+ * loading everything twice.
+ *
+ * Completes quietly when there is nothing to resume or the delegation is no
+ * longer startable — the user simply stays themselves.
  */
 class ResumeDelegationSession {
     delegation;
     static type = '[DelegationSession] Resume';
-    constructor(delegation) {
+    constructor(delegation = null) {
         this.delegation = delegation;
     }
 }
@@ -178,12 +186,6 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
-var DelegationSessionActionKey;
-(function (DelegationSessionActionKey) {
-    DelegationSessionActionKey["LoadCandidates"] = "loadCandidates";
-    DelegationSessionActionKey["StartSession"] = "startSession";
-})(DelegationSessionActionKey || (DelegationSessionActionKey = {}));
-
 const STORAGE_KEY = 'mt.delegation.session-resume.v1';
 /**
  * Lets a delegated session survive a page reload **without persisting the
@@ -271,6 +273,12 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImpor
             args: [{ providedIn: 'root' }]
         }] });
 
+var DelegationSessionActionKey;
+(function (DelegationSessionActionKey) {
+    DelegationSessionActionKey["LoadCandidates"] = "loadCandidates";
+    DelegationSessionActionKey["StartSession"] = "startSession";
+})(DelegationSessionActionKey || (DelegationSessionActionKey = {}));
+
 /** Package-private: raw delegated credentials never enter NGXS or public models. */
 class DelegationTokenVault {
     value = signal(null, ...(ngDevMode ? [{ debugName: "value" }] : /* istanbul ignore next */ []));
@@ -437,37 +445,60 @@ let DelegationSessionState = class DelegationSessionState {
         });
     }
     /**
-     * Re-mints the delegated session the user was in before they reloaded.
+     * Fallback resume for hosts that do not await {@link ResumeDelegationSession}
+     * before mounting their authenticated shell: pick the session back up as soon
+     * as the candidates arrive.
      *
-     * The token itself was never persisted (doc 05); only the delegation id was,
-     * so this is a full `POST .../session` and the backend re-authorizes from
-     * scratch. Attempted at most once per page load — a delegation that has since
-     * expired or been revoked must not retry on every candidate refresh.
+     * Prefer the awaited path — resuming after the shell has already loaded means
+     * every actor-scoped read runs twice, once as the real user and again under
+     * delegated authority.
      */
     tryResume(candidates) {
-        if (this.resumeAttempted) {
+        if (this.resumeAttempted || this.resumeStore.pending() == null) {
             return;
         }
         const delegationId = this.resumeStore.pending();
-        if (delegationId == null) {
-            return;
-        }
         const row = candidates.find((candidate) => candidate.delegationId === delegationId);
-        this.resumeAttempted = true;
         if (!row) {
             // No longer startable (expired, cancelled, scope revoked) — forget it.
+            this.resumeAttempted = true;
             this.resumeStore.clear();
             return;
         }
-        queueMicrotask(() => this.store.dispatch(new ResumeDelegationSession(row)).subscribe({
-            error: () => this.resumeStore.clear(),
-        }));
+        queueMicrotask(() => this.store.dispatch(new ResumeDelegationSession(row)).subscribe());
     }
     resume(ctx, { delegation }) {
-        if (ctx.getState().active) {
+        const delegationId = this.resumeStore.pending();
+        if (ctx.getState().active || delegationId == null) {
             return EMPTY;
         }
-        return this.startSession(ctx, delegation, null, 'ResumeSession');
+        // Claim the attempt up front so the nested candidate load below does not
+        // also fire `tryResume` for the same delegation.
+        this.resumeAttempted = true;
+        const known = delegation?.delegationId === delegationId
+            ? delegation
+            : ctx
+                .getState()
+                .candidates.find((candidate) => candidate.delegationId === delegationId);
+        const start$ = known
+            ? this.startSession(ctx, known, null, 'ResumeSession')
+            : this.store.dispatch(new LoadDelegationCandidates()).pipe(switchMap(() => {
+                const row = ctx
+                    .getState()
+                    .candidates.find((candidate) => candidate.delegationId === delegationId);
+                if (!row) {
+                    // Expired, cancelled, or scope revoked while the tab was closed.
+                    this.resumeStore.clear();
+                    return EMPTY;
+                }
+                return this.startSession(ctx, row, null, 'ResumeSession');
+            }));
+        // A failed resume is not the caller's problem: drop the marker and let the
+        // user carry on as themselves rather than blocking the boot on an error.
+        return start$.pipe(catchError(() => {
+            this.resumeStore.clear();
+            return EMPTY;
+        }));
     }
     start(ctx, { delegation }) {
         const previous = ctx.getState().active;
@@ -611,6 +642,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "21.2.8", ngImpor
 class DelegationSessionFacade {
     store = inject(Store);
     promptReceipts = inject(DelegationPromptReceiptService);
+    resumeStore = inject(DelegationSessionResumeStore);
     endInFlight = null;
     // ---------------------------------------------------------------------------
     // Data slices
@@ -654,6 +686,23 @@ class DelegationSessionFacade {
     claimPromptCandidates(candidates) {
         return this.promptReceipts.claimUnseen(candidates);
     }
+    /**
+     * True when a previous session is waiting to be re-minted after a reload.
+     * Synchronous (a `localStorage` read), so a route guard can check it without
+     * paying for a round-trip on the overwhelmingly common no-delegation boot.
+     */
+    hasPendingResume() {
+        return this.resumeStore.pending() != null;
+    }
+    /**
+     * Re-mints the delegated session the user reloaded out of, and completes when
+     * delegated mode is in force (or when there is nothing to resume). Await this
+     * **before** mounting the authenticated shell so its reads run once, already
+     * delegated.
+     */
+    resumeSession() {
+        return this.store.dispatch(new ResumeDelegationSession());
+    }
     startSession(delegation) {
         return this.store.dispatch(new StartDelegationSession(delegation));
     }