doover-js 0.1.2 → 0.2.0

package/dist/viewer/doover-data-provider.js

@@ -11,12 +11,19 @@ const errors_1 = require("../http/errors");
 const rest_client_1 = require("../http/rest-client");
 const snowflake_1 = require("../utils/snowflake");
 const path_parsing_1 = require("./path-parsing");
+function isRpcMessageData(data) {
+    return (typeof data === "object" &&
+        data !== null &&
+        "status" in data &&
+        "method" in data &&
+        "request" in data);
+}
 class DooverDataProvider {
-    constructor(config) {
+    constructor(config, auth) {
         this.config = config;
         this.subscriptions = new Map();
-        this.rest = new rest_client_1.RestClient(config);
-        this.gateway = new gateway_client_1.GatewayClient(config);
+        this.rest = new rest_client_1.RestClient(config, auth);
+        this.gateway = new gateway_client_1.GatewayClient(config, auth);
         this.agentsApi = new agents_api_1.AgentsApi(this.rest);
         this.channelsApi = new channels_api_1.ChannelsApi(this.rest);
         this.messagesApi = new messages_api_1.MessagesApi(this.rest);
@@ -27,6 +34,11 @@ class DooverDataProvider {
             const identifier = this.toIdentifier(message.channel.agent_id, message.channel.name);
             this.subscriptions.get(key)?.forEach((entry) => entry.messageCallback(identifier, message));
         });
+        this.gateway.on("messageUpdate", (message) => {
+            const key = this.channelKey(message.channel.agent_id, message.channel.name);
+            const identifier = this.toIdentifier(message.channel.agent_id, message.channel.name);
+            this.subscriptions.get(key)?.forEach((entry) => entry.messageUpdateCallback?.(identifier, message));
+        });
         this.gateway.on("channelSync", (event) => {
             const key = this.channelKey(event.channel.agent_id, event.channel.name);
             const identifier = this.toIdentifier(event.channel.agent_id, event.channel.name);
@@ -78,13 +90,17 @@ class DooverDataProvider {
         }
         return this.channelsApi.getChannel(identifier.agentId, identifier.channelName);
     }
-    async subscribeToChannel(identifier, callback, aggregateCallback) {
+    async subscribeToChannel(identifier, callback, aggregateCallback, messageUpdateCallback) {
         const validated = this.requireChannel(identifier);
         const key = this.channelKey(validated.agentId, validated.channelName);
         const entries = this.subscriptions.get(key) ?? [];
-        entries.push({ messageCallback: callback, aggregateCallback });
+        entries.push({
+            messageCallback: callback,
+            aggregateCallback,
+            messageUpdateCallback,
+        });
         this.subscriptions.set(key, entries);
-        this.gateway.connect();
+        await this.gateway.connect();
         this.gateway.subscribe({
             agent_id: validated.agentId,
             name: validated.channelName,
@@ -121,13 +137,27 @@ class DooverDataProvider {
         }
         return this.aggregatesApi.getAggregate(identifier.agentId, identifier.channelName);
     }
-    async getMessages(identifier, beforeId) {
+    /**
+     * Fetch a page of messages for a channel.
+     *
+     * Accepts either a cursor string (legacy — shorthand for `{ before }`)
+     * or a `ListMessagesParams` options object.
+     *
+     * Default limit is 10 for backwards compatibility; pass `limit` explicitly
+     * for larger pages.
+     */
+    async getMessages(identifier, optionsOrBefore) {
         if (!identifier.agentId || !identifier.channelName) {
             return undefined;
         }
+        const options = typeof optionsOrBefore === "string"
+            ? { before: optionsOrBefore }
+            : (optionsOrBefore ?? {});
         const messages = await this.messagesApi.listMessages(identifier.agentId, identifier.channelName, {
-            before: beforeId ?? (0, snowflake_1.generateSnowflakeIdAtTime)(new Date()),
-            limit: 10,
+            before: options.before ?? (0, snowflake_1.generateSnowflakeIdAtTime)(new Date()),
+            limit: options.limit ?? 10,
+            ...(options.after !== undefined ? { after: options.after } : {}),
+            ...(options.field_name !== undefined ? { field_name: options.field_name } : {}),
         });
         return messages.reverse();
     }
@@ -141,6 +171,63 @@ class DooverDataProvider {
             data: message,
         });
     }
+    /**
+     * Send a message-based RPC to a channel and await a settled response.
+     *
+     * Wire protocol: POST a message with `{ type: "rpc", ...rpcRequest }`; the
+     * server echoes progress via `MessageUpdate` events keyed by the message id,
+     * carrying a `status` envelope. Resolves on `success` with the `response`
+     * payload, rejects on `error` with the status message.
+     *
+     * For low-latency ephemeral commands (camera PTZ etc.), use
+     * `gateway.sendOneShotMessage` directly instead — that path is not persisted
+     * to the database.
+     *
+     * `onStatus` fires on every intermediate status (`sent`, `acknowledged`,
+     * `deferred`, `pending`) and once more on terminal states.
+     */
+    sendRPC(identifier, rpcRequest, options) {
+        return new Promise((resolve, reject) => {
+            let rpcMessageId;
+            let settled = false;
+            const onUpdate = (_identifier, message) => {
+                if (settled)
+                    return;
+                if (rpcMessageId === undefined || message.id !== rpcMessageId)
+                    return;
+                if (!isRpcMessageData(message.data))
+                    return;
+                const rpcMessage = message.data;
+                options?.onStatus?.(rpcMessage.status);
+                if (rpcMessage.status.code === "success") {
+                    settled = true;
+                    void this.unsubscribeFromChannel(identifier, noopMessageCallback);
+                    resolve(rpcMessage.response);
+                }
+                else if (rpcMessage.status.code === "error") {
+                    settled = true;
+                    void this.unsubscribeFromChannel(identifier, noopMessageCallback);
+                    reject(rpcMessage.status.message);
+                }
+            };
+            // noopMessageCallback is used as the identity handle for this
+            // subscription — subscribe/unsubscribe pair matches by reference.
+            const noopMessageCallback = () => { };
+            const noopAggregateCallback = () => { };
+            this.subscribeToChannel(identifier, noopMessageCallback, noopAggregateCallback, onUpdate)
+                .then(() => this.sendMessage(identifier, { type: "rpc", ...rpcRequest }))
+                .then((message) => {
+                rpcMessageId = message.id;
+            })
+                .catch((error) => {
+                if (settled)
+                    return;
+                settled = true;
+                void this.unsubscribeFromChannel(identifier, noopMessageCallback);
+                reject(error);
+            });
+        });
+    }
     updateAggregate(identifier, message) {
         const validated = this.requireChannel(identifier);
         return this.aggregatesApi.patchAggregate(validated.agentId, validated.channelName, message);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doover-js",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "TypeScript client for Doover.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -8,6 +8,14 @@
     ".": {
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
+    },
+    "./node": {
+      "types": "./dist/node/index.d.ts",
+      "default": "./dist/node/index.js"
+    },
+    "./react": {
+      "types": "./dist/react/index.d.ts",
+      "default": "./dist/react/index.js"
     }
   },
   "repository": {
@@ -25,20 +33,43 @@
     "build": "tsc",
     "clean": "rm -rf dist",
     "prepublishOnly": "npm run build",
-    "test": "mocha --require tsx/cjs \"src/test/**/*.test.ts\""
+    "test:node": "mocha --exit --require tsx/cjs \"src/test/**/*.test.ts\"",
+    "test:react": "mocha --exit --require global-jsdom/register --require tsx/cjs \"src/test/**/*.test.tsx\"",
+    "test": "npm run test:node && npm run test:react"
   },
   "keywords": [
     "doover"
   ],
   "license": "Apache-2.0",
+  "peerDependencies": {
+    "@tanstack/react-query": "^5",
+    "react": "^18 || ^19"
+  },
+  "peerDependenciesMeta": {
+    "@tanstack/react-query": {
+      "optional": true
+    },
+    "react": {
+      "optional": true
+    }
+  },
   "devDependencies": {
+    "@tanstack/react-query": "^5.90.2",
+    "@testing-library/react": "^16.1.0",
     "@types/chai": "^5.2.2",
     "@types/chai-as-promised": "^7.1.8",
     "@types/mocha": "^10.0.10",
+    "@types/node": "^25.6.0",
+    "@types/react": "^18.3.17",
+    "@types/react-dom": "^18.3.5",
     "@types/sinon": "^17.0.4",
     "chai": "^5.2.1",
     "chai-as-promised": "^8.0.2",
+    "global-jsdom": "^25.0.0",
+    "jsdom": "^25.0.1",
     "mocha": "^11.1.0",
+    "react": "^18.3.1",
+    "react-dom": "^18.3.1",
     "sinon": "^21.0.0",
     "tsx": "^4.19.3",
     "typescript": "^5.8.3"