@truenas/api-client 3.0.6 → 3.0.7

package/dist/index.d.cts

@@ -12476,6 +12476,14 @@ interface ActiveConnection {
 }
 interface ConnectionError extends Error {
     hostname?: string;
+    /** The WebSocket close code, when the failure came from a close rather than a timeout. */
+    closeCode?: number;
+    /**
+     * The server's own reason text, verbatim. `message` is this client's rendering
+     * of the code and loses what the appliance actually said — for a policy close
+     * that is the difference between "policy violation" and which policy.
+     */
+    closeReason?: string;
 }
 type Connection = ActiveConnection & {
     state: 'active';
@@ -12568,6 +12576,11 @@ declare class TrueNasConnection {
     /**
      * 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: boolean): void;
     /**

package/dist/index.d.ts

@@ -12476,6 +12476,14 @@ interface ActiveConnection {
 }
 interface ConnectionError extends Error {
     hostname?: string;
+    /** The WebSocket close code, when the failure came from a close rather than a timeout. */
+    closeCode?: number;
+    /**
+     * The server's own reason text, verbatim. `message` is this client's rendering
+     * of the code and loses what the appliance actually said — for a policy close
+     * that is the difference between "policy violation" and which policy.
+     */
+    closeReason?: string;
 }
 type Connection = ActiveConnection & {
     state: 'active';
@@ -12568,6 +12576,11 @@ declare class TrueNasConnection {
     /**
      * 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: boolean): void;
     /**

package/dist/index.js

@@ -1,4 +1,4 @@
-import { map, toArray, switchMap, 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, finalize, merge, takeWhile } from 'rxjs';
+import { map, toArray, switchMap, concat, from, defer, throwError, firstValueFrom, BehaviorSubject, Subject, distinctUntilChanged, catchError as catchError$1, of, filter, take, retry, startWith, shareReplay as shareReplay$1, takeUntil, EMPTY, combineLatest, interval, Observable, timeout, timer, race, tap, share, finalize, merge, takeWhile } from 'rxjs';
 import { webSocket } from 'rxjs/webSocket';
 import { map as map$1, catchError, shareReplay } from 'rxjs/operators';
 
@@ -2834,6 +2834,7 @@ var noopLogger = {
 };
 
 // src/utils/truenas-connection.utils.ts
+var policyViolationCloseCode = 1008;
 function isHttpStatusError(reason) {
   return ["404", "502", "503"].some((code) => reason.includes(code));
 }
@@ -2942,7 +2943,25 @@ var TrueNasConnection = class {
       switchMap((enabled) => {
         if (enabled) {
           return this.connect().pipe(
-            map((conn) => makeActiveConnection(conn.ws, conn.hostname))
+            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.
+            catchError$1(
+              (err) => isTerminalClose(err) ? of(
+                makeConnectionError(
+                  err.message,
+                  err.hostname,
+                  err.closeCode,
+                  err.closeReason
+                )
+              ) : throwError(() => err)
+            )
           );
         }
         return of(closedConnection);
@@ -2968,7 +2987,14 @@ var TrueNasConnection = class {
       catchError$1((err) => {
         this.logger.error("All connections failed - retrying", { message: err?.message, hostname: err?.hostname });
         return concat(
-          of(makeConnectionError(err.message, err.hostname)),
+          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.
           throwError(() => null)
         );
@@ -3077,6 +3103,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);
@@ -3134,7 +3165,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)
+            );
           }
         }
       });
@@ -3184,12 +3217,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