@truenas/api-client 1.0.0 → 1.0.1

package/dist/index.d.cts

@@ -1993,11 +1993,6 @@ declare class TrueNasConnection {
      *
      * `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(): boolean;
     /**

package/dist/index.d.ts

@@ -1993,11 +1993,6 @@ declare class TrueNasConnection {
      *
      * `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(): boolean;
     /**

package/dist/index.js

@@ -1,4 +1,4 @@
-import { switchMap, map, toArray, concat, from, defer, throwError, firstValueFrom, BehaviorSubject, Subject, distinctUntilChanged, of, filter, take, catchError as catchError$1, retry, startWith, shareReplay as shareReplay$1, takeUntil, combineLatest, interval, Observable, timeout, race, tap, share, takeWhile, merge, finalize } from 'rxjs';
+import { switchMap, map, toArray, concat, from, defer, throwError, firstValueFrom, BehaviorSubject, Subject, distinctUntilChanged, of, filter, take, catchError as catchError$1, retry, startWith, shareReplay as shareReplay$1, takeUntil, EMPTY, combineLatest, interval, Observable, timeout, timer, race, tap, share, takeWhile, merge, finalize } from 'rxjs';
 import { webSocket } from 'rxjs/webSocket';
 import { map as map$1, catchError, shareReplay } from 'rxjs/operators';
 
@@ -708,7 +708,9 @@ var TrueNasConnection = class {
      */
     this.messages$ = this.ws$.pipe(
       filter((ws) => ws !== null),
-      switchMap((ws) => ws.messages())
+      switchMap((ws) => ws.messages().pipe(
+        catchError$1(() => EMPTY)
+      ))
     );
     combineLatest([
       interval(twentySeconds),
@@ -735,11 +737,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;
@@ -785,11 +782,14 @@ var TrueNasConnection = class {
    */
   createSocket(hostname) {
     const url = `wss://${hostname}${this.websocketPath}`;
+    let hasOpened = false;
     return new Observable((subscriber) => {
       const ws = new TrueNasSocket({
         url,
         openObserver: {
           next: () => {
+            hasOpened = true;
+            this.connectionAttempts.next(0);
             subscriber.next({ ws, hostname });
           }
         },
@@ -819,9 +819,21 @@ var TrueNasConnection = class {
       // retry logic:
       //   * if a connection is not established in 10 seconds, consider that an error
       timeout({ first: tenSeconds }),
-      //   * if an error happens, wait `retryDelay` before trying again.
-      //     after `maxRetry` retries, give up.
-      retry({ count: this.maxRetry, delay: this.retryDelay })
+      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 throwError(() => error);
+          }
+          return timer(this.retryDelay);
+        }
+      })
     );
   }
   /**
@@ -1284,7 +1296,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) {
@@ -1305,7 +1317,7 @@ var VersionDiscovery = class {
       }
       return body;
     } finally {
-      clearTimeout(timer);
+      clearTimeout(timer2);
     }
   }
   /**