doover-js 0.2.0 → 0.3.0

package/dist/react/useChannelMessages.d.ts

@@ -6,6 +6,19 @@ export interface UseChannelMessagesOptions {
     limit?: number;
     /** If false, skip subscribing for live message-create updates. Defaults true. */
     liveUpdates?: boolean;
+    /**
+     * Restrict the returned messages to those whose payload contains any of
+     * these top-level field names. Passed through as `field_name` on the
+     * REST call.
+     */
+    fields?: string[];
+    /**
+     * Optional first-page `before` cursor (snowflake id). Defaults to
+     * unset, which returns the latest messages. Use this when you need to
+     * guard against client-side clock skew (seed with a slightly-future
+     * snowflake so server-stamped messages don't get missed).
+     */
+    initialBefore?: string;
 }
 type Page<TData> = MessageStructure<TData>[];
 export interface UseChannelMessagesResult<TData> extends Omit<UseInfiniteQueryResult<InfiniteData<Page<TData>>>, "data"> {

package/dist/react/useChannelMessages.js

@@ -20,6 +20,8 @@ function useChannelMessages(identifier, options) {
     const { agentId, channelName } = identifier;
     const limit = options?.limit;
     const liveUpdates = options?.liveUpdates ?? true;
+    const fields = options?.fields;
+    const initialBefore = options?.initialBefore;
     const key = channelMessagesQueryKey(agentId, channelName);
     const onMessage = (0, react_1.useCallback)((message) => {
         queryClient.setQueryData(key, (current) => {
@@ -41,12 +43,13 @@ function useChannelMessages(identifier, options) {
         queryKey: key,
         enabled: !!agentId && !!channelName,
         staleTime: Infinity,
-        initialPageParam: undefined,
+        initialPageParam: initialBefore,
         getNextPageParam: (lastPage) => lastPage && lastPage.length > 0 ? lastPage[0]?.id : undefined,
         queryFn: async ({ pageParam }) => {
             const page = await client.viewer.getMessages(identifier, {
                 ...(typeof pageParam === "string" ? { before: pageParam } : {}),
                 ...(limit !== undefined ? { limit } : {}),
+                ...(fields && fields.length > 0 ? { field_name: fields } : {}),
             });
             return (page ?? []);
         },

package/dist/react/useMultiAgentAggregates.js

@@ -5,6 +5,7 @@ exports.useMultiAgentAggregates = useMultiAgentAggregates;
 const react_1 = require("react");
 const react_query_1 = require("@tanstack/react-query");
 const context_1 = require("./context");
+const useChannelAggregate_1 = require("./useChannelAggregate");
 function multiAgentAggregatesQueryKey(channelName, agentIds) {
     return [
         "doover",
@@ -28,7 +29,18 @@ function useMultiAgentAggregates(channelName, agentIds, options) {
         queryKey: key,
         enabled: agentIds.length > 0,
         staleTime: Infinity,
-        queryFn: () => client.agents.getMultiAgentAggregates(channelName, { agent_id: agentIds }),
+        queryFn: async () => {
+            const response = await client.agents.getMultiAgentAggregates(channelName, { agent_id: agentIds });
+            // Seed the per-agent `channelAggregateQueryKey` cache so that
+            // sibling `useChannelAggregate(id, channelName)` calls for any
+            // of these agents get an instant cache hit rather than issuing
+            // a second fetch for data we already have.
+            for (const result of response.results) {
+                const { agent_id, ...aggregate } = result;
+                queryClient.setQueryData((0, useChannelAggregate_1.channelAggregateQueryKey)(agent_id, channelName), aggregate);
+            }
+            return response;
+        },
     });
     const patchAgentAggregate = (0, react_1.useCallback)((agentId, aggregate) => {
         queryClient.setQueryData(key, (current) => {
@@ -44,6 +56,9 @@ function useMultiAgentAggregates(channelName, agentIds, options) {
                 : current.results.map((r, i) => (i === idx ? next : r));
             return { ...current, results };
         });
+        // Mirror live updates into the per-agent cache so sibling
+        // `useChannelAggregate` consumers see them too.
+        queryClient.setQueryData((0, useChannelAggregate_1.channelAggregateQueryKey)(agentId, channelName), aggregate);
     }, 
     // eslint-disable-next-line react-hooks/exhaustive-deps
     [queryClient, channelName, agentIds.join(",")]);

package/dist/react/useMultiAgentChannelMessages.d.ts

@@ -5,6 +5,13 @@ export interface UseMultiAgentChannelMessagesOptions {
     limit?: number;
     /** If false, skip live subscriptions per agent. Defaults true. */
     liveUpdates?: boolean;
+    /**
+     * Restrict the returned messages to those whose payload contains any
+     * of these top-level field names. Forwarded as `field_name`.
+     */
+    fields?: string[];
+    /** Optional first-page `before` cursor (snowflake id). */
+    initialBefore?: string;
 }
 interface Page {
     results: MessageStructure[];

package/dist/react/useMultiAgentChannelMessages.js

@@ -19,6 +19,8 @@ function useMultiAgentChannelMessages(channelName, agentIds, options) {
     const queryClient = (0, react_query_1.useQueryClient)();
     const limit = options?.limit;
     const liveUpdates = options?.liveUpdates ?? true;
+    const fields = options?.fields;
+    const initialBefore = options?.initialBefore;
     const key = multiAgentChannelMessagesQueryKey(channelName, agentIds);
     const prependMessage = (0, react_1.useCallback)((message) => {
         queryClient.setQueryData(key, (current) => {
@@ -62,13 +64,14 @@ function useMultiAgentChannelMessages(channelName, agentIds, options) {
         queryKey: key,
         enabled: agentIds.length > 0,
         staleTime: Infinity,
-        initialPageParam: undefined,
+        initialPageParam: initialBefore,
         getNextPageParam: (lastPage) => lastPage?.next,
         queryFn: async ({ pageParam }) => {
             const page = await client.agents.getMultiAgentMessages(channelName, {
                 agent_id: agentIds,
                 ...(typeof pageParam === "string" ? { before: pageParam } : {}),
                 ...(limit !== undefined ? { limit } : {}),
+                ...(fields && fields.length > 0 ? { field_name: fields } : {}),
             });
             return page;
         },

package/dist/react/useUpdateAggregate.d.ts

@@ -1,9 +1,16 @@
 import { type UseMutationResult } from "@tanstack/react-query";
+import type { AggregateMutationParams } from "../apis/aggregates-api";
 import type { Aggregate } from "../types/common";
 import type { ChannelIdentifier } from "../types/viewer";
 export interface UseUpdateAggregateOptions {
     /** If true, use PUT semantics (replace) instead of PATCH (merge). */
     replace?: boolean;
+    /**
+     * Forwarded as query params to the aggregate endpoint:
+     * `log_update` (record a history message), `clear_attachments`,
+     * `suppress_response`. See `AggregateMutationParams`.
+     */
+    params?: AggregateMutationParams;
 }
 /**
  * Mutation wrapping `DooverDataProvider.updateAggregate` (PATCH) or

package/dist/react/useUpdateAggregate.js

@@ -14,10 +14,11 @@ function useUpdateAggregate(identifier, options) {
     const client = (0, context_1.useDooverClient)();
     const queryClient = (0, react_query_1.useQueryClient)();
     const replace = options?.replace ?? false;
+    const params = options?.params;
     return (0, react_query_1.useMutation)({
         mutationFn: (data) => replace
-            ? client.viewer.putAggregate(identifier, data)
-            : client.viewer.updateAggregate(identifier, data),
+            ? client.viewer.putAggregate(identifier, data, params)
+            : client.viewer.updateAggregate(identifier, data, params),
         onSuccess: (aggregate) => {
             queryClient.setQueryData((0, useChannelAggregate_1.channelAggregateQueryKey)(identifier.agentId, identifier.channelName), aggregate);
         },

package/dist/react/useUpdateMessage.d.ts

@@ -1,17 +1,33 @@
 import { type UseMutationResult } from "@tanstack/react-query";
 import type { MessageBody, MessageMutationParams } from "../apis/messages-api";
 import type { ChannelIdentifier } from "../types/viewer";
-export interface UseUpdateMessageOptions {
-    /** If true, use PUT (replace) instead of PATCH (merge). Default PATCH. */
+export interface UpdateMessageCallOptions {
+    /**
+     * If true, use PUT (replace) instead of PATCH (merge). Falls back to
+     * the hook-level `replace` option, which itself defaults to PATCH.
+     */
     replace?: boolean;
+    /**
+     * Query params forwarded to the message endpoint. Merged over the
+     * hook-level `params` option (per-call keys win).
+     */
     params?: MessageMutationParams;
 }
+export interface UseUpdateMessageOptions extends UpdateMessageCallOptions {
+}
 export interface UpdateMessageVariables {
     messageId: string;
     body: MessageBody;
+    /**
+     * Per-call overrides. Extensible — add new knobs here without breaking
+     * the variables shape.
+     */
+    options?: UpdateMessageCallOptions;
 }
 /**
  * Mutation wrapping `MessagesApi.patchMessage` or `putMessage`. Bound to a
- * single channel; the message id and body are passed per-call.
+ * single channel; the message id and body are passed per-call. Each
+ * invocation can override `replace` / `params` via `variables.options` for
+ * mutation sites that sometimes PUT and sometimes PATCH the same channel.
  */
 export declare function useUpdateMessage(identifier: ChannelIdentifier, options?: UseUpdateMessageOptions): UseMutationResult<unknown, Error, UpdateMessageVariables>;

package/dist/react/useUpdateMessage.js

@@ -5,17 +5,23 @@ const react_query_1 = require("@tanstack/react-query");
 const context_1 = require("./context");
 /**
  * Mutation wrapping `MessagesApi.patchMessage` or `putMessage`. Bound to a
- * single channel; the message id and body are passed per-call.
+ * single channel; the message id and body are passed per-call. Each
+ * invocation can override `replace` / `params` via `variables.options` for
+ * mutation sites that sometimes PUT and sometimes PATCH the same channel.
  */
 function useUpdateMessage(identifier, options) {
     const client = (0, context_1.useDooverClient)();
-    const replace = options?.replace ?? false;
-    const params = options?.params;
+    const defaultReplace = options?.replace ?? false;
+    const defaultParams = options?.params;
     return (0, react_query_1.useMutation)({
-        mutationFn: ({ messageId, body }) => {
+        mutationFn: ({ messageId, body, options: call }) => {
             if (!identifier.agentId || !identifier.channelName) {
                 throw new Error("useUpdateMessage requires both agentId and channelName on the identifier.");
             }
+            const replace = call?.replace ?? defaultReplace;
+            const params = call?.params || defaultParams
+                ? { ...defaultParams, ...call?.params }
+                : undefined;
             return replace
                 ? client.messages.putMessage(identifier.agentId, identifier.channelName, messageId, body, params)
                 : client.messages.patchMessage(identifier.agentId, identifier.channelName, messageId, body, params);

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

@@ -1,5 +1,5 @@
 import { AgentsApi } from "../apis/agents-api";
-import { AggregatesApi } from "../apis/aggregates-api";
+import { AggregatesApi, type AggregateMutationParams } from "../apis/aggregates-api";
 import { ChannelsApi } from "../apis/channels-api";
 import { ConnectionsApi } from "../apis/connections-api";
 import { MessagesApi, type ListMessagesParams } from "../apis/messages-api";
@@ -68,8 +68,8 @@ export declare class DooverDataProvider implements ChannelsDataProvider<ChannelI
     sendRPC<TRequest = object, TResponse = object, TPending = undefined>(identifier: ChannelIdentifier, rpcRequest: RpcRequest<TRequest>, options?: {
         onStatus?: (status: RpcStatus<TPending>) => void;
     }): Promise<TResponse>;
-    updateAggregate(identifier: ChannelIdentifier, message: object): Promise<Aggregate>;
-    putAggregate(identifier: ChannelIdentifier, message: object): Promise<Aggregate>;
+    updateAggregate(identifier: ChannelIdentifier, message: object, params?: AggregateMutationParams): Promise<Aggregate>;
+    putAggregate(identifier: ChannelIdentifier, message: object, params?: AggregateMutationParams): Promise<Aggregate>;
     getChannelSubscriptions(identifier: ChannelIdentifier): Promise<SubscriptionDetails[]>;
     getAgentConnections(identifier: ChannelIdentifier): Promise<ConnectionDetails[]>;
     getIdentifierFromPath(path: string, searchParams: URLSearchParams): {

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

@@ -228,13 +228,13 @@ class DooverDataProvider {
             });
         });
     }
-    updateAggregate(identifier, message) {
+    updateAggregate(identifier, message, params) {
         const validated = this.requireChannel(identifier);
-        return this.aggregatesApi.patchAggregate(validated.agentId, validated.channelName, message);
+        return this.aggregatesApi.patchAggregate(validated.agentId, validated.channelName, message, params);
     }
-    putAggregate(identifier, message) {
+    putAggregate(identifier, message, params) {
         const validated = this.requireChannel(identifier);
-        return this.aggregatesApi.putAggregate(validated.agentId, validated.channelName, message);
+        return this.aggregatesApi.putAggregate(validated.agentId, validated.channelName, message, params);
     }
     getChannelSubscriptions(identifier) {
         const validated = this.requireChannel(identifier);

package/package.json

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