@holochain/client 0.20.4-rc.0 → 0.20.5

package/lib/api/client.d.ts

@@ -23,6 +23,7 @@ export declare class WsClient extends Emittery {
     private pendingRequests;
     private index;
     private authenticationToken;
+    private reconnectPromise;
     constructor(socket: IsoWebSocket, url?: URL, options?: WsClientOptions);
     /**
      * Instance factory for creating WsClients.
@@ -53,8 +54,21 @@ export declare class WsClient extends Emittery {
     /**
      * Send requests to the connected websocket.
      *
+     * If the underlying socket is closed when this method is called, the
+     * client transparently reconnects and re-authenticates using the cached
+     * token. Transient reconnect errors are surfaced as a `ConnectionError`
+     * and the cached token is retained, so a subsequent call can retry the
+     * reconnect.
+     *
+     * If the conductor rejects the cached token during the reconnect
+     * (signalled by an immediate close after the `authenticate` handshake),
+     * the cached token is cleared and the call rejects with an
+     * `InvalidTokenError`. The consumer must rebuild the `AppWebsocket`
+     * with a fresh token; further calls on this client will reject with
+     * `WebsocketClosedError`.
+     *
      * @param request - The request to send over the websocket.
-     * @returns
+     * @returns The decoded response payload.
      */
     request<Response>(request: unknown): Promise<Response>;
     private exchange;

package/lib/api/client.js

@@ -19,6 +19,7 @@ export class WsClient extends Emittery {
     pendingRequests;
     index;
     authenticationToken;
+    reconnectPromise;
     constructor(socket, url, options) {
         super();
         this.registerMessageListener(socket);
@@ -100,8 +101,21 @@ export class WsClient extends Emittery {
     /**
      * Send requests to the connected websocket.
      *
+     * If the underlying socket is closed when this method is called, the
+     * client transparently reconnects and re-authenticates using the cached
+     * token. Transient reconnect errors are surfaced as a `ConnectionError`
+     * and the cached token is retained, so a subsequent call can retry the
+     * reconnect.
+     *
+     * If the conductor rejects the cached token during the reconnect
+     * (signalled by an immediate close after the `authenticate` handshake),
+     * the cached token is cleared and the call rejects with an
+     * `InvalidTokenError`. The consumer must rebuild the `AppWebsocket`
+     * with a fresh token; further calls on this client will reject with
+     * `WebsocketClosedError`.
+     *
      * @param request - The request to send over the websocket.
-     * @returns
+     * @returns The decoded response payload.
      */
     async request(request) {
         return this.exchange(request, this.sendMessage.bind(this));
@@ -114,7 +128,15 @@ export class WsClient extends Emittery {
             return promise;
         }
         else if (this.url && this.authenticationToken) {
-            await this.reconnectWebsocket(this.url, this.authenticationToken);
+            // Dedupe concurrent reconnect attempts. The first caller into this
+            // branch starts a single reconnect; further callers await the same
+            // promise so we never create multiple sockets in parallel.
+            if (!this.reconnectPromise) {
+                this.reconnectPromise = this.reconnectWebsocket(this.url, this.authenticationToken).finally(() => {
+                    this.reconnectPromise = undefined;
+                });
+            }
+            await this.reconnectPromise;
             this.registerMessageListener(this.socket);
             this.registerCloseListener(this.socket);
             const promise = new Promise((resolve, reject) => sendHandler(request, resolve, reject));
@@ -204,19 +226,28 @@ export class WsClient extends Emittery {
     async reconnectWebsocket(url, token) {
         return new Promise((resolve, reject) => {
             this.socket = new IsoWebSocket(url, this.options);
+            // Track whether the "open" event has fired. The invalidTokenCloseListener
+            // must only clear the token when the connection did open and the conductor
+            // then closed it quickly.
+            let openFired = false;
             // This error event never occurs in tests. Could be removed?
             this.socket.addEventListener("error", (errorEvent) => {
-                this.authenticationToken = undefined;
                 reject(new HolochainError("ConnectionError", `could not connect to Holochain Conductor API at ${url} - ${errorEvent.message}`));
             }, { once: true });
             const invalidTokenCloseListener = (closeEvent) => {
-                this.authenticationToken = undefined;
-                reject(new HolochainError("InvalidTokenError", `could not connect to ${this.url} due to an invalid app authentication token - close code ${closeEvent.code}`));
+                if (openFired) {
+                    this.authenticationToken = undefined;
+                    reject(new HolochainError("InvalidTokenError", `could not connect to ${this.url} due to an invalid app authentication token - close code ${closeEvent.code}`));
+                }
+                else {
+                    reject(new HolochainError("ConnectionError", `could not connect to Holochain Conductor API at ${url} - close code ${closeEvent.code}`));
+                }
             };
             this.socket.addEventListener("close", invalidTokenCloseListener, {
                 once: true,
             });
             this.socket.addEventListener("open", async () => {
+                openFired = true;
                 const encodedMsg = encode({
                     type: "authenticate",
                     data: encode({ token }),

package/lib/api/zome-call-signing.d.ts

@@ -1,10 +1,21 @@
-import { type KeyPair } from "libsodium-wrappers";
 import type { CapSecret } from "../hdk/capabilities.js";
 import type { AgentPubKey, CellId } from "../types.js";
 /**
  * @public
  */
 export type Nonce256Bit = Uint8Array;
+/**
+ * @public
+ */
+export declare const _kp: () => {
+    publicKey: Uint8Array;
+    privateKey: Uint8Array;
+    keyType: string;
+};
+/**
+ * @public
+ */
+export type KeyPair = ReturnType<typeof _kp>;
 /**
  * @public
  */

package/lib/api/zome-call-signing.js

@@ -1,5 +1,9 @@
 import _sodium from "libsodium-wrappers";
 import { encodeHashToBase64 } from "../utils/base64.js";
+/**
+ * @public
+ */
+export const _kp = () => _sodium.crypto_sign_keypair();
 const signingCredentials = new Map();
 /**
  * Get credentials for signing zome calls.

package/lib/hdk/validation-receipts.d.ts

@@ -1,4 +1,4 @@
-import { AgentPubKey, DhtOpHash, Timestamp } from "../types";
+import { AgentPubKey, DhtOpHash, Timestamp } from "../types.js";
 /**
  * @public
  */

package/lib/tsdoc-metadata.json

@@ -5,7 +5,7 @@
   "toolPackages": [
     {
       "packageName": "@microsoft/api-extractor",
-      "packageVersion": "7.55.1"
+      "packageVersion": "7.58.7"
     }
   ]
 }

package/lib/utils/holo-hash-map.d.ts

@@ -122,7 +122,7 @@ export declare class HoloHashMap<K extends HoloHash, V> implements Map<K, V> {
      * @param thisArg - Optional value to use as 'this' when executing the callback
      */
     forEach(callbackfn: (value: V, key: K, map: Map<K, V>) => void, thisArg?: any): void;
-    [Symbol.iterator](): IterableIterator<[K, V]>;
+    [Symbol.iterator](): MapIterator<[K, V]>;
     get [Symbol.toStringTag](): string;
     /**
      * The number of entries in the map.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holochain/client",
-  "version": "0.20.4-rc.0",
+  "version": "0.20.5",
   "description": "A JavaScript client for the Holochain Conductor API",
   "author": "Holochain Foundation <info@holochain.org> (https://holochain.org)",
   "license": "CAL-1.0",
@@ -48,7 +48,7 @@
     "isomorphic-ws": "^5.0.0",
     "js-base64": "^3.7.8",
     "js-sha512": "^0.9.0",
-    "libsodium-wrappers": "^0.8",
+    "libsodium-wrappers": "^0.8.4",
     "lodash-es": "^4.17.21",
     "ws": "^8.18.3"
   },