doover-js 0.4.2 → 0.4.4

package/dist/react/index.d.ts

@@ -6,7 +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 type { UseChannelAggregateOptions, UseChannelAggregateResult, } from "./useChannelAggregate";
 export { useAgentChannel } from "./useAgentChannel";
 export { useSendMessage } from "./useSendMessage";
 export { useUpdateAggregate } from "./useUpdateAggregate";

package/dist/react/useAgentChannel.d.ts

@@ -1,7 +1,8 @@
 import type { Aggregate } from "../types/common";
+import { type UseChannelAggregateOptions } from "./useChannelAggregate";
 /**
  * Convenience wrapper around `useChannelAggregate` that accepts an agent id
  * 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 = Aggregate["data"]>(agentId: string | undefined, channelName: string): import("./useChannelAggregate").UseChannelAggregateResult<TData>;
+export declare function useAgentChannel<TData = Aggregate["data"]>(agentId: string | undefined, channelName: string, options?: UseChannelAggregateOptions): import("./useChannelAggregate").UseChannelAggregateResult<TData>;

package/dist/react/useAgentChannel.js

@@ -7,6 +7,6 @@ const useChannelAggregate_1 = require("./useChannelAggregate");
  * and channel name as separate arguments — the most common shape at call
  * sites where the identifier isn't already a `ChannelIdentifier`.
  */
-function useAgentChannel(agentId, channelName) {
-    return (0, useChannelAggregate_1.useChannelAggregate)({ agentId, channelName });
+function useAgentChannel(agentId, channelName, options) {
+    return (0, useChannelAggregate_1.useChannelAggregate)({ agentId, channelName }, options);
 }

package/dist/react/useChannelAggregate.d.ts

@@ -19,6 +19,22 @@ export interface UseChannelAggregateResult<TData> extends Omit<UseQueryResult<Ag
     /** Server timestamp (epoch seconds) of the last aggregate update. */
     last_updated: number | null | undefined;
 }
+export interface UseChannelAggregateOptions {
+    /**
+     * Whether to fetch the initial aggregate over REST on mount.
+     *
+     * Defaults to `true` — the hook does a one-shot HTTP GET to seed the cache
+     * before the gateway WebSocket has connected, so the first paint isn't
+     * empty.
+     *
+     * Set to `false` for purely WS-driven consumers that don't want the REST
+     * round-trip (e.g. when the gateway's upsert-on-subscribe semantics make
+     * the REST call redundant or actively wrong, like channels that don't yet
+     * exist). The cache is then populated only by `ChannelSync` /
+     * `AggregateUpdate` events.
+     */
+    fetchInitial?: boolean;
+}
 /**
  * Fetch a channel's aggregate and keep it live via the gateway. Incoming
  * `channelSync` and `aggregateUpdate` events patch the react-query cache
@@ -30,4 +46,4 @@ export interface UseChannelAggregateResult<TData> extends Omit<UseQueryResult<Ag
  * 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 = Aggregate["data"]>(identifier: ChannelIdentifier): UseChannelAggregateResult<TData>;
+export declare function useChannelAggregate<TData = Aggregate["data"]>(identifier: ChannelIdentifier, options?: UseChannelAggregateOptions): UseChannelAggregateResult<TData>;

package/dist/react/useChannelAggregate.js

@@ -4,6 +4,7 @@ exports.channelAggregateQueryKey = channelAggregateQueryKey;
 exports.useChannelAggregate = useChannelAggregate;
 const react_1 = require("react");
 const react_query_1 = require("@tanstack/react-query");
+const errors_1 = require("../http/errors");
 const context_1 = require("./context");
 const useChannelSubscription_1 = require("./useChannelSubscription");
 function channelAggregateQueryKey(agentId, channelName) {
@@ -20,11 +21,12 @@ function channelAggregateQueryKey(agentId, channelName) {
  * 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) {
+function useChannelAggregate(identifier, options) {
     const client = (0, context_1.useDooverClient)();
     const queryClient = (0, react_query_1.useQueryClient)();
     const { agentId, channelName } = identifier;
     const key = channelAggregateQueryKey(agentId, channelName);
+    const fetchInitial = options?.fetchInitial ?? true;
     const onAggregate = (0, react_1.useCallback)((aggregate) => {
         queryClient.setQueryData(key, aggregate);
     }, 
@@ -34,9 +36,18 @@ function useChannelAggregate(identifier) {
     (0, useChannelSubscription_1.useChannelSubscription)(identifier, { onAggregate });
     const query = (0, react_query_1.useQuery)({
         queryKey: key,
-        enabled: !!agentId && !!channelName,
+        enabled: fetchInitial && !!agentId && !!channelName,
         staleTime: Infinity,
         queryFn: () => client.viewer.getAggregate(identifier),
+        // A 404 means the aggregate doesn't exist — retrying won't change that,
+        // and the caller needs the error promptly to render an empty/"not
+        // installed" state. Fall back to the react-query default (3 retries) for
+        // every other failure.
+        retry: (failureCount, error) => {
+            if (error instanceof errors_1.DooverApiError && error.status === 404)
+                return false;
+            return failureCount < 3;
+        },
     });
     const aggregate = query.data;
     const { data: _ignored, ...rest } = query;

package/dist/react/useMultiAgentAggregates.d.ts

@@ -1,16 +1,15 @@
 import { type UseQueryResult } from "@tanstack/react-query";
-import type { Aggregate } from "../types/common";
-import type { AgentAggregate } from "../types/openapi";
+import type { Aggregate, JSONValue, AgentAggregate } from "../types/common";
 export declare function multiAgentAggregatesQueryKey(channelName: string, agentIds: string[]): readonly ["doover", "channel", string, "aggregates", string];
 export interface UseMultiAgentAggregatesOptions {
     /** If false, skip per-agent live subscriptions. Defaults true. */
     liveUpdates?: boolean;
 }
-export interface UseMultiAgentAggregatesResult {
+export interface UseMultiAgentAggregatesResult<TData> {
     /** Keyed by `agent_id` for O(1) lookup. */
-    aggregatesByAgent: Record<string, Aggregate>;
+    aggregatesByAgent: Record<string, Aggregate<TData>>;
     query: UseQueryResult<{
-        results: AgentAggregate[];
+        results: AgentAggregate<TData>[];
         count: number;
     }>;
 }
@@ -19,4 +18,4 @@ export interface UseMultiAgentAggregatesResult {
  * agent's slot live via its own gateway subscription. Reconciles per-agent
  * `channelSync`/`aggregateUpdate` events into the batched query cache.
  */
-export declare function useMultiAgentAggregates(channelName: string, agentIds: string[], options?: UseMultiAgentAggregatesOptions): UseMultiAgentAggregatesResult;
+export declare function useMultiAgentAggregates<TData = Record<string, JSONValue>>(channelName: string, agentIds: string[], options?: UseMultiAgentAggregatesOptions): UseMultiAgentAggregatesResult<TData>;

package/dist/react/useMultiAgentChannelMessages.d.ts

@@ -13,13 +13,13 @@ export interface UseMultiAgentChannelMessagesOptions {
     /** Optional first-page `before` cursor (snowflake id). */
     initialBefore?: string;
 }
-interface Page {
-    results: MessageStructure[];
+interface Page<TData> {
+    results: MessageStructure<TData>[];
     next?: string;
 }
-export interface UseMultiAgentChannelMessagesResult extends Omit<UseInfiniteQueryResult<InfiniteData<Page>>, "data"> {
-    messages: MessageStructure[];
-    data: InfiniteData<Page> | undefined;
+export interface UseMultiAgentChannelMessagesResult<TData> extends Omit<UseInfiniteQueryResult<InfiniteData<Page<TData>>>, "data"> {
+    messages: MessageStructure<TData>[];
+    data: InfiniteData<Page<TData>> | undefined;
 }
-export declare function useMultiAgentChannelMessages(channelName: string, agentIds: string[], options?: UseMultiAgentChannelMessagesOptions): UseMultiAgentChannelMessagesResult;
+export declare function useMultiAgentChannelMessages<TData = unknown>(channelName: string, agentIds: string[], options?: UseMultiAgentChannelMessagesOptions): UseMultiAgentChannelMessagesResult<TData>;
 export {};

package/dist/react/useMultiAgentChannelMessages.js

@@ -26,12 +26,13 @@ function useMultiAgentChannelMessages(channelName, agentIds, options) {
         queryClient.setQueryData(key, (current) => {
             if (!current)
                 return current;
+            const typed = message;
             const [firstPage, ...rest] = current.pages;
             const firstResults = firstPage?.results ?? [];
             return {
                 ...current,
                 pages: [
-                    { ...firstPage, results: [message, ...firstResults] },
+                    { ...firstPage, results: [typed, ...firstResults] },
                     ...rest,
                 ],
             };

package/dist/react/useSendMessage.d.ts

@@ -6,4 +6,4 @@ import type { ChannelIdentifier } from "../types/viewer";
  * to the channel and resolves with the created `MessageStructure` (including
  * its server-assigned `id` and `timestamp`).
  */
-export declare function useSendMessage(identifier: ChannelIdentifier): UseMutationResult<MessageStructure, Error, object>;
+export declare function useSendMessage<TData extends object = object>(identifier: ChannelIdentifier): UseMutationResult<MessageStructure<TData>, Error, TData>;

package/dist/react/useUpdateAggregate.d.ts

@@ -18,4 +18,4 @@ export interface UseUpdateAggregateOptions {
  * aggregate into the react-query cache for its channel so consumers of
  * `useChannelAggregate` see the change immediately.
  */
-export declare function useUpdateAggregate(identifier: ChannelIdentifier, options?: UseUpdateAggregateOptions): UseMutationResult<Aggregate, Error, object>;
+export declare function useUpdateAggregate<TData extends object = object>(identifier: ChannelIdentifier, options?: UseUpdateAggregateOptions): UseMutationResult<Aggregate<TData>, Error, TData>;

package/dist/react/useUpdateAggregate.js

@@ -16,9 +16,9 @@ function useUpdateAggregate(identifier, options) {
     const replace = options?.replace ?? false;
     const params = options?.params;
     return (0, react_query_1.useMutation)({
-        mutationFn: (data) => replace
+        mutationFn: (data) => (replace
             ? client.viewer.putAggregate(identifier, data, params)
-            : client.viewer.updateAggregate(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

@@ -15,9 +15,9 @@ export interface UpdateMessageCallOptions {
 }
 export interface UseUpdateMessageOptions extends UpdateMessageCallOptions {
 }
-export interface UpdateMessageVariables {
+export interface UpdateMessageVariables<TBody extends MessageBody = MessageBody> {
     messageId: string;
-    body: MessageBody;
+    body: TBody;
     /**
      * Per-call overrides. Extensible — add new knobs here without breaking
      * the variables shape.
@@ -30,4 +30,4 @@ export interface UpdateMessageVariables {
  * 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>;
+export declare function useUpdateMessage<TBody extends MessageBody = MessageBody>(identifier: ChannelIdentifier, options?: UseUpdateMessageOptions): UseMutationResult<unknown, Error, UpdateMessageVariables<TBody>>;

package/dist/react/useUpdateMessage.js

@@ -14,7 +14,7 @@ function useUpdateMessage(identifier, options) {
     const defaultReplace = options?.replace ?? false;
     const defaultParams = options?.params;
     return (0, react_query_1.useMutation)({
-        mutationFn: ({ messageId, body, options: call }) => {
+        mutationFn: ({ messageId, body, options: call, }) => {
             if (!identifier.agentId || !identifier.channelName) {
                 throw new Error("useUpdateMessage requires both agentId and channelName on the identifier.");
             }

package/package.json

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