@poolse/react 0.1.1 → 0.2.0-alpha.3

package/dist/index.d.cts

@@ -88,6 +88,20 @@ interface UseConversationsState {
     error: Error | null;
     refetch: () => Promise<void>;
     create: (attrs: ConversationCreateRequest) => Promise<Conversation>;
+    /**
+     * Per-conversation unread count, keyed by conversation id. Sourced
+     * from `Conversation.unread_count` on the initial fetch and kept
+     * fresh as the caller marks conversations read (via `markRead`).
+     *
+     * Note: cross-conversation incrementing on a new inbound message
+     * requires subscribing to every conversation channel, which the SDK
+     * doesn't do by default. Counts in this map are accurate for the
+     * conversation the caller has open + correct at fetch time for the
+     * rest; refetch on a fresh tab focus for true reconciliation.
+     */
+    unreadCounts: Record<Uuid, number>;
+    /** Force a conversation's unread to 0 — invoked by `markReadUpTo`. */
+    markConversationRead: (conversationId: Uuid) => void;
 }
 /**
  * List of conversations the current End User can see.
@@ -125,11 +139,13 @@ interface UseMembersState {
 }
 /**
  * Live-ish membership list for a conversation. Initial REST fetch on
- * mount; mutation helpers update local state in place. No realtime
- * sync yet — the backend doesn't broadcast `member:joined` /
- * `member:left` events. For now, callers who depend on
- * cross-client member updates should poll with `refetch()` or
- * remount the hook.
+ * mount; mutation helpers update local state in place.
+ *
+ * Realtime: subscribes to `member:read` on the conversation channel
+ * and advances the matching membership's `last_read_message_id` /
+ * `last_read_at` so the sender's read-receipt glyph flips from "sent"
+ * to "read" without a refetch. `member:joined` / `member:left` aren't
+ * broadcast yet — for cross-client adds/removes, call `refetch()`.
  */
 declare function useMembers(conversationId: Uuid): UseMembersState;
 
@@ -143,6 +159,26 @@ interface UseMessagesState {
     loadMore: () => Promise<void>;
     /** Optimistically append + POST. Replaces the optimistic row with the server response on success. */
     send: (attrs: MessageCreateRequest) => Promise<Message>;
+    /**
+     * Edit a message you previously sent. Optimistically updates the
+     * local row, rolls back on server error. Server enforces
+     * sender-only authorization — calling this for a message you didn't
+     * send will throw an ApiError.
+     */
+    edit: (messageId: Uuid, body: string) => Promise<Message>;
+    /**
+     * Soft-delete a message you sent (or that you have admin authority
+     * over). Optimistically applies the tombstone (`deleted_at` + null
+     * body) locally, rolls back on error.
+     */
+    delete: (messageId: Uuid) => Promise<void>;
+    /**
+     * Advance the caller's read cursor to `messageId`. Server emits
+     * read-receipt updates to other members; the conversation's
+     * unread count drops to zero. No local state mutation — this is
+     * "tell the server we read up to here".
+     */
+    markReadUpTo: (messageId: Uuid) => Promise<void>;
 }
 /**
  * Live message list for `conversationId`. Combines:
@@ -225,6 +261,16 @@ interface UseThreadState {
      * `MessageCreateRequest` fields) as you would to `useMessages.send`.
      */
     sendReply: (attrs: Omit<MessageCreateRequest, 'reply_to_id'>) => Promise<Message>;
+    /**
+     * Edit a reply (or the root message). Optimistic with rollback —
+     * mirrors `useMessages.edit`. Server enforces sender-only authz.
+     */
+    edit: (messageId: Uuid, body: string) => Promise<Message>;
+    /**
+     * Soft-delete a reply (or the root message). Optimistic tombstone
+     * (`deleted_at` + null body) — mirrors `useMessages.delete`.
+     */
+    delete: (messageId: Uuid) => Promise<void>;
 }
 /**
  * Thread view rooted at `rootMessageId`. Loads replies oldest-first

package/dist/index.d.ts

@@ -88,6 +88,20 @@ interface UseConversationsState {
     error: Error | null;
     refetch: () => Promise<void>;
     create: (attrs: ConversationCreateRequest) => Promise<Conversation>;
+    /**
+     * Per-conversation unread count, keyed by conversation id. Sourced
+     * from `Conversation.unread_count` on the initial fetch and kept
+     * fresh as the caller marks conversations read (via `markRead`).
+     *
+     * Note: cross-conversation incrementing on a new inbound message
+     * requires subscribing to every conversation channel, which the SDK
+     * doesn't do by default. Counts in this map are accurate for the
+     * conversation the caller has open + correct at fetch time for the
+     * rest; refetch on a fresh tab focus for true reconciliation.
+     */
+    unreadCounts: Record<Uuid, number>;
+    /** Force a conversation's unread to 0 — invoked by `markReadUpTo`. */
+    markConversationRead: (conversationId: Uuid) => void;
 }
 /**
  * List of conversations the current End User can see.
@@ -125,11 +139,13 @@ interface UseMembersState {
 }
 /**
  * Live-ish membership list for a conversation. Initial REST fetch on
- * mount; mutation helpers update local state in place. No realtime
- * sync yet — the backend doesn't broadcast `member:joined` /
- * `member:left` events. For now, callers who depend on
- * cross-client member updates should poll with `refetch()` or
- * remount the hook.
+ * mount; mutation helpers update local state in place.
+ *
+ * Realtime: subscribes to `member:read` on the conversation channel
+ * and advances the matching membership's `last_read_message_id` /
+ * `last_read_at` so the sender's read-receipt glyph flips from "sent"
+ * to "read" without a refetch. `member:joined` / `member:left` aren't
+ * broadcast yet — for cross-client adds/removes, call `refetch()`.
  */
 declare function useMembers(conversationId: Uuid): UseMembersState;
 
@@ -143,6 +159,26 @@ interface UseMessagesState {
     loadMore: () => Promise<void>;
     /** Optimistically append + POST. Replaces the optimistic row with the server response on success. */
     send: (attrs: MessageCreateRequest) => Promise<Message>;
+    /**
+     * Edit a message you previously sent. Optimistically updates the
+     * local row, rolls back on server error. Server enforces
+     * sender-only authorization — calling this for a message you didn't
+     * send will throw an ApiError.
+     */
+    edit: (messageId: Uuid, body: string) => Promise<Message>;
+    /**
+     * Soft-delete a message you sent (or that you have admin authority
+     * over). Optimistically applies the tombstone (`deleted_at` + null
+     * body) locally, rolls back on error.
+     */
+    delete: (messageId: Uuid) => Promise<void>;
+    /**
+     * Advance the caller's read cursor to `messageId`. Server emits
+     * read-receipt updates to other members; the conversation's
+     * unread count drops to zero. No local state mutation — this is
+     * "tell the server we read up to here".
+     */
+    markReadUpTo: (messageId: Uuid) => Promise<void>;
 }
 /**
  * Live message list for `conversationId`. Combines:
@@ -225,6 +261,16 @@ interface UseThreadState {
      * `MessageCreateRequest` fields) as you would to `useMessages.send`.
      */
     sendReply: (attrs: Omit<MessageCreateRequest, 'reply_to_id'>) => Promise<Message>;
+    /**
+     * Edit a reply (or the root message). Optimistic with rollback —
+     * mirrors `useMessages.edit`. Server enforces sender-only authz.
+     */
+    edit: (messageId: Uuid, body: string) => Promise<Message>;
+    /**
+     * Soft-delete a reply (or the root message). Optimistic tombstone
+     * (`deleted_at` + null body) — mirrors `useMessages.delete`.
+     */
+    delete: (messageId: Uuid) => Promise<void>;
 }
 /**
  * Thread view rooted at `rootMessageId`. Loads replies oldest-first

package/dist/index.js

@@ -18,7 +18,9 @@ function PoolseProvider({ config, children }) {
       socketPath: initial.socketPath
     };
     return new Poolse({
-      apiUrl: initial.apiUrl,
+      // apiUrl is optional in PoolseConfig — only forward when set
+      // so the SDK can fall back to its hosted-endpoint default.
+      ...initial.apiUrl !== void 0 ? { apiUrl: initial.apiUrl } : {},
       // Always read the latest callbacks from the ref — they're free
       // to change between renders.
       getToken: () => configRef.current.getToken(),
@@ -161,7 +163,21 @@ function useConversations() {
     });
     return off;
   }, [chat, me]);
-  return { conversations, loading, error, refetch, create };
+  const markConversationRead = useCallback((conversationId) => {
+    setConversations(
+      (prev) => prev.map((c) => c.id === conversationId ? { ...c, unread_count: 0 } : c)
+    );
+  }, []);
+  const unreadCounts = useMemo(() => {
+    const out = {};
+    for (const c of conversations) {
+      if (typeof c.unread_count === "number" && c.unread_count > 0) {
+        out[c.id] = c.unread_count;
+      }
+    }
+    return out;
+  }, [conversations]);
+  return { conversations, loading, error, refetch, create, unreadCounts, markConversationRead };
 }
 function prepend(prev, conv) {
   const idx = prev.findIndex((c) => c.id === conv.id);
@@ -179,6 +195,12 @@ function useMembers(conversationId) {
   membersRef.current = members;
   const fetcher = useCallback(
     async (signal) => {
+      if (!conversationId) {
+        setLoading(false);
+        setMembers([]);
+        setError(null);
+        return;
+      }
       setLoading(true);
       setError(null);
       try {
@@ -198,6 +220,22 @@ function useMembers(conversationId) {
     void fetcher(controller.signal);
     return () => controller.abort();
   }, [fetcher]);
+  useEffect(() => {
+    if (!conversationId) return;
+    const channel = chat.realtime.conversation(conversationId);
+    const off = channel.onMemberRead((evt) => {
+      setMembers(
+        (prev) => prev.map(
+          (m) => m.user_id === evt.user_id ? {
+            ...m,
+            last_read_message_id: evt.last_read_message_id,
+            last_read_at: evt.last_read_at
+          } : m
+        )
+      );
+    });
+    return () => off();
+  }, [chat, conversationId]);
   const refetch = useCallback(() => fetcher(), [fetcher]);
   const addMembers = useCallback(
     async (externalIds, opts = {}) => {
@@ -306,7 +344,7 @@ function useMessages(conversationId) {
         // the realtime echo replaced it with the canonical row.
         sender_id: meIdRef.current,
         type: attrs.type ?? "text",
-        body: attrs.body,
+        body: attrs.body ?? null,
         reply_to_id: attrs.reply_to_id ?? null,
         thread_root_id: null,
         mentions: attrs.mentions ?? [],
@@ -331,7 +369,69 @@ function useMessages(conversationId) {
     },
     [chat, conversationId]
   );
-  return { messages, loading, error, hasMore, loadMore, send };
+  const edit = useCallback(
+    async (messageId, body) => {
+      let previous;
+      setMessages(
+        (prev) => prev.map((m) => {
+          if (m.id !== messageId) return m;
+          previous = m;
+          return { ...m, body, edited_at: (/* @__PURE__ */ new Date()).toISOString() };
+        })
+      );
+      try {
+        const updated = await chat.messages.one(messageId).update({ body });
+        setMessages((prev) => prev.map((m) => m.id === messageId ? updated : m));
+        return updated;
+      } catch (err) {
+        if (previous) {
+          const restore = previous;
+          setMessages((prev) => prev.map((m) => m.id === messageId ? restore : m));
+        }
+        throw err;
+      }
+    },
+    [chat]
+  );
+  const deleteMessage = useCallback(
+    async (messageId) => {
+      let previous;
+      setMessages(
+        (prev) => prev.map((m) => {
+          if (m.id !== messageId) return m;
+          previous = m;
+          return { ...m, body: null, deleted_at: (/* @__PURE__ */ new Date()).toISOString() };
+        })
+      );
+      try {
+        await chat.messages.one(messageId).delete();
+      } catch (err) {
+        if (previous) {
+          const restore = previous;
+          setMessages((prev) => prev.map((m) => m.id === messageId ? restore : m));
+        }
+        throw err;
+      }
+    },
+    [chat]
+  );
+  const markReadUpTo = useCallback(
+    async (messageId) => {
+      await chat.conversations.one(conversationId).messages.markRead(messageId);
+    },
+    [chat, conversationId]
+  );
+  return {
+    messages,
+    loading,
+    error,
+    hasMore,
+    loadMore,
+    send,
+    edit,
+    delete: deleteMessage,
+    markReadUpTo
+  };
 }
 function upsertById(prev, msg) {
   const idx = prev.findIndex((m) => m.id === msg.id);
@@ -475,7 +575,7 @@ function useThread(conversationId, rootMessageId) {
         conversation_id: conversationId,
         sender_id: null,
         type: attrs.type ?? "text",
-        body: attrs.body,
+        body: attrs.body ?? null,
         reply_to_id: rootMessageId,
         thread_root_id: rootMessageId,
         mentions: attrs.mentions ?? [],
@@ -502,7 +602,62 @@ function useThread(conversationId, rootMessageId) {
     },
     [chat, conversationId, rootMessageId]
   );
-  return { replies, loading, error, hasMore, loadMore, sendReply };
+  const edit = useCallback(
+    async (messageId, body) => {
+      let previous;
+      setReplies(
+        (prev) => prev.map((m) => {
+          if (m.id !== messageId) return m;
+          previous = m;
+          return { ...m, body, edited_at: (/* @__PURE__ */ new Date()).toISOString() };
+        })
+      );
+      try {
+        const updated = await chat.messages.one(messageId).update({ body });
+        setReplies((prev) => prev.map((m) => m.id === messageId ? updated : m));
+        return updated;
+      } catch (err) {
+        if (previous) {
+          const restore = previous;
+          setReplies((prev) => prev.map((m) => m.id === messageId ? restore : m));
+        }
+        throw err;
+      }
+    },
+    [chat]
+  );
+  const deleteReply = useCallback(
+    async (messageId) => {
+      let previous;
+      setReplies(
+        (prev) => prev.map((m) => {
+          if (m.id !== messageId) return m;
+          previous = m;
+          return { ...m, body: null, deleted_at: (/* @__PURE__ */ new Date()).toISOString() };
+        })
+      );
+      try {
+        await chat.messages.one(messageId).delete();
+      } catch (err) {
+        if (previous) {
+          const restore = previous;
+          setReplies((prev) => prev.map((m) => m.id === messageId ? restore : m));
+        }
+        throw err;
+      }
+    },
+    [chat]
+  );
+  return {
+    replies,
+    loading,
+    error,
+    hasMore,
+    loadMore,
+    sendReply,
+    edit,
+    delete: deleteReply
+  };
 }
 function upsertById2(prev, msg) {
   const idx = prev.findIndex((m) => m.id === msg.id);