hypha-rpc 0.20.17 → 0.20.19

package/dist/hypha-rpc-websocket.js

@@ -271,6 +271,8 @@ class Timer {
   }
 }
 
+class RemoteService extends Object {}
+
 /**
  * RPC object represents a single site in the
  * communication protocol between the application and the plugin
@@ -345,7 +347,10 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       const onConnected = async (connectionInfo) => {
         if (!this._silent && this._connection.manager_id) {
           console.log("Connection established, reporting services...");
-          const manager = await this.get_manager_service(10, "camel");
+          const manager = await this.get_manager_service({
+            timeout: 10,
+            case_conversion: "camel",
+          });
           for (let service of Object.values(this._services)) {
             const serviceInfo = this._extract_service_info(service);
             await manager.registerService(serviceInfo);
@@ -510,12 +515,16 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
     await this._connection.disconnect();
   }
 
-  async get_manager_service(timeout, case_conversion = null) {
+  async get_manager_service(config) {
+    config = config || {};
+    let { timeout, case_conversion } = config;
     (0,_utils__WEBPACK_IMPORTED_MODULE_0__.assert)(this._connection.manager_id, "Manager id is not set");
     const svc = await this.get_remote_service(
       `*/${this._connection.manager_id}:default`,
-      timeout,
-      case_conversion,
+      {
+        timeout: timeout,
+        case_conversion: case_conversion,
+      },
     );
     return svc;
   }
@@ -551,7 +560,8 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
       `Permission denied for getting protected service: ${service_id}, workspace mismatch: ${ws} != ${context["ws"]}`,
     );
   }
-  async get_remote_service(service_uri, timeout, case_conversion = null) {
+  async get_remote_service(service_uri, config) {
+    let { timeout, case_conversion } = config || {};
     timeout = timeout === undefined ? this._method_timeout : timeout;
     if (!service_uri && this._connection.manager_id) {
       service_uri = "*/" + this._connection.manager_id;
@@ -584,8 +594,12 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
         "Timeout Error: Failed to get remote service: " + service_uri,
       );
       svc.id = `${provider}:${service_id}`;
-      if (case_conversion) return (0,_utils__WEBPACK_IMPORTED_MODULE_0__.convertCase)(svc, case_conversion);
-      else return svc;
+      if (case_conversion)
+        return Object.assign(
+          new RemoteService(),
+          (0,_utils__WEBPACK_IMPORTED_MODULE_0__.convertCase)(svc, case_conversion),
+        );
+      else return Object.assign(new RemoteService(), svc);
     } catch (e) {
       console.warn("Failed to get remote service: " + service_uri, e);
       throw e;
@@ -728,11 +742,16 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
     return _get_schema(service, null, skipContext);
   }
 
-  async register_service(api, overwrite, notify = true, check_type = false) {
+  async register_service(api, config) {
+    let { check_type, notify, overwrite } = config || {};
+    notify = notify === undefined ? true : notify;
     let manager;
     if (check_type && api.type) {
       try {
-        manager = await this.get_manager_service(10, "camel");
+        manager = await this.get_manager_service({
+          timeout: 10,
+          case_conversion: "camel",
+        });
         const type_info = await manager.get_service_type(api.type);
         api = _annotate_service(api, type_info);
       } catch (e) {
@@ -744,7 +763,12 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
     const serviceInfo = this._extract_service_info(service);
     if (notify) {
       try {
-        manager = manager || (await this.get_manager_service(10, "camel"));
+        manager =
+          manager ||
+          (await this.get_manager_service({
+            timeout: 10,
+            case_conversion: "camel",
+          }));
         await manager.registerService(serviceInfo);
       } catch (e) {
         throw new Error(`Failed to notify workspace manager: ${e}`);
@@ -763,7 +787,10 @@ class RPC extends _utils__WEBPACK_IMPORTED_MODULE_0__.MessageEmitter {
     const api = this._services[service];
     delete this._services[service];
     if (notify) {
-      const manager = await this.get_manager_service(10, "camel");
+      const manager = await this.get_manager_service({
+        timeout: 10,
+        case_conversion: "camel",
+      });
       await manager.registerService(api.id);
     }
   }
@@ -2379,7 +2406,7 @@ async function getRTCService(server, service_id, config) {
         setTimeout(async () => {
           const rpc = await _setupRPC(config);
           pc.rpc = rpc;
-          async function get_service(name) {
+          async function get_service(name, ...args) {
             (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(
               !name.includes(":"),
               "WebRTC service name should not contain ':'",
@@ -2390,6 +2417,7 @@ async function getRTCService(server, service_id, config) {
             );
             return await rpc.get_remote_service(
               config.workspace + "/" + config.peer_id + ":" + name,
+              ...args,
             );
           }
           async function disconnect() {
@@ -2397,13 +2425,22 @@ async function getRTCService(server, service_id, config) {
             pc.close();
           }
           pc.getService = (0,_utils_schema_js__WEBPACK_IMPORTED_MODULE_2__.schemaFunction)(get_service, {
-            name: "get_service",
+            name: "getService",
             description: "Get a remote service via webrtc",
             parameters: {
               type: "object",
               properties: {
-                name: { type: "string", description: "Name of the service" },
+                service_id: {
+                  type: "string",
+                  description:
+                    "Service ID. This should be a service id in the format: 'workspace/service_id', 'workspace/client_id:service_id' or 'workspace/client_id:service_id@app_id'",
+                },
+                config: {
+                  type: "object",
+                  description: "Options for the service",
+                },
               },
+              required: ["id"],
             },
           });
           pc.disconnect = (0,_utils_schema_js__WEBPACK_IMPORTED_MODULE_2__.schemaFunction)(disconnect, {
@@ -4772,26 +4809,25 @@ async function login(config) {
   }
 }
 
-async function webrtcGetService(
-  wm,
-  rtc_service_id,
-  query,
-  webrtc,
-  webrtc_config,
-) {
+async function webrtcGetService(wm, rtc_service_id, query, config) {
+  config = config || {};
+  config.case_conversion = config.case_conversion || "camel";
+  const webrtc = config.webrtc;
+  const webrtc_config = config.webrtc_config;
+  if (config.webrtc !== undefined) delete config.webrtc;
+  if (config.webrtc_config !== undefined) delete config.webrtc_config;
   (0,_utils__WEBPACK_IMPORTED_MODULE_1__.assert)(
     [undefined, true, false, "auto"].includes(webrtc),
     "webrtc must be true, false or 'auto'",
   );
-  // pass other arguments to get_service
-  const otherArgs = Array.prototype.slice.call(arguments, 3);
-  const svc = await wm.getService(query, ...otherArgs);
+
+  const svc = await wm.getService(query, config);
   if (webrtc === true || webrtc === "auto") {
     if (svc.id.includes(":") && svc.id.includes("/")) {
       try {
         // Assuming that the client registered a webrtc service with the client_id + "-rtc"
         const peer = await (0,_webrtc_client_js__WEBPACK_IMPORTED_MODULE_3__.getRTCService)(wm, rtc_service_id, webrtc_config);
-        const rtcSvc = await peer.get_service(svc.id.split(":")[1]);
+        const rtcSvc = await peer.getService(svc.id.split(":")[1], config);
         rtcSvc._webrtc = true;
         rtcSvc._peer = peer;
         rtcSvc._service = svc;
@@ -4852,14 +4888,17 @@ async function connectToServer(config) {
     method_timeout: config.method_timeout,
     app_id: config.app_id,
   });
-  const wm = await rpc.get_manager_service(config.method_timeout, "camel");
+  const wm = await rpc.get_manager_service({
+    timeout: config.method_timeout,
+    case_conversion: "camel",
+  });
   wm.rpc = rpc;
 
   async function _export(api) {
     api.id = "default";
     api.name = api.name || config.name || api.id;
     api.description = api.description || config.description;
-    await rpc.register_service(api, true);
+    await rpc.register_service(api, { overwrite: true });
   }
 
   async function getApp(clientId) {
@@ -5023,37 +5062,44 @@ async function connectToServer(config) {
     });
   }
   if (config.webrtc) {
-    await (0,_webrtc_client_js__WEBPACK_IMPORTED_MODULE_3__.registerRTCService)(wm, clientId + "-rtc", config.webrtc_config);
+    await (0,_webrtc_client_js__WEBPACK_IMPORTED_MODULE_3__.registerRTCService)(wm, `${clientId}-rtc`, config.webrtc_config);
     // make a copy of wm, so webrtc can use the original wm.getService
     const _wm = Object.assign({}, wm);
+    const description = _wm.getService.__schema__.description;
+    // TODO: Fix the schema for adding options for webrtc
+    const parameters = _wm.getService.__schema__.parameters;
     wm.getService = (0,_utils_schema_js__WEBPACK_IMPORTED_MODULE_2__.schemaFunction)(
-      webrtcGetService.bind(null, _wm, clientId + "-rtc"),
+      webrtcGetService.bind(null, _wm, `${workspace}/${clientId}-rtc`),
       {
         name: "getService",
-        description: "Get a service via webrtc.",
-        parameters: {
-          properties: {
-            query: {
-              description: "The query to get the service",
-              type: "object",
-            },
-            webrtc: {
-              default: "auto",
-              description: "Use webrtc to get the service",
-              type: ["boolean", "string"],
-            },
-            webrtc_config: {
-              description: "The webrtc configuration",
-              type: "object",
-            },
+        description,
+        parameters,
+      },
+    );
+
+    wm.getRTCService = (0,_utils_schema_js__WEBPACK_IMPORTED_MODULE_2__.schemaFunction)(_webrtc_client_js__WEBPACK_IMPORTED_MODULE_3__.getRTCService.bind(null, wm), {
+      name: "getRTCService",
+      description: "Get the webrtc connection, returns a peer connection.",
+      parameters: {
+        properties: {
+          config: {
+            description: "The config for the webrtc service",
+            type: "object",
           },
-          required: ["query"],
-          type: "object",
         },
+        required: ["config"],
+        type: "object",
       },
-    );
+    });
+  } else {
+    const _getService = wm.getService;
+    wm.getService = (query, config) => {
+      config = config || {};
+      config.case_conversion = config.case_conversion || "camel";
+      return _getService(query, config);
+    };
+    wm.getService.__schema__ = _getService.__schema__;
   }
-
   return wm;
 }