@holochain/client 0.14.1 → 0.15.0

package/lib/api/admin/websocket.d.ts

@@ -25,7 +25,7 @@ export declare class AdminWebsocket implements AdminApi {
      * @param defaultTimeout - The default timeout for any request.
      * @returns A promise for a new connected instance.
      */
-    static connect(url: string, defaultTimeout?: number): Promise<AdminWebsocket>;
+    static connect(url: URL, defaultTimeout?: number): Promise<AdminWebsocket>;
     _requester<ReqI, ReqO, ResI, ResO>(tag: string, transformer?: Transformer<ReqI, ReqO, ResI, ResO>): (req: ReqI, timeout?: number | undefined) => Promise<ResO>;
     /**
      * Send a request to open the given port for {@link AppWebsocket} connections.

package/lib/api/admin/websocket.js

@@ -34,7 +34,7 @@ export class AdminWebsocket {
         // Check if we are in the launcher's environment, and if so, redirect the url to connect to
         const env = getLauncherEnvironment();
         if (env?.ADMIN_INTERFACE_PORT) {
-            url = `ws://127.0.0.1:${env.ADMIN_INTERFACE_PORT}`;
+            url = new URL(`ws://127.0.0.1:${env.ADMIN_INTERFACE_PORT}`);
         }
         const wsClient = await WsClient.connect(url);
         return new AdminWebsocket(wsClient, defaultTimeout);

package/lib/api/app/websocket.d.ts

@@ -23,7 +23,7 @@ export declare class AppWebsocket extends Emittery implements AppApi {
      * @param defaultTimeout - Timeout to default to for all operations.
      * @returns A new instance of an AppWebsocket.
      */
-    static connect(url: string, defaultTimeout?: number): Promise<AppWebsocket>;
+    static connect(url: URL, defaultTimeout?: number): Promise<AppWebsocket>;
     _requester<ReqI, ReqO, ResI, ResO>(tag: string, transformer?: Transformer<ReqI, ReqO, ResI, ResO>): (req: ReqI, timeout?: number | undefined) => Promise<ResO>;
     /**
      * Request the app's info, including all cell infos.

package/lib/api/app/websocket.js

@@ -35,7 +35,7 @@ export class AppWebsocket extends Emittery {
         // Check if we are in the launcher's environment, and if so, redirect the url to connect to
         const env = getLauncherEnvironment();
         if (env?.APP_INTERFACE_PORT) {
-            url = `ws://127.0.0.1:${env.APP_INTERFACE_PORT}`;
+            url = new URL(`ws://127.0.0.1:${env.APP_INTERFACE_PORT}`);
         }
         const wsClient = await WsClient.connect(url);
         const appWebsocket = new AppWebsocket(wsClient, defaultTimeout, env?.INSTALLED_APP_ID);

package/lib/api/app-agent/websocket.d.ts

@@ -31,7 +31,7 @@ export declare class AppAgentWebsocket implements AppAgentClient {
      * @param defaultTimeout - Timeout to default to for all operations.
      * @returns A new instance of an AppAgentWebsocket.
      */
-    static connect(url: string, installed_app_id: InstalledAppId, defaultTimeout?: number): Promise<AppAgentWebsocket>;
+    static connect(url: URL, installed_app_id: InstalledAppId, defaultTimeout?: number): Promise<AppAgentWebsocket>;
     /**
      * Get a cell id by its role name or clone id.
      *

package/lib/api/client.d.ts

@@ -1,30 +1,29 @@
 /// <reference types="ws" />
-import { decode } from "@msgpack/msgpack";
 import Emittery from "emittery";
 import IsoWebSocket from "isomorphic-ws";
 /**
  * A WebSocket client which can make requests and receive responses,
  * as well as send and receive signals.
  *
- * Uses Holochain's websocket WireMessage for communication.
+ * Uses Holochain's WireMessage for communication.
  *
  * @public
  */
 export declare class WsClient extends Emittery {
     socket: IsoWebSocket;
-    pendingRequests: Record<number, {
-        resolve: (msg: unknown) => ReturnType<typeof decode>;
-        reject: (error: Error) => void;
-    }>;
+    url: URL | undefined;
+    private pendingRequests;
     index: number;
-    constructor(socket: IsoWebSocket);
+    private connectRetries;
+    constructor(socket: IsoWebSocket, url: URL);
+    private setupSocket;
     /**
      * Instance factory for creating WsClients.
      *
-     * @param url - The `ws://` URL to connect to.
+     * @param url - The WebSocket URL to connect to.
      * @returns An new instance of the WsClient.
      */
-    static connect(url: string): Promise<WsClient>;
+    static connect(url: URL): Promise<WsClient>;
     /**
      * Sends data as a signal.
      *
@@ -37,7 +36,8 @@ export declare class WsClient extends Emittery {
      * @param request - The request to send over the websocket.
      * @returns
      */
-    request<Req, Res>(request: Req): Promise<Res>;
+    request<Response>(request: unknown): Promise<Response>;
+    private sendMessage;
     private handleResponse;
     /**
      * Close the websocket connection.

package/lib/api/client.js

@@ -6,20 +6,27 @@ import { SignalType } from "./app/types.js";
  * A WebSocket client which can make requests and receive responses,
  * as well as send and receive signals.
  *
- * Uses Holochain's websocket WireMessage for communication.
+ * Uses Holochain's WireMessage for communication.
  *
  * @public
  */
 export class WsClient extends Emittery {
     socket;
+    url;
     pendingRequests;
     index;
-    constructor(socket) {
+    connectRetries;
+    constructor(socket, url) {
         super();
         this.socket = socket;
+        this.url = url;
         this.pendingRequests = {};
         this.index = 0;
-        socket.onmessage = async (serializedMessage) => {
+        this.connectRetries = 0;
+        this.setupSocket();
+    }
+    setupSocket() {
+        this.socket.onmessage = async (serializedMessage) => {
             // If data is not a buffer (nodejs), it will be a blob (browser)
             let deserializedData;
             if (globalThis.window &&
@@ -64,7 +71,7 @@ export class WsClient extends Emittery {
                 console.error(`Got unrecognized Websocket message type: ${message.type}`);
             }
         };
-        socket.onclose = (event) => {
+        this.socket.onclose = (event) => {
             const pendingRequestIds = Object.keys(this.pendingRequests).map((id) => parseInt(id));
             if (pendingRequestIds.length) {
                 pendingRequestIds.forEach((id) => {
@@ -78,20 +85,17 @@ export class WsClient extends Emittery {
     /**
      * Instance factory for creating WsClients.
      *
-     * @param url - The `ws://` URL to connect to.
+     * @param url - The WebSocket URL to connect to.
      * @returns An new instance of the WsClient.
      */
     static connect(url) {
         return new Promise((resolve, reject) => {
             const socket = new IsoWebSocket(url);
-            // make sure that there are no uncaught connection
-            // errors because that causes nodejs thread to crash
-            // with uncaught exception
             socket.onerror = () => {
                 reject(new Error(`could not connect to holochain conductor, please check that a conductor service is running and available at ${url}`));
             };
             socket.onopen = () => {
-                const client = new WsClient(socket);
+                const client = new WsClient(socket, url);
                 resolve(client);
             };
         });
@@ -114,25 +118,43 @@ export class WsClient extends Emittery {
      * @param request - The request to send over the websocket.
      * @returns
      */
-    request(request) {
+    async request(request) {
         if (this.socket.readyState === this.socket.OPEN) {
-            const id = this.index;
-            const encodedMsg = encode({
-                id,
-                type: "request",
-                data: encode(request),
-            });
             const promise = new Promise((resolve, reject) => {
-                this.pendingRequests[id] = { resolve, reject };
+                this.sendMessage(request, resolve, reject);
             });
-            this.socket.send(encodedMsg);
-            this.index += 1;
             return promise;
         }
+        else if (this.url) {
+            const response = new Promise((resolve, reject) => {
+                // typescript forgets in this promise scope that this.url is not undefined
+                const socket = new IsoWebSocket(this.url);
+                this.socket = socket;
+                socket.onerror = () => {
+                    reject(new Error(`could not connect to Holochain conductor, please check that a conductor service is running and available at ${this.url}`));
+                };
+                socket.onopen = () => {
+                    this.sendMessage(request, resolve, reject);
+                };
+                this.setupSocket();
+            });
+            return response;
+        }
         else {
             return Promise.reject(new Error("Socket is not open"));
         }
     }
+    sendMessage(request, resolve, reject) {
+        const id = this.index;
+        const encodedMsg = encode({
+            id,
+            type: "request",
+            data: encode(request),
+        });
+        this.socket.send(encodedMsg);
+        this.pendingRequests[id] = { resolve, reject };
+        this.index += 1;
+    }
     handleResponse(msg) {
         const id = msg.id;
         if (this.pendingRequests[id]) {

package/lib/api/common.d.ts

@@ -30,6 +30,14 @@ export type Tagged<T> = {
  * @public
  */
 export declare const requesterTransformer: <ReqI, ReqO, ResI, ResO>(requester: Requester<Tagged<ReqO>, Tagged<ResI>>, tag: string, transform?: Transformer<ReqI, ReqO, ResI, ResO>) => (req: ReqI, timeout?: number) => Promise<ResO>;
+/**
+ * Error thrown when response from Holochain is an error.
+ *
+ * @public
+ */
+export declare class HolochainError extends Error {
+    constructor(name: string, message: string);
+}
 export declare const catchError: (res: any) => Promise<any>;
 export declare const promiseTimeout: (promise: Promise<unknown>, tag: string, ms: number) => Promise<unknown>;
 /**

package/lib/api/common.js

@@ -19,16 +19,32 @@ const identityTransformer = {
     input: identity,
     output: identity,
 };
+/**
+ * Error thrown when response from Holochain is an error.
+ *
+ * @public
+ */
+export class HolochainError extends Error {
+    constructor(name, message) {
+        super();
+        this.name = name;
+        this.message = message;
+    }
+}
+// this determines the error format of all error responses
 export const catchError = (res) => {
-    return res.type === ERROR_TYPE ? Promise.reject(res) : Promise.resolve(res);
+    if (res.type === ERROR_TYPE) {
+        const error = new HolochainError(res.data.type, res.data.data);
+        return Promise.reject(error);
+    }
+    else {
+        return Promise.resolve(res);
+    }
 };
 export const promiseTimeout = (promise, tag, ms) => {
     let id;
     const timeout = new Promise((_, reject) => {
-        id = setTimeout(() => {
-            clearTimeout(id);
-            reject(new Error(`Timed out in ${ms}ms: ${tag}`));
-        }, ms);
+        id = setTimeout(() => reject(new Error(`Timed out in ${ms}ms: ${tag}`)), ms);
     });
     return new Promise((res, rej) => {
         Promise.race([promise, timeout])

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@holochain/client",
-  "version": "0.14.1",
+  "version": "0.15.0",
   "description": "A JavaScript client for the Holochain Conductor API",
   "author": "Holochain Foundation <info@holochain.org> (http://holochain.org)",
   "license": "CAL-1.0",