doover-js 0.3.0 → 0.4.1

package/dist/gateway/gateway-client.js

@@ -243,7 +243,7 @@ class GatewayClient {
                 this.emit("messageCreate", (0, snowflake_1.addTimestampToMessage)(message.d));
                 break;
             case "MessageUpdate":
-                this.emit("messageUpdate", (0, snowflake_1.addTimestampToMessage)(message.d));
+                this.emit("messageUpdate", (0, snowflake_1.addTimestampToMessage)(message.d.message), message.d.request_data);
                 break;
             case "AggregateUpdate":
                 this.emit("aggregateUpdate", message.d);

package/dist/gateway/types.d.ts

@@ -38,10 +38,20 @@ export interface GatewayMessageCreate extends GatewayMessageBase {
     t: "MessageCreate";
     d: Omit<MessageStructure, "timestamp">;
 }
+/**
+ * `message` is the full post-update MessageStructure; `request_data` is the
+ * diff of just-changed fields. Consumers should read `message` for the
+ * current state and only touch `request_data` if they specifically need to
+ * know what changed in this update.
+ */
 export interface GatewayMessageUpdate extends GatewayMessageBase {
     op: 0;
     t: "MessageUpdate";
-    d: Omit<MessageStructure, "timestamp"> & {
+    d: {
+        channel: ChannelRef;
+        author_id: string;
+        organisation_id?: string;
+        message: Omit<MessageStructure, "timestamp">;
         request_data: JSONValue;
     };
 }
@@ -119,9 +129,7 @@ export interface GatewayListenerMap {
     ready: (event: GatewayReady["d"]) => void;
     channelSync: (event: GatewayChannelSync["d"]) => void;
     messageCreate: (event: MessageStructure) => void;
-    messageUpdate: (event: GatewayMessageUpdate["d"] & {
-        timestamp: number;
-    }) => void;
+    messageUpdate: (message: MessageStructure, request_data: JSONValue | undefined) => void;
     aggregateUpdate: (event: GatewayAggregateUpdate["d"]) => void;
     alarmTrigger: (event: GatewayAlarmTrigger["d"]) => void;
     oneShotMessage: (event: GatewayOneShotMessage["d"]) => void;

package/dist/react/index.d.ts

@@ -6,6 +6,7 @@ export { useAgentConnections, agentConnectionsQueryKey, } from "./useAgentConnec
 export { useChannelSubscription, } from "./useChannelSubscription";
 export type { ChannelSubscriptionHandlers } from "./useChannelSubscription";
 export { useChannelAggregate, channelAggregateQueryKey, } from "./useChannelAggregate";
+export type { UseChannelAggregateResult } from "./useChannelAggregate";
 export { useAgentChannel } from "./useAgentChannel";
 export { useSendMessage } from "./useSendMessage";
 export { useUpdateAggregate } from "./useUpdateAggregate";

package/dist/react/useAgentChannel.d.ts

@@ -4,4 +4,4 @@ import type { Aggregate } from "../types/common";
  * and channel name as separate arguments — the most common shape at call
  * sites where the identifier isn't already a `ChannelIdentifier`.
  */
-export declare function useAgentChannel<TData extends Aggregate["data"] = Aggregate["data"]>(agentId: string | undefined, channelName: string): import("@tanstack/react-query").UseQueryResult<Aggregate<TData> | undefined>;
+export declare function useAgentChannel<TData = Aggregate["data"]>(agentId: string | undefined, channelName: string): import("./useChannelAggregate").UseChannelAggregateResult<TData>;

package/dist/react/useChannelAggregate.d.ts

@@ -2,12 +2,32 @@ import { type UseQueryResult } from "@tanstack/react-query";
 import type { Aggregate } from "../types/common";
 import type { ChannelIdentifier } from "../types/viewer";
 export declare function channelAggregateQueryKey(agentId: string | undefined, channelName: string | undefined): readonly ["doover", "agent", string | undefined, "channel", string | undefined];
+/**
+ * Shape returned by `useChannelAggregate`. Shadows the react-query
+ * `data` field with the unwrapped aggregate payload (`TData`) so the
+ * common call-site pattern — `const { data } = useChannelAggregate(…)` —
+ * just works without a secondary `.data` access or cast. The
+ * `attachments` and `last_updated` slots are hoisted alongside for the
+ * same reason; everything else (isLoading, isError, refetch, status,
+ * …) passes through from react-query unchanged.
+ */
+export interface UseChannelAggregateResult<TData> extends Omit<UseQueryResult<Aggregate<TData> | undefined>, "data"> {
+    /** The aggregate payload. `undefined` until the first fetch lands. */
+    data: TData | undefined;
+    /** Attachments (files/blobs) on the aggregate. */
+    attachments: Aggregate["attachments"] | undefined;
+    /** Server timestamp (epoch seconds) of the last aggregate update. */
+    last_updated: number | null | undefined;
+}
 /**
  * Fetch a channel's aggregate and keep it live via the gateway. Incoming
  * `channelSync` and `aggregateUpdate` events patch the react-query cache
  * under `channelAggregateQueryKey(agentId, channelName)`.
  *
  * Typed on `TData` — the shape of `aggregate.data`. Defaults to the generic
- * `Record<string, JSONValue>` used by `Aggregate`.
+ * `Record<string, JSONValue>` used by `Aggregate`. No `extends` constraint
+ * on the generic: typed aggregate interfaces (e.g. `{ enabled: boolean }`)
+ * don't have the implicit index signature that `Aggregate["data"]` carries
+ * and enforcing compatibility there just forces `as` casts at call sites.
  */
-export declare function useChannelAggregate<TData extends Aggregate["data"] = Aggregate["data"]>(identifier: ChannelIdentifier): UseQueryResult<Aggregate<TData> | undefined>;
+export declare function useChannelAggregate<TData = Aggregate["data"]>(identifier: ChannelIdentifier): UseChannelAggregateResult<TData>;

package/dist/react/useChannelAggregate.js

@@ -15,7 +15,10 @@ function channelAggregateQueryKey(agentId, channelName) {
  * under `channelAggregateQueryKey(agentId, channelName)`.
  *
  * Typed on `TData` — the shape of `aggregate.data`. Defaults to the generic
- * `Record<string, JSONValue>` used by `Aggregate`.
+ * `Record<string, JSONValue>` used by `Aggregate`. No `extends` constraint
+ * on the generic: typed aggregate interfaces (e.g. `{ enabled: boolean }`)
+ * don't have the implicit index signature that `Aggregate["data"]` carries
+ * and enforcing compatibility there just forces `as` casts at call sites.
  */
 function useChannelAggregate(identifier) {
     const client = (0, context_1.useDooverClient)();
@@ -29,10 +32,18 @@ function useChannelAggregate(identifier) {
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [queryClient, agentId, channelName]);
     (0, useChannelSubscription_1.useChannelSubscription)(identifier, { onAggregate });
-    return (0, react_query_1.useQuery)({
+    const query = (0, react_query_1.useQuery)({
         queryKey: key,
         enabled: !!agentId && !!channelName,
         staleTime: Infinity,
         queryFn: () => client.viewer.getAggregate(identifier),
     });
+    const aggregate = query.data;
+    const { data: _ignored, ...rest } = query;
+    return {
+        ...rest,
+        data: aggregate?.data,
+        attachments: aggregate?.attachments,
+        last_updated: aggregate?.last_updated,
+    };
 }

package/dist/react/useChannelSubscription.d.ts

@@ -1,8 +1,13 @@
-import type { Aggregate, MessageStructure } from "../types/common";
+import type { Aggregate, JSONValue, MessageStructure } from "../types/common";
 import type { ChannelIdentifier } from "../types/viewer";
 export interface ChannelSubscriptionHandlers {
     onMessage?: (message: MessageStructure) => void;
-    onMessageUpdate?: (message: MessageStructure) => void;
+    /**
+     * Fires on server-side MessageUpdate events. `message` is the full updated
+     * MessageStructure; `request_data` (optional) is the diff of what changed
+     * in this specific update. Most consumers only need `message`.
+     */
+    onMessageUpdate?: (message: MessageStructure, request_data?: JSONValue) => void;
     onAggregate?: (aggregate: Aggregate) => void;
 }
 /**

package/dist/react/useChannelSubscription.js

@@ -24,8 +24,8 @@ function useChannelSubscription(identifier, handlers) {
         const aggregateCallback = (_id, aggregate) => {
             handlersRef.current.onAggregate?.(aggregate);
         };
-        const messageUpdateCallback = (_id, message) => {
-            handlersRef.current.onMessageUpdate?.(message);
+        const messageUpdateCallback = (_id, message, request_data) => {
+            handlersRef.current.onMessageUpdate?.(message, request_data);
         };
         void client.viewer.subscribeToChannel(identifier, messageCallback, aggregateCallback, messageUpdateCallback);
         return () => {

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

@@ -289,36 +289,44 @@ const helpers_1 = require("./helpers");
             op: 0,
             t: "MessageUpdate",
             d: {
-                id: rpcId,
-                author_id: "u1",
                 channel: { agent_id: "a1", name: "c1" },
-                data: {
-                    type: "rpc",
-                    method: "ping",
-                    request: {},
-                    status: { code: "acknowledged", message: { timestamp: 1 } },
-                    response: {},
+                author_id: "u1",
+                message: {
+                    id: rpcId,
+                    author_id: "u1",
+                    channel: { agent_id: "a1", name: "c1" },
+                    data: {
+                        type: "rpc",
+                        method: "ping",
+                        request: {},
+                        status: { code: "acknowledged", message: { timestamp: 1 } },
+                        response: {},
+                    },
+                    attachments: [],
                 },
-                attachments: [],
-                request_data: {},
+                request_data: { status: { code: "acknowledged", message: { timestamp: 1 } } },
             },
         });
         ws.receive({
             op: 0,
             t: "MessageUpdate",
             d: {
-                id: rpcId,
-                author_id: "u1",
                 channel: { agent_id: "a1", name: "c1" },
-                data: {
-                    type: "rpc",
-                    method: "ping",
-                    request: {},
-                    status: { code: "success" },
-                    response: { pong: true },
+                author_id: "u1",
+                message: {
+                    id: rpcId,
+                    author_id: "u1",
+                    channel: { agent_id: "a1", name: "c1" },
+                    data: {
+                        type: "rpc",
+                        method: "ping",
+                        request: {},
+                        status: { code: "success" },
+                        response: { pong: true },
+                    },
+                    attachments: [],
                 },
-                attachments: [],
-                request_data: {},
+                request_data: { status: { code: "success" }, response: { pong: true } },
             },
         });
         await (0, chai_1.expect)(promise).to.eventually.deep.equal({ pong: true });
@@ -366,18 +374,22 @@ const helpers_1 = require("./helpers");
             op: 0,
             t: "MessageUpdate",
             d: {
-                id: rpcId,
-                author_id: "u1",
                 channel: { agent_id: "a1", name: "c1" },
-                data: {
-                    type: "rpc",
-                    method: "ping",
-                    request: {},
-                    status: { code: "error", message: "boom" },
-                    response: {},
+                author_id: "u1",
+                message: {
+                    id: rpcId,
+                    author_id: "u1",
+                    channel: { agent_id: "a1", name: "c1" },
+                    data: {
+                        type: "rpc",
+                        method: "ping",
+                        request: {},
+                        status: { code: "error", message: "boom" },
+                        response: {},
+                    },
+                    attachments: [],
                 },
-                attachments: [],
-                request_data: {},
+                request_data: { status: { code: "error", message: "boom" } },
             },
         });
         await (0, chai_1.expect)(promise).to.eventually.be.rejectedWith("boom");

package/dist/test/gateway-client.test.js

@@ -115,12 +115,16 @@ const helpers_1 = require("./helpers");
             op: 0,
             t: "MessageUpdate",
             d: {
-                id,
-                author_id: "u1",
                 channel: { agent_id: "a1", name: "c1" },
-                data: {},
-                attachments: [],
-                request_data: {},
+                author_id: "u1",
+                message: {
+                    id,
+                    author_id: "u1",
+                    channel: { agent_id: "a1", name: "c1" },
+                    data: { full: true },
+                    attachments: [],
+                },
+                request_data: { diff: true },
             },
         });
         ws.receive({
@@ -195,7 +199,7 @@ const helpers_1 = require("./helpers");
         });
         (0, chai_1.expect)(channelSync.calledOnce).to.equal(true);
         (0, chai_1.expect)(messageCreate.calledWithMatch(sinon_1.default.match({ id, timestamp: sinon_1.default.match.number }))).to.equal(true);
-        (0, chai_1.expect)(messageUpdate.calledWithMatch(sinon_1.default.match({ id, timestamp: sinon_1.default.match.number }))).to.equal(true);
+        (0, chai_1.expect)(messageUpdate.calledWithMatch(sinon_1.default.match({ id, data: { full: true }, timestamp: sinon_1.default.match.number }), sinon_1.default.match({ diff: true }))).to.equal(true);
         (0, chai_1.expect)(aggregateUpdate.calledOnce).to.equal(true);
         (0, chai_1.expect)(alarmTrigger.calledOnce).to.equal(true);
         (0, chai_1.expect)(oneShot.calledOnce).to.equal(true);

package/dist/test/react.test.js

@@ -131,7 +131,8 @@ function wrapper(client) {
             wrapper: Wrapper,
         });
         await (0, react_1.waitFor)(() => (0, chai_1.expect)(result.current.isSuccess).to.equal(true));
-        (0, chai_1.expect)(result.current.data?.data).to.deep.equal({ x: 1 });
+        (0, chai_1.expect)(result.current.data).to.deep.equal({ x: 1 });
+        (0, chai_1.expect)(result.current.attachments).to.deep.equal([]);
         // Drive a live aggregate update.
         await (0, react_1.act)(async () => {
             const ws = helpers_1.MockWebSocket.instances[0];
@@ -154,7 +155,7 @@ function wrapper(client) {
                 },
             });
         });
-        await (0, react_1.waitFor)(() => (0, chai_1.expect)(result.current.data?.data).to.deep.equal({ x: 2 }));
+        await (0, react_1.waitFor)(() => (0, chai_1.expect)(result.current.data).to.deep.equal({ x: 2 }));
     });
     (0, mocha_1.it)("useSendMessage posts via MessagesApi", async () => {
         const fetchMock = (0, helpers_1.createFetchMock)((url) => {
@@ -327,18 +328,22 @@ function wrapper(client) {
                 op: 0,
                 t: "MessageUpdate",
                 d: {
-                    id: rpcId,
-                    author_id: "u1",
                     channel: { agent_id: "a1", name: "ui_cmds" },
-                    data: {
-                        type: "rpc",
-                        method: "ping",
-                        request: {},
-                        status: { code: "success" },
-                        response: { pong: true },
+                    author_id: "u1",
+                    message: {
+                        id: rpcId,
+                        author_id: "u1",
+                        channel: { agent_id: "a1", name: "ui_cmds" },
+                        data: {
+                            type: "rpc",
+                            method: "ping",
+                            request: {},
+                            status: { code: "success" },
+                            response: { pong: true },
+                        },
+                        attachments: [],
                     },
-                    attachments: [],
-                    request_data: {},
+                    request_data: { status: { code: "success" }, response: { pong: true } },
                 },
             });
             return promise;

package/dist/viewer/doover-data-provider.d.ts

@@ -6,12 +6,17 @@ import { MessagesApi, type ListMessagesParams } from "../apis/messages-api";
 import type { DooverAuth } from "../auth/doover-auth";
 import { GatewayClient } from "../gateway/gateway-client";
 import { RestClient, type DooverClientConfig } from "../http/rest-client";
-import type { Aggregate, Channel, ConnectionDetails, MessageStructure, RpcRequest, RpcStatus } from "../types/common";
+import type { Aggregate, Channel, ConnectionDetails, JSONValue, MessageStructure, RpcRequest, RpcStatus } from "../types/common";
 import type { Agent, AgentsResponse, ChannelIdentifier, ChannelsDataProvider, SubscriptionDetails, User } from "../types/viewer";
 interface SubscriptionEntry {
     messageCallback: (identifier: ChannelIdentifier, message: MessageStructure) => void;
     aggregateCallback: (identifier: ChannelIdentifier, aggregate: Aggregate) => void;
-    messageUpdateCallback?: (identifier: ChannelIdentifier, message: MessageStructure) => void;
+    /**
+     * `message` is the full post-update MessageStructure (server-side `.message`
+     * field). `request_data` is the diff of just-changed fields, or undefined
+     * if the server didn't provide one. Most consumers only need `message`.
+     */
+    messageUpdateCallback?: (identifier: ChannelIdentifier, message: MessageStructure, request_data?: JSONValue) => void;
 }
 export declare class DooverDataProvider implements ChannelsDataProvider<ChannelIdentifier> {
     private readonly config;

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

@@ -34,10 +34,10 @@ 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) => {
+        this.gateway.on("messageUpdate", (message, request_data) => {
             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.subscriptions.get(key)?.forEach((entry) => entry.messageUpdateCallback?.(identifier, message, request_data));
         });
         this.gateway.on("channelSync", (event) => {
             const key = this.channelKey(event.channel.agent_id, event.channel.name);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "doover-js",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "description": "TypeScript client for Doover.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",