hypha-rpc 0.1.5 → 0.1.6-post1

package/dist/hypha-rpc-websocket.js

@@ -231,7 +231,7 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       this._emit_message = connection.emit_message.bind(connection);
       connection.on_message(this._on_message.bind(this));
       this._connection = connection;
-      const updateServices = async () => {
+      const onConnected = async (connectionInfo) => {
         if (!this._silent && this._connection.manager_id) {
           console.log("Connection established, reporting services...");
           for (let service of Object.values(this._services)) {
@@ -244,12 +244,13 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
           }
         } else {
           console.log(
-            "Connection established, no manager id to report services",
+            "Connection established", connectionInfo
           );
         }
+        this._fire("connected", connectionInfo);
       };
-      connection.on_connect(updateServices);
-      updateServices();
+      connection.on_connected(onConnected);
+      onConnected();
     } else {
       this._emit_message = function () {
         console.log("No connection to emit message");
@@ -387,7 +388,11 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
         Object.assign(main, extra.value);
       }
       this._fire(main["type"], main);
-    } else {
+    }
+    else if (typeof message === "object") {
+      this._fire(message["type"], message);
+    }
+    else {
       throw new Error("Invalid message format");
     }
   }
@@ -398,7 +403,7 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
   }
 
   async disconnect() {
-    this._fire("disconnect");
+    this._fire("disconnected");
     await this._connection.disconnect();
   }
 
@@ -478,7 +483,7 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       svc.id = `${provider}:${service_id}`;
       return svc;
     } catch (e) {
-      console.error("Failed to get remote service: " + service_uri, e);
+      console.warn("Failed to get remote service: " + service_uri, e);
       throw e;
     }
   }
@@ -790,8 +795,12 @@ class RPC extends _utils_js__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
   emit(main_message, extra_data) {
     (0,_utils_js__WEBPACK_IMPORTED_MODULE_0__.assert)(
       typeof main_message === "object" && main_message.type,
-      "Invalid message, must be an object with a type field.",
+      "Invalid message, must be an object with a `type` fields.",
     );
+    if(!main_message.to) {
+      this._fire(main_message.type, main_message);
+      return
+    }
     let message_package = (0,_msgpack_msgpack__WEBPACK_IMPORTED_MODULE_2__.encode)(main_message);
     if (extra_data) {
       const extra = (0,_msgpack_msgpack__WEBPACK_IMPORTED_MODULE_2__.encode)(extra_data);
@@ -1976,11 +1985,11 @@ class WebRTCConnection {
     this._data_channel = channel;
     this._handle_message = null;
     this._reconnection_token = null;
-    this._disconnect_handler = null;
-    this._handle_connect = () => {};
+    this._handle_disconnected = null;
+    this._handle_connected = () => {};
     this.manager_id = null;
     this._data_channel.onopen = async () => {
-      this._handle_connect && this._handle_connect();
+      this._handle_connected && this._handle_connected({channel: this._data_channel});
     };
     this._data_channel.onmessage = async (event) => {
       let data = event.data;
@@ -1991,18 +2000,18 @@ class WebRTCConnection {
     };
     const self = this;
     this._data_channel.onclose = function () {
-      if (this._disconnect_handler) this._disconnect_handler("closed");
+      if (this._handle_disconnected) this._handle_disconnected("closed");
       console.log("websocket closed");
       self._data_channel = null;
     };
   }
 
   on_disconnected(handler) {
-    this._disconnect_handler = handler;
+    this._handle_disconnected = handler;
   }
 
-  on_connect(handler) {
-    this._handle_connect = handler;
+  on_connected(handler) {
+    this._handle_connected = handler;
   }
 
   on_message(handler) {
@@ -4178,6 +4187,7 @@ class WebsocketRPCConnection {
     client_id,
     workspace,
     token,
+    reconnection_token = null,
     timeout = 60,
     WebSocketClass = null,
   ) {
@@ -4186,11 +4196,11 @@ class WebsocketRPCConnection {
     this._client_id = client_id;
     this._workspace = workspace;
     this._token = token;
-    this._reconnection_token = null;
+    this._reconnection_token = reconnection_token;
     this._websocket = null;
     this._handle_message = null;
-    this._handle_connect = null; // Connection open event handler
-    this._disconnect_handler = null; // Disconnection event handler
+    this._handle_connected = null; // Connection open event handler
+    this._handle_disconnected = null; // Disconnection event handler
     this._timeout = timeout;
     this._WebSocketClass = WebSocketClass || WebSocket; // Allow overriding the WebSocket class
     this._closed = false;
@@ -4205,12 +4215,12 @@ class WebsocketRPCConnection {
     this._handle_message = handler;
   }
 
-  on_connect(handler) {
-    this._handle_connect = handler;
+  on_connected(handler) {
+    this._handle_connected = handler;
   }
 
   on_disconnected(handler) {
-    this._disconnect_handler = handler;
+    this._handle_disconnected = handler;
   }
 
   async _attempt_connection(server_url, attempt_fallback = true) {
@@ -4238,8 +4248,8 @@ class WebsocketRPCConnection {
           this._attempt_connection_with_query_params(server_url)
             .then(resolve)
             .catch(reject);
-        } else if (this._disconnect_handler) {
-          this._disconnect_handler(event.reason);
+        } else if (this._handle_disconnected) {
+          this._handle_disconnected(event.reason);
         }
       };
     });
@@ -4291,15 +4301,18 @@ class WebsocketRPCConnection {
           console.log(
             `Successfully connected to the server, workspace: ${this.connection_info.workspace}, manager_id: ${this.manager_id}`,
           );
+          if(this.connection_info.announcement){
+            console.log(`${this.connection_info.announcement}`);
+          }
           resolve(this.connection_info);
         } else if (first_message.type == "error") {
-          const error = first_message.error || "Unknown error";
+          const error = "ConnectionAbortedError: " + first_message.message;
           console.error("Failed to connect, " + error);
           reject(new Error(error));
           return;
         } else {
-          console.error("Unexpected message received from the server:", data);
-          reject(new Error("Unexpected message received from the server"));
+          console.error("ConnectionAbortedError: Unexpected message received from the server:", data);
+          reject(new Error("ConnectionAbortedError: Unexpected message received from the server"));
           return;
         }
       };
@@ -4341,8 +4354,8 @@ class WebsocketRPCConnection {
 
       this._websocket.onclose = this._handle_close.bind(this);
 
-      if (this._handle_connect) {
-        this._handle_connect(this);
+      if (this._handle_connected) {
+        this._handle_connected(this.connection_info);
       }
       return this.connection_info;
     } catch (error) {
@@ -4361,14 +4374,12 @@ class WebsocketRPCConnection {
       this._websocket &&
       this._websocket.readyState === WebSocket.CLOSED
     ) {
-      if ([1000].includes(event.code)) {
+      if ([1000, 1001].includes(event.code)) {
         console.info(
-          "Websocket connection closed (code: %s): %s",
-          event.code,
-          event.reason,
+          `Websocket connection closed (code: ${event.code}): ${event.reason}`  
         );
-        if (this._disconnect_handler) {
-          this._disconnect_handler(event.reason);
+        if (this._handle_disconnected) {
+          this._handle_disconnected(event.reason);
         }
         this._closed = true;
       } else if (this._enable_reconnect) {
@@ -4380,10 +4391,11 @@ class WebsocketRPCConnection {
         let retry = 0;
         const reconnect = async () => {
           try {
-            console.info(
+            console.warn(
               `Reconnecting to ${this._server_url.split("?")[0]} (attempt #${retry})`,
             );
             await this.open();
+            console.warn(`Successfully reconnected to server ${this._server_url}`); 
           } catch (e) {
             if (`${e}`.includes("ConnectionAbortedError")) {
               console.warn("Failed to reconnect, connection aborted:", e);
@@ -4392,7 +4404,6 @@ class WebsocketRPCConnection {
               console.warn("Failed to reconnect, connection aborted:", e);
               return;
             }
-            console.warn("Failed to reconnect:", e);
             await new Promise((resolve) => setTimeout(resolve, 1000));
             if (
               this._websocket &&
@@ -4411,8 +4422,8 @@ class WebsocketRPCConnection {
         reconnect();
       }
     } else {
-      if (this._disconnect_handler) {
-        this._disconnect_handler(event.reason);
+      if (this._handle_disconnected) {
+        this._handle_disconnected(event.reason);
       }
     }
   }
@@ -4457,6 +4468,7 @@ async function login(config) {
   const service_id = config.login_service_id || "public/*:hypha-login";
   const timeout = config.login_timeout || 60;
   const callback = config.login_callback;
+  const profile = config.profile;
 
   const server = await connectToServer({
     name: "initial login client",
@@ -4464,13 +4476,14 @@ async function login(config) {
   });
   try {
     const svc = await server.get_service(service_id);
+    (0,_utils_js__WEBPACK_IMPORTED_MODULE_1__.assert)(svc, `Failed to get the login service: ${service_id}`);
     const context = await svc.start();
     if (callback) {
       await callback(context);
     } else {
       console.log(`Please open your browser and login at ${context.login_url}`);
     }
-    return await svc.check(context.key, timeout);
+    return await svc.check(context.key, timeout, profile);
   } catch (error) {
     throw error;
   } finally {
@@ -4497,6 +4510,7 @@ async function connectToServer(config) {
     clientId,
     config.workspace,
     config.token,
+    config.reconnection_token,
     config.method_timeout || 60,
     config.WebSocketClass,
   );
@@ -4533,17 +4547,13 @@ async function connectToServer(config) {
     return await wm.get_service(query + ":default");
   }
 
-  async function disconnect() {
-    await rpc.disconnect();
-    await connection.disconnect();
-  }
   if (connection_info) {
     wm.config = Object.assign(wm.config, connection_info);
   }
   wm.export = _export;
   wm.getPlugin = getPlugin;
   wm.listPlugins = wm.listServices;
-  wm.disconnect = disconnect;
+  wm.disconnect = rpc.disconnect.bind(rpc);
   wm.registerCodec = rpc.register_codec.bind(rpc);
   wm.emit = rpc.emit;
   wm.on = rpc.on;
@@ -4551,7 +4561,7 @@ async function connectToServer(config) {
     rpc.on("force-exit", async (message) => {
       if (message.from === "*/" + connection.manager_id) {
         console.log("Disconnecting from server, reason:", message.reason);
-        await disconnect();
+        await rpc.disconnect();
       }
     });
   }
@@ -4565,7 +4575,9 @@ async function connectToServer(config) {
         [undefined, true, false, "auto"].includes(webrtc),
         "webrtc must be true, false or 'auto'",
       );
-      const svc = await _get_service(query);
+      // pass other arguments to get_service
+      const otherArgs = Array.prototype.slice.call(arguments, 3);
+      const svc = await _get_service(query, ...otherArgs);
       if (webrtc === true || webrtc === "auto") {
         if (svc.id.includes(":") && svc.id.includes("/")) {
           const client = svc.id.split(":")[0];