@transitive-sdk/utils-web 0.12.0 → 0.12.2

package/dist/utils-web.js

@@ -655,7 +655,6 @@ var require_MqttSync = __commonJS({
     var log2 = getLogger2("MqttSync");
     var HEARTBEAT_TOPIC = "$SYS/broker/uptime";
     var specialKey = "$_";
-    var RPC_PREFIX = "_RPCv1_";
     var noop = () => {
     };
     var clone2 = (payload) => {
@@ -733,8 +732,10 @@ var require_MqttSync = __commonJS({
               topic = pathToTopic2(path);
             }
             const json = mqttParsePayload(payload);
-            if (path[0] == RPC_PREFIX) {
-              this.handleRPC(path.slice(1), json);
+            if (this.rpcHandlers[topic]) {
+              this.handleRPCRequest(topic, json);
+            } else if (this.rpcCallbacks[topic]) {
+              this.handleRPCResponse(topic, json);
             } else if (this.isPublished(topic)) {
               this.publishedMessages.updateFromArray([...path, specialKey], json);
               this.data.update(topic, json, { external: true });
@@ -1084,38 +1085,37 @@ var require_MqttSync = __commonJS({
       /* --------------------------------------------------------------------------
       *  Remote Procedure Calls (RPC)
       */
-      /* Handle RPC requests anmd responses  */
-      handleRPC(path, json) {
-        const type = path[0];
-        if (type == "request") {
-          const command = pathToTopic2(path.slice(1));
-          log2.debug("handling RPC request for", command, json);
-          const handler = this.rpcHandlers[command];
-          if (!handler) {
-            log2.warn("Received unknown RPC request", command);
-            return;
-          }
-          const result = handler(json.args);
-          const responseTopic = `/${RPC_PREFIX}/response/${json.id}`;
+      /* Handle RPC requests  */
+      async handleRPCRequest(topic, json) {
+        log2.debug("handling RPC request for", topic, json);
+        const handler = this.rpcHandlers[topic];
+        const result = handler(json.args);
+        const responseTopic = `${topic.replace("/request", "/response")}/${json.id}`;
+        if (result instanceof Promise) {
+          result.then((resultValue) => this.mqtt.publish(
+            responseTopic,
+            JSON.stringify({ id: json.id, result: resultValue }),
+            { retain: false, qos: 2 }
+          ));
+        } else {
           this.mqtt.publish(
             responseTopic,
-            JSON.stringify({ id: json.id, command, result }),
+            JSON.stringify({ id: json.id, result }),
             { retain: false, qos: 2 }
           );
-        } else if (type == "response") {
-          const requestId = path[1];
-          log2.debug("handle RPC response", requestId, json);
-          this.rpcCallbacks[requestId]?.(json.result);
-          delete this.rpcCallbacks[requestId];
-          this.mqtt.unsubscribe(`/${RPC_PREFIX}/response/${requestId}`);
-        } else {
-          log2.warn("Unknown RPC type", path);
         }
       }
+      /* Handle RPC response  */
+      handleRPCResponse(topic, json) {
+        log2.debug("handle RPC response", topic, json);
+        this.rpcCallbacks[topic](json.result);
+        delete this.rpcCallbacks[topic];
+        this.mqtt.unsubscribe(topic);
+      }
       /** Register an RPC request handler. Example:
        * ```js
-       * mqttSync.register('/mycommand', arg => {
-       *   log.debug('running /mycommand with args', arg);
+       * mqttSync.register('/mySquare', arg => {
+       *   log.debug('running /mySquare with args', arg);
        *   return arg * arg;
        * });
        * ```
@@ -1125,11 +1125,16 @@ var require_MqttSync = __commonJS({
        * topics in their respective namespace. In the cloud and on the web you will
        * need to use the respective namespace, i.e.,
        * `/orgId/deviceId/@scope/capName/capVersion/`.
+       *
+       * #### Async/Await
+       * Yes, you can make the handler `async` and use `await` inside of it. This
+       * will be handled correctly, i.e., MqttSync will await the result of the
+       * handler before responding to the RPC request client.
        */
       register(command, handler) {
         log2.debug("registering RPC handler for", command);
-        this.rpcHandlers[command] = handler;
-        const requestTopic = `/${RPC_PREFIX}/request${command}`;
+        const requestTopic = `${command}/request`;
+        this.rpcHandlers[requestTopic] = handler;
         this.mqtt.subscribe(requestTopic, { rap: true, qos: 2 }, (err, granted) => {
           if (err) {
             log2.warn(`Error subscribing to RPC topic ${requestTopic}`, err);
@@ -1140,20 +1145,20 @@ var require_MqttSync = __commonJS({
       }
       /** Make an RPC request. Example:
       * ```js
-      * mqttSync.call('/mycommand', 11, result => {
-      *   log.debug(`Called /mycommand with arg 11 and got ${result}`);
+      * mqttSync.call('/mySquare', 11, result => {
+      *   log.debug(`Called /mySquare with arg 11 and got ${result}`);
       * });
       * ```
       * Alternative you can omit the callback and use async/await:
       * ```js
-      * const result = await mqttSync.call('/mycommand', 11);
-      * log.debug(`Called /mycommand with arg 11 and got ${result}`);
+      * const result = await mqttSync.call('/mySquare', 11);
+      * log.debug(`Called /mySquare with arg 11 and got ${result}`);
       * ```
       * See the note about namespaces in `register`.
       */
       call(command, args, callback = void 0) {
         const id = crypto.randomUUID();
-        const responseTopic = `/${RPC_PREFIX}/response/${id}`;
+        const responseTopic = `${command}/response/${id}`;
         this.mqtt.subscribe(responseTopic, { rap: true, qos: 2 }, (err, granted) => {
           if (err) {
             log2.warn(`Error subscribing to RPC response topic ${responseTopic}`, err);
@@ -1161,7 +1166,7 @@ var require_MqttSync = __commonJS({
             log2.warn(`Not allowed to subscribe to RPC response topic ${responseTopic}`);
           }
         });
-        const requestTopic = `/${RPC_PREFIX}/request${command}`;
+        const requestTopic = `${command}/request`;
         log2.debug("calling RPC", requestTopic);
         this.mqtt.publish(
           requestTopic,
@@ -1169,10 +1174,10 @@ var require_MqttSync = __commonJS({
           { retain: false, qos: 2 }
         );
         if (callback) {
-          this.rpcCallbacks[id] = callback;
+          this.rpcCallbacks[responseTopic] = callback;
         } else {
           return new Promise((resolve, reject) => {
-            this.rpcCallbacks[id] = resolve;
+            this.rpcCallbacks[responseTopic] = resolve;
           });
         }
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@transitive-sdk/utils-web",
-  "version": "0.12.0",
+  "version": "0.12.2",
   "description": "Web utils for the Transitive framework",
   "homepage": "https://transitiverobotics.com",
   "repository": {