@transitive-sdk/utils-web 0.14.14 → 0.16.0

package/dist/utils-web.js

@@ -406,6 +406,8 @@ var require_common = __commonJS({
         callback && callback(count);
       }, delay);
     };
+    var storageRequestToSelector = (topic) => pathToTopic2(topicToPath2(topic).map((value) => value == "$store" ? "+" : value).map((value) => value == "$storeTail" ? "#" : value));
+    var selectorToStorageRequest = (topic) => pathToTopic2(topicToPath2(topic).map((value) => value[0] == "+" ? "$store" : value).map((value) => value[0] == "#" ? "$storeTail" : value));
     var getRandomId = (bytes = 6) => {
       const buffer = new Uint8Array(bytes);
       crypto.getRandomValues(buffer);
@@ -494,7 +496,9 @@ var require_common = __commonJS({
       formatDuration,
       tryJSONParse,
       decodeJWT: decodeJWT3,
-      visitAncestor
+      visitAncestor,
+      storageRequestToSelector,
+      selectorToStorageRequest
     };
   }
 });
@@ -713,7 +717,8 @@ var require_MqttSync = __commonJS({
       versionCompare,
       encodeTopicElement,
       visitAncestor,
-      getRandomId
+      getRandomId,
+      selectorToStorageRequest
     } = require_common();
     var { DataCache } = require_DataCache();
     var log2 = getLogger2("MqttSync");
@@ -771,7 +776,8 @@ var require_MqttSync = __commonJS({
         migrate,
         onReady,
         sliceTopic,
-        onHeartbeatGranted
+        onHeartbeatGranted,
+        inclMeta
       }) {
         this.mqtt = mqttClient;
         this.sliceTopic = sliceTopic;
@@ -796,9 +802,13 @@ var require_MqttSync = __commonJS({
               path = path.slice(sliceTopic);
               topic = pathToTopic2(path);
             }
-            if (this.rpcHandlers[topic]) {
+            if (!inclMeta && path.some((field) => field[0] == "$")) {
+              return;
+            }
+            const rpcHandler = this.getRPCHandler(topic);
+            if (rpcHandler) {
               const json = mqttParsePayload(payload);
-              this.handleRPCRequest(topic, json);
+              this.handleRPCRequest(path, rpcHandler, json);
             } else if (this.rpcCallbacks[topic]) {
               const json = mqttParsePayload(payload);
               this.handleRPCResponse(topic, json);
@@ -976,15 +986,15 @@ var require_MqttSync = __commonJS({
           callback && callback(count);
         });
       }
-      /** register a callback for the next heartbeat from the broker */
+      /** Register a callback for the next heartbeat from the broker */
       waitForHeartbeatOnce(callback) {
         setTimeout(() => this.heartbeatWaitersOnce.push(callback), 1);
       }
-      /** check whether we are subscribed to the given topic */
+      /* check whether we are subscribed to the given topic */
       isSubscribed(topic) {
         return Object.keys(this.subscribedPaths).some((subscribedTopic) => topicMatch(subscribedTopic, topic));
       }
-      /** Check whether we are publishing the given topic in a non-atomic way.
+      /* Check whether we are publishing the given topic in a non-atomic way.
       This is used to determine whether to store the published value or not. */
       isPublished(topic) {
         return Object.keys(this.publishedPaths).some(
@@ -1018,7 +1028,7 @@ var require_MqttSync = __commonJS({
           delete this.subscribedPaths[topic];
         }
       }
-      /** Publish retained to MQTT, store as published, and return a promise */
+      /* Publish retained to MQTT, store as published, and return a promise */
       _actuallyPublish(topic, value) {
         if (!this.mqtt.connected) {
           log2.warn("not connected, not publishing", topic);
@@ -1033,7 +1043,7 @@ var require_MqttSync = __commonJS({
         );
         return true;
       }
-      /** Send all items in the queue in sequence, if any and if not already
+      /* Send all items in the queue in sequence, if any and if not already
       running. */
       // async _processQueue() {
       //   if (this._processing) return; // already running (and probably waiting)
@@ -1082,7 +1092,7 @@ var require_MqttSync = __commonJS({
       addToQueue(topic, value) {
         this.publishQueue.set(topic, value);
       }
-      /** Add to publication queue */
+      /* Add to publication queue */
       _enqueue(topic, value) {
         log2.debug("enqueuing", topic);
         this.addToQueue(topic, value);
@@ -1174,12 +1184,17 @@ var require_MqttSync = __commonJS({
       /* --------------------------------------------------------------------------
       *  Remote Procedure Calls (RPC)
       */
+      /** Given a (ground) topic find the matching RPC handler, if any. This is
+      * needed because RPC topics can include wildcards. */
+      getRPCHandler(topic) {
+        return _3.find(this.rpcHandlers, (_handler, topicSelector) => topicMatch(topicSelector, topic));
+      }
       /* 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}`;
+      async handleRPCRequest(path, handler, json) {
+        log2.debug("handling RPC request for", path, json);
+        const commandTopic = pathToTopic2(path.slice(0, -1));
+        const result = handler(json.args, commandTopic);
+        const responseTopic = `${commandTopic}/response/${json.id}`;
         if (result instanceof Promise) {
           result.then((resultValue) => this.mqtt.publish(
             responseTopic,
@@ -1202,24 +1217,29 @@ var require_MqttSync = __commonJS({
         this.mqtt.unsubscribe(topic);
       }
       /** Register an RPC request handler. Example:
-       * ```js
-       * mqttSync.register('/mySquare', arg => {
-       *   log.debug('running /mySquare with args', arg);
-       *   return arg * arg;
-       * });
-       * ```
-       * Note that the command topic needs to be in the capabilities namespace like
-       * any other topic. In robot capabilities, as usual, these can start in `/`
-       * because the local mqtt bridge operated by the robot agent will place all
-       * 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.
-       */
+      * ```js
+      * mqttSync.register('/mySquare', (arg, commandTopic) => {
+      *   log.debug('we got request on topic', commandTopic);
+      *   log.debug('running /mySquare with args', arg);
+      *   return arg * arg;
+      * });
+      * ```
+      * Note that the command topic needs to be in the capabilities namespace like
+      * any other topic. In robot capabilities, as usual, these can start in `/`
+      * because the local mqtt bridge operated by the robot agent will place all
+      * 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/`.
+      *
+      * You can use wildcards in the registered topic. The handler will receive the
+      * actual, ground topic the request was made on as the second argument. This
+      * allows you to make the RPCs behavior depend on the topic.
+      *
+      * #### 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);
         const requestTopic = `${command}/request`;
@@ -1234,13 +1254,22 @@ var require_MqttSync = __commonJS({
       }
       /** Make an RPC request. Example:
       * ```js
-      * mqttSync.call('/mySquare', 11, result => {
+      * mqttSync.call('/orgId/deviceId/@capScope/capName/capVersion/mySquare', 11, result => {
       *   log.debug(`Called /mySquare with arg 11 and got ${result}`);
       * });
       * ```
+      * This would call the RPC 'mySquare' registered by version `capVersion` of the
+      * capability `@capScope/capName` running on device `deviceId` by user `orgId`.
+      * That RPC would have been registered on the device using
+      * `mqttSync.register('/mySquare', ...)` as shown above (because namespaces
+      * on the device are auto-extended to the org, device and capability).
+      *
+      * RPCs are typically registered on the robot and called from the web or cloud
+      * but the inverse is also possible, with the same namespace caveat.
+      *
       * Alternative you can omit the callback and use async/await:
       * ```js
-      * const result = await mqttSync.call('/mySquare', 11);
+      * const result = await mqttSync.call('${prefix}/mySquare', 11);
       * log.debug(`Called /mySquare with arg 11 and got ${result}`);
       * ```
       * See the note about namespaces in `register`.
@@ -1273,6 +1302,14 @@ var require_MqttSync = __commonJS({
           });
         }
       }
+      /** Request the history of the described topics (selector with wildcards) to
+      * be stored in ClickHouse for the `ttl` number of days (if the mqtt2clickhouse
+      * service is running -- as it usually is inside the
+      * transitiverobotics/clickhouse docker image). */
+      requestHistoryStorage(topic, ttl = 1) {
+        const storageRequest = selectorToStorageRequest(topic);
+        this.mqtt.publish(storageRequest, String(ttl), { retain: true });
+      }
     };
     module2.exports = MqttSync3;
   }

package/package.json

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