@truenas/api-client 3.0.6 → 3.0.7

package/dist/index.cjs

@@ -2836,6 +2836,7 @@ var noopLogger = {
 };
 
 // src/utils/truenas-connection.utils.ts
+var policyViolationCloseCode = 1008;
 function isHttpStatusError(reason) {
   return ["404", "502", "503"].some((code) => reason.includes(code));
 }
@@ -2944,7 +2945,25 @@ var TrueNasConnection = class {
       rxjs.switchMap((enabled) => {
         if (enabled) {
           return this.connect().pipe(
-            rxjs.map((conn) => makeActiveConnection(conn.ws, conn.hostname))
+            rxjs.map((conn) => makeActiveConnection(conn.ws, conn.hostname)),
+            // A refusal becomes a value here rather than an error, so it never
+            // reaches the `retry` below and nothing reconnects on its own.
+            //
+            // Handled at this depth on purpose: letting it out completes the
+            // pipeline and unsubscribes `enabledChange$`, and `setEnabled` is the
+            // documented way an app asks for another attempt once the network
+            // changes. Not retrying is a statement about what this client does on
+            // its own; it is not a reason to refuse the caller asking again.
+            rxjs.catchError(
+              (err) => isTerminalClose(err) ? rxjs.of(
+                makeConnectionError(
+                  err.message,
+                  err.hostname,
+                  err.closeCode,
+                  err.closeReason
+                )
+              ) : rxjs.throwError(() => err)
+            )
           );
         }
         return rxjs.of(closedConnection);
@@ -2970,7 +2989,14 @@ var TrueNasConnection = class {
       rxjs.catchError((err) => {
         this.logger.error("All connections failed - retrying", { message: err?.message, hostname: err?.hostname });
         return rxjs.concat(
-          rxjs.of(makeConnectionError(err.message, err.hostname)),
+          rxjs.of(
+            makeConnectionError(
+              err.message,
+              err.hostname,
+              err.closeCode,
+              err.closeReason
+            )
+          ),
           // since this error will immediately get caught by `retry` there's no reason to build a real error.
           rxjs.throwError(() => null)
         );
@@ -3079,6 +3105,11 @@ var TrueNasConnection = class {
   /**
    * enables or disables the connection gate. the app calls this when its `SystemState`
    * changes (mapping `SystemState.Active -> true`, everything else -> `false`).
+   *
+   * This is also how a caller asks for another attempt after the appliance has
+   * refused the client — nothing reconnects on its own from there. The gate is
+   * `distinctUntilChanged`, so re-asserting `true` while it is already `true`
+   * does nothing: the round trip through `false` is what asks again.
    */
   setEnabled(enabled) {
     this.enabled$.next(enabled);
@@ -3136,7 +3167,9 @@ var TrueNasConnection = class {
               errorMessage = getWebSocketError(event.code);
             }
             this.connectionAttempts.next(this.connectionAttempts.value + 1);
-            subscriber.error(makeConnectionError(errorMessage, hostname));
+            subscriber.error(
+              makeConnectionError(errorMessage, hostname, event.code, reason)
+            );
           }
         }
       });
@@ -3186,12 +3219,15 @@ var makeActiveConnection = (ws, hostname) => ({
   hostname,
   state: "active"
 });
-var makeConnectionError = (message, hostname) => ({
+var makeConnectionError = (message, hostname, closeCode, closeReason) => ({
   name: "ConnectionError",
   message,
   hostname,
+  closeCode,
+  closeReason,
   state: "error"
 });
+var isTerminalClose = (err) => err?.closeCode === policyViolationCloseCode;
 var closedConnection = { state: "closed" };
 
 // src/client/truenas-api-client.ts