@truenas/api-client 1.0.0 → 1.0.1

package/dist/index.cjs

@@ -710,7 +710,9 @@ var TrueNasConnection = class {
      */
     this.messages$ = this.ws$.pipe(
       rxjs.filter((ws) => ws !== null),
-      rxjs.switchMap((ws) => ws.messages())
+      rxjs.switchMap((ws) => ws.messages().pipe(
+        rxjs.catchError(() => rxjs.EMPTY)
+      ))
     );
     rxjs.combineLatest([
       rxjs.interval(twentySeconds),
@@ -737,11 +739,6 @@ var TrueNasConnection = class {
    *
    * `true` when the lifetime `connectionAttempts` count exceeds `hostnames.length * maxRetry`,
    * OR when an error message is currently set. Ported from the source (tncui) behavior.
-   *
-   * CAVEAT (pre-existing tncui behavior, preserved here): `connectionAttempts` only ever grows —
-   * it is never reset on a successful (re)connection — so over a long-lived connection with
-   * reconnect churn this can latch to `true` even while the connection is currently healthy. For
-   * "is it errored right now?" use the live `hasConnectionError$` observable instead.
    */
   hasExhaustedRetries() {
     const attemptsExhausted = this.connectionAttempts.value > this.hostnames.length * this.maxRetry;
@@ -787,11 +784,14 @@ var TrueNasConnection = class {
    */
   createSocket(hostname) {
     const url = `wss://${hostname}${this.websocketPath}`;
+    let hasOpened = false;
     return new rxjs.Observable((subscriber) => {
       const ws = new TrueNasSocket({
         url,
         openObserver: {
           next: () => {
+            hasOpened = true;
+            this.connectionAttempts.next(0);
             subscriber.next({ ws, hostname });
           }
         },
@@ -821,9 +821,21 @@ var TrueNasConnection = class {
       // retry logic:
       //   * if a connection is not established in 10 seconds, consider that an error
       rxjs.timeout({ first: tenSeconds }),
-      //   * if an error happens, wait `retryDelay` before trying again.
-      //     after `maxRetry` retries, give up.
-      rxjs.retry({ count: this.maxRetry, delay: this.retryDelay })
+      rxjs.retry({
+        //   * while still *establishing*: wait `retryDelay` before trying again, giving up
+        //     after `maxRetry` retries.
+        count: this.maxRetry,
+        //   * we use a custom `delay` function here to ensure no retries are performed
+        //     once a socket is *opened*.
+        //     basically: a later death must propagate out rather than being retried
+        //     so it can be handled by the `connection$` observable.
+        delay: (error) => {
+          if (hasOpened) {
+            return rxjs.throwError(() => error);
+          }
+          return rxjs.timer(this.retryDelay);
+        }
+      })
     );
   }
   /**
@@ -1286,7 +1298,7 @@ var VersionDiscovery = class {
   async fetchVersions(hostname) {
     const url = `https://${hostname}/api/versions`;
     const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), discoveryTimeoutMs);
+    const timer2 = setTimeout(() => controller.abort(), discoveryTimeoutMs);
     try {
       const response = await fetch(url, { signal: controller.signal });
       if (response.status === 404) {
@@ -1307,7 +1319,7 @@ var VersionDiscovery = class {
       }
       return body;
     } finally {
-      clearTimeout(timer);
+      clearTimeout(timer2);
     }
   }
   /**