@arsedizioni/ars-utils 22.5.14 → 22.5.16

package/fesm2022/arsedizioni-ars-utils-evolution.common.mjs

@@ -516,6 +516,19 @@ function isAuthEndpoint(url) {
         || url.includes('/passkeys/request-options')
         || url.includes('/passkeys/login');
 }
+/**
+ * Returns whether the URL is the silent link probe, whose failures must never reach the user.
+ *
+ * `/session/status` runs unconditionally at every bootstrap, including for users who never linked
+ * Evolution at all. When the API is unreachable, reporting that failure would show "Evolution non è
+ * disponibile" to somebody who never asked Evolution for anything: the error is still rethrown for
+ * the caller to observe, but nothing is broadcast.
+ * @param url - The request URL.
+ * @returns True when the URL is the status probe.
+ */
+function isStatusProbe(url) {
+    return url.includes('/session/status');
+}
 /**
  * Resolves the user-facing message for a failed request.
  * @param error - The raw HTTP error object.
@@ -641,7 +654,11 @@ function evolutionAuthInterceptor(serviceUri, flags = EvolutionServiceFlags.None
             // at all. Everything that gets here is an Evolution request anyway: the others returned
             // before the pipe was built.
             const errorStatus = parseInt(error?.status ?? '0');
-            if (errorStatus === 401 && !isAuthEndpoint(authenticatedRequest.url)) {
+            if (isStatusProbe(authenticatedRequest.url)) {
+                // The silent probe stays silent: its caller reads the outcome from the rethrown error,
+                // nobody else needs to hear about it.
+            }
+            else if (errorStatus === 401 && !isAuthEndpoint(authenticatedRequest.url)) {
                 // Expired or invalidated session on an authenticated request. Notified once: several
                 // in-flight requests failing together is how a single expiry becomes a wall of dialogs.
                 if (!sessionExpiredNotified) {
@@ -741,6 +758,11 @@ class CoreService {
         }
         return this._loginInfo;
     }
+    /**
+     * Gets the signed-in account.
+     * @returns The current {@link EvolutionUserInfo}, or `undefined` when there is no session.
+     */
+    get user() { return this.loginInfo?.context; }
     /**
      * Sets the logged-in state.
      * @param value - The new logged-in value.
@@ -895,7 +917,7 @@ class LoginService {
      * Gets the signed-in account with its licence context.
      * @returns The current {@link EvolutionUserInfo}, or undefined when there is no session.
      */
-    get user() { return this.core.loginInfo?.context; }
+    get user() { return this.core.user; }
     /** `true` when this browser has a session the API has accepted. */
     get loggedIn() { return this.core.loggedIn; }
     /** `true` while an authentication is in flight. */
@@ -925,8 +947,8 @@ class LoginService {
     clear() { this.core.clear(); }
     // ── Lifecycle ───────────────────────────────────────────────────────────────
     /**
-     * Initialises the service with the back-end URI and optional feature flags, and revalidates a
-     * session that survived a page refresh instead of assuming it is still there.
+     * Initialises the service with the back-end URI and optional feature flags, and asks the API — the
+     * only party that can read the HttpOnly cookie — whether this browser still holds a session.
      *
      * Must be called once during application bootstrap, before any other method. What it used to do
      * on a refresh was announce `LOGIN_COMPLETED` on the strength of a value in local storage; the
@@ -950,12 +972,13 @@ class LoginService {
                 this.handleBroadcastMessage(message);
             });
         }
-        // A stored context means this browser signed in at some point, never that the session is still
-        // alive: the API is the only one that knows, and it is asked here.
-        if (this.core.loggedIn()) {
-            this.core.loggingIn.set(true);
-            this.restoreSession();
-        }
+        // The probe runs UNCONDITIONALLY, where it used to run only when a stored context existed. The
+        // stored context is just a hint -- "this browser signed in at some point" -- and the cookie can
+        // outlive it: local storage cleared while the month-long cookie stayed put made this library
+        // declare "no link" with a perfectly valid session in the browser. The API is the only one that
+        // knows, and it is asked every time.
+        this.core.loggingIn.set(true);
+        this.restoreSession();
     }
     /**
      * Dispatches an incoming broadcast message to the appropriate handler.
@@ -1046,6 +1069,18 @@ class LoginService {
             return r;
         }));
     }
+    /**
+     * Asks the API whether this browser holds a live session, without ever failing with a 401: the
+     * route is anonymous and answers `connected: false` to a caller with no session. This is the one
+     * honest way to know the link state -- the auth cookie is HttpOnly and belongs to the API's host,
+     * so it cannot be read from here, and its presence would prove nothing anyway, since the session
+     * also lives server-side and may have been revoked or evicted.
+     * @returns An observable that emits the `ApiResult<EvolutionSessionStatus>`.
+     */
+    status() {
+        return this.httpClient
+            .get(this.core.serviceUri + '/session/status');
+    }
     /**
      * Reads the current session from the server, which resolves it from the auth cookie's claims.
      * Used to restore the state after a page refresh instead of trusting what local storage holds.
@@ -1068,25 +1103,49 @@ class LoginService {
         }));
     }
     /**
-     * Asks `/session/me` whether the restored session is still alive, and announces the login when it
-     * is.
+     * Asks `/session/status` whether this browser holds a live session, and hydrates the context
+     * through {@link me} when it does.
+     *
+     * The probe is silent by construction: `/session/status` never answers 401, so a visitor who
+     * never signed in -- or a cookie whose session has died -- comes back as `connected: false` with
+     * no error broadcast and no dialog. Only then is the stale stored context cleared, so the
+     * `loggedIn` signal tells the truth at every bootstrap.
      *
-     * Nothing is cleared on failure, and that is deliberate: a failure here is not proof of a dead
-     * session -- the API may be unreachable, the proxy may have answered 502, the device may be
-     * offline -- and clearing on any of those would sign the user out with a perfectly valid cookie.
-     * A genuine 401 is a different matter and the interceptor has already reported it.
+     * Nothing is cleared on a transport failure, and that is deliberate: an unreachable API is not
+     * proof of a dead session -- the proxy may have answered 502, the device may be offline -- and
+     * clearing on any of those would sign the user out with a perfectly valid cookie.
      * @returns void
      */
     restoreSession() {
-        this.me()
-            .pipe(finalize(() => this.core.loggingIn.set(false)))
+        // Whether the probe handed over to `/session/me`, which then owns lowering `loggingIn`.
+        let restoring = false;
+        this.status()
+            .pipe(finalize(() => { if (!restoring) {
+            this.core.loggingIn.set(false);
+        } }))
             .subscribe({
             next: r => {
-                if (r?.success) {
-                    this.broadcastService.sendMessage(EvolutionMessages.LOGIN_COMPLETED);
+                if (r?.success && r.value?.connected) {
+                    restoring = true;
+                    this.me()
+                        .pipe(finalize(() => this.core.loggingIn.set(false)))
+                        .subscribe({
+                        next: m => {
+                            if (m?.success) {
+                                this.broadcastService.sendMessage(EvolutionMessages.LOGIN_COMPLETED);
+                            }
+                        },
+                        // Consumed so the rethrown error is not reported a second time as an unhandled one.
+                        error: () => { }
+                    });
+                }
+                else if (this.core.loggedIn()) {
+                    // The stored context outlived its session: drop it, or the next bootstrap would keep
+                    // claiming a session that is gone.
+                    this.core.clear();
                 }
             },
-            // Consumed so the rethrown error is not reported a second time as an unhandled one.
+            // Transport failure: keep the stored hint, the next bootstrap will ask again.
             error: () => { }
         });
     }
@@ -1322,7 +1381,7 @@ class AccountService {
      * @returns An observable that emits `ApiResult<EvolutionUserInfo>`.
      */
     refreshLicence() {
-        return this.httpClient.get(this.core.serviceUri + '/account/licenses/refresh/' + (this.core.loginInfo?.context?.userId ?? -1));
+        return this.httpClient.get(this.core.serviceUri + '/account/licenses/refresh/' + (this.core.user?.userId ?? -1));
     }
     static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.1.3", ngImport: i0, type: AccountService, deps: [], target: i0.ɵɵFactoryTarget.Service }); }
     static { this.ɵprov = i0.ɵɵngDeclareService({ minVersion: "22.0.0", version: "22.1.3", ngImport: i0, type: AccountService }); }
@@ -1376,11 +1435,12 @@ class EvolutionService {
      * Gets the signed-in account with its licence context.
      * @returns The current {@link EvolutionUserInfo}, or undefined when there is no session.
      */
-    get user() { return this.core.loginInfo?.context; }
+    get user() { return this.core.user; }
     /**
      * `true` when this browser has a session the API has accepted. It starts from the stored context
-     * and is confirmed -- or left to the interceptor's 401 handling -- by the `/session/me` call
-     * {@link initialize} makes.
+     * and is settled -- raised or cleared -- by the silent `/session/status` probe {@link initialize}
+     * makes, which is the one honest way to read a state that lives in an HttpOnly cookie plus a
+     * server-side lease. This signal IS the link state: bind it, do not poll it.
      */
     get loggedIn() { return this.core.loggedIn; }
     /** `true` while an authentication is in flight. */