@poolse/react 0.1.0 → 0.2.0-alpha.2

package/CHANGELOG.md

@@ -4,6 +4,45 @@ All notable changes to `@poolse/react` are documented here. Format follows
 [Keep a Changelog](https://keepachangelog.com/en/1.1.0/); versions follow
 [semver](https://semver.org).
 
+## [0.2.0] — 2026-06-01
+
+### Added
+
+- `useMessages.edit(messageId, body)` — optimistic edit with rollback
+  on server error. Server enforces sender-only authorization.
+- `useMessages.delete(messageId)` — optimistic soft-delete (sets
+  `deleted_at` + null body locally, rolls back on error).
+- `useMessages.markReadUpTo(messageId)` — wraps
+  `chat.conversations.one(id).messages.markRead`; advances the
+  caller's read cursor and triggers server-side read-receipt
+  broadcasts to other members.
+- `useConversations` now exposes `unreadCounts: Record<convId, number>`
+  plus `markConversationRead(convId)` for sidebar-badge UIs.
+- `useThread.edit(messageId, body)` / `useThread.delete(messageId)`
+  for inline reply editing inside `<ThreadView>`.
+
+### Changed
+
+- `useMembers(conversationId)` now treats an empty string id as
+  "skip fetch" (returns `{ members: [], loading: false }`) so
+  callers can conditionally enable member loading without wrapping
+  in a `enabled ?` guard.
+- `useMembers` subscribes to the new `member:read` realtime event
+  and advances the matching membership's `last_read_message_id` /
+  `last_read_at` in place. The sender's check-double glyph now
+  flips in real time without a refetch.
+- Provider auto-resolves the SDK's new default `apiUrl` when none
+  is passed in config.
+
+## [0.1.1] — 2026-06-01
+
+### Fixed
+
+- `useMessages.send()` now stamps the optimistic temp message's
+  `sender_id` with the current user's id (via `useMe` internally).
+  Without this, self-sent messages briefly rendered on the "other"
+  side of the chat until the realtime echo replaced them.
+
 ## [0.1.0] — 2026-06-01
 
 First publishable release.

package/dist/index.cjs

@@ -19,7 +19,9 @@ function PoolseProvider({ config, children }) {
       socketPath: initial.socketPath
     };
     return new sdk.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(),
@@ -162,7 +164,21 @@ function useConversations() {
     });
     return off;
   }, [chat, me]);
-  return { conversations, loading, error, refetch, create };
+  const markConversationRead = react.useCallback((conversationId) => {
+    setConversations(
+      (prev) => prev.map((c) => c.id === conversationId ? { ...c, unread_count: 0 } : c)
+    );
+  }, []);
+  const unreadCounts = react.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);
@@ -180,6 +196,12 @@ function useMembers(conversationId) {
   membersRef.current = members;
   const fetcher = react.useCallback(
     async (signal) => {
+      if (!conversationId) {
+        setLoading(false);
+        setMembers([]);
+        setError(null);
+        return;
+      }
       setLoading(true);
       setError(null);
       try {
@@ -199,6 +221,22 @@ function useMembers(conversationId) {
     void fetcher(controller.signal);
     return () => controller.abort();
   }, [fetcher]);
+  react.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 = react.useCallback(() => fetcher(), [fetcher]);
   const addMembers = react.useCallback(
     async (externalIds, opts = {}) => {
@@ -231,11 +269,14 @@ function useMembers(conversationId) {
 var PAGE_SIZE = 50;
 function useMessages(conversationId) {
   const chat = usePoolse();
+  const { me } = useMe();
   const [messages, setMessages] = react.useState([]);
   const [loading, setLoading] = react.useState(true);
   const [error, setError] = react.useState(null);
   const [hasMore, setHasMore] = react.useState(true);
   const oldestSequenceRef = react.useRef(null);
+  const meIdRef = react.useRef(me?.id ?? null);
+  meIdRef.current = me?.id ?? null;
   react.useEffect(() => {
     let cancelled = false;
     setLoading(true);
@@ -298,9 +339,13 @@ function useMessages(conversationId) {
         id,
         tenant_id: "",
         conversation_id: conversationId,
-        sender_id: null,
+        // Stamp the current user's id so the optimistic row renders
+        // on the right (self) side from the moment it appears. Null
+        // here would briefly flash the row on the "other" side until
+        // 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 ?? [],
@@ -325,7 +370,69 @@ function useMessages(conversationId) {
     },
     [chat, conversationId]
   );
-  return { messages, loading, error, hasMore, loadMore, send };
+  const edit = react.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 = react.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 = react.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);
@@ -469,7 +576,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 ?? [],
@@ -496,7 +603,62 @@ function useThread(conversationId, rootMessageId) {
     },
     [chat, conversationId, rootMessageId]
   );
-  return { replies, loading, error, hasMore, loadMore, sendReply };
+  const edit = react.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 = react.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);