@antzsoft/chat-core 1.3.9 → 1.4.1

package/README.md

@@ -43,7 +43,7 @@ npm install @antzsoft/chat-core
 | Capability | What the SDK provides |
 |---|---|
 | Authentication | Login, register, logout, token refresh (automatic on 401) |
-| Conversations | List, create (group/DM), update, delete, mute, pin, leave, manage members |
+| Conversations | List, create (group/DM), update, delete, mute, pin, mark unread, leave, manage members |
 | Messages | Send, edit, delete, react, star, pin, search, paginate, @mention |
 | Mentions | Group @mentions with `@all` (admin-gated); token parse/build/render helpers; mention pierces mute |
 | File uploads | Presigned URL pipeline — request URL → upload binary (multipart POST for S3/local, PUT for Azure) → confirm. Files ≥ 10 MB on S3 or local use chunked multipart (parallel parts → complete). |
@@ -945,6 +945,8 @@ import { conversationsApi } from '@antzsoft/chat-core';
 | `unmute` | `(conversationId: string) => Promise<void>` | Unmute a conversation. |
 | `pin` | `(conversationId: string) => Promise<void>` | Pin a conversation to the top of the list. Max 5 pins — server returns `400` if the limit is reached. |
 | `unpin` | `(conversationId: string) => Promise<void>` | Unpin a conversation. |
+| `markUnread` | `(conversationId: string) => Promise<void>` | Manually flag a conversation as unread (`Conversation.isManuallyUnread` becomes `true`), independent of `unreadCount`. |
+| `markRead` | `(conversationId: string) => Promise<void>` | Clear the manual unread flag. Also cleared automatically whenever the conversation is opened/read through the normal mark-as-read flow. |
 | `leave` | `(conversationId: string, andDelete?: boolean) => Promise<void>` | Leave a group conversation. Pass `andDelete: true` to also hide it from the caller's list in one atomic operation ("Exit and Delete"). When the last admin calls `leave()`, the server automatically promotes the longest-standing active member to admin before completing the exit — no client action required. |
 | `getMembers` | `(conversationId: string) => Promise<User[]>` | Fetch full user profiles for all participants. |
 
@@ -1165,6 +1167,44 @@ async function onForeground() {
 
 > **Using `@antzsoft/chat-web-sdk` or `@antzsoft/chat-rn-sdk`?** You don't need any of this — `useConversations()` handles socket subscriptions internally. Just sum `conversations.reduce((s, c) => s + (c.unreadCount ?? 0), 0)` and it updates automatically.
 
+#### Mark as Unread (v1.4.1+)
+
+`isManuallyUnread` is a separate flag from `unreadCount` — it lets a user re-flag a conversation they've already read so it stands out again in the list, without fabricating unread messages or moving the read-receipt cursor. This is the same "mark as unread" behavior as WhatsApp/Telegram: a dot indicator, not a count.
+
+| Field / method | Type | Description |
+|---|---|---|
+| `Conversation.isManuallyUnread` | `boolean \| undefined` | `true` once flagged; `false`/absent otherwise. Independent of `unreadCount` — both can be `true`/`>0` at once, or `isManuallyUnread` can be `true` while `unreadCount` is `0`. |
+| `conversationsApi.markUnread(id)` | `Promise<void>` | Sets the flag. |
+| `conversationsApi.markRead(id)` | `Promise<void>` | Clears the flag. |
+
+```typescript
+// Flag a fully-read conversation as unread
+await conversationsApi.markUnread(conversationId);
+
+// Clear it manually (rarely needed — see auto-clear below)
+await conversationsApi.markRead(conversationId);
+
+// Render: numbered badge takes priority; fall back to a plain dot
+const conv = await conversationsApi.get(conversationId);
+if ((conv.unreadCount ?? 0) > 0) {
+  showBadge(conv.unreadCount);
+} else if (conv.isManuallyUnread) {
+  showDot();
+}
+```
+
+**Auto-clears on read.** Opening the conversation — anything that runs the normal mark-as-read flow (socket `mark_read`, or the REST notification-catchup path) — clears `isManuallyUnread` server-side automatically, same as WhatsApp. You do not need to call `markRead()` yourself after the user opens the chat; it's only for the explicit "un-flag without opening" action (e.g. an X button on the dot).
+
+**Live sync across devices.** Unlike `mute`/`pin` (which currently only take effect on the next fetch), toggling `isManuallyUnread` emits a `conversation_updated` socket event to the caller's other connected sessions immediately:
+
+```typescript
+socket?.on('conversation_updated', (conv) => {
+  // conv.isManuallyUnread reflects the latest state, pushed live
+});
+```
+
+**Web/RN SDK hooks expose named mutations:** `markUnread`, `markRead` (both SDKs) — cache updated optimistically, no manual invalidation needed. The built-in `ConversationList` component already renders the dot and exposes the toggle from its existing Pin/Mute menu.
+
 #### Clear / Delete Chat (v1.2.6+)
 
 `conversationsApi.delete(conversationId)` hides a conversation from the caller's list. Any participant can call it — no admin role required. Other participants are completely unaffected.
@@ -2845,6 +2885,7 @@ interface Conversation {
   isPinned?: boolean;
   isMuted?: boolean;
   mutedUntil?: string;
+  isManuallyUnread?: boolean;  // v1.4.1+ — manually flagged unread, independent of unreadCount
 }
 
 interface ConversationSettings {
@@ -3122,6 +3163,24 @@ document.querySelectorAll('[data-conv-id]').forEach((el) => {
 
 ## Changelog
 
+### v1.4.1
+
+- **New: manual "mark as unread."** A conversation can now be flagged unread independently of `unreadCount` — the same UX as WhatsApp/Telegram's "mark as unread": re-flag a conversation you've already read so it stands out again, without fabricating unread messages.
+  - **New field:** `Conversation.isManuallyUnread?: boolean`. Present on every conversation object returned from `conversationsApi.list/get`, and on `conversation_created`/`conversation_updated` socket payloads that carry a full conversation DTO. `false`/absent for a conversation that has never been manually flagged.
+  - **New API methods:** `conversationsApi.markUnread(conversationId)` and `conversationsApi.markRead(conversationId)` — both `Promise<void>`, following the same shape as `pin`/`unpin`.
+  - **Auto-clears on read.** Opening the conversation (anything that calls the existing mark-as-read flow — socket `mark_read` or the REST notification-catchup path) clears the flag server-side automatically, same as WhatsApp: you don't have to manually un-flag it after reading.
+  - **Live sync.** Toggling the flag emits a `conversation_updated` event to the caller's other connected devices/tabs, so mark-unread/mark-read state stays in sync across sessions immediately — unlike `mute`/`pin`, which currently only take effect on next fetch.
+
+  **Backward compatible, additive-only.** `isManuallyUnread` is optional; an older SDK against a server with this change simply ignores the extra field. **No integration changes required** unless you want to surface the new flag/actions in your own conversation list UI (the RN and web SDKs' built-in `ConversationList` already do, see their changelogs).
+
+### v1.4.0
+
+- **Fix: stale transit encryption key after token refresh, causing continuous `"Transit decryption failed for event: user_online"` spam.** `reconnectSocket()` called `socket.connect()` to apply a refreshed token while preserving the transit session — but socket.io-client's `connect()` is a no-op on an already-connected socket. A token refresh fires while the user is actively on a chat screen (socket still connected), so the new auth was never actually sent; the socket kept running on the stale token until the server eventually dropped it, and the disconnect handler then cleared the transit session, desyncing the client's key from the server's.
+
+  **Fix:** in the transit branch of `reconnectSocket()`, force a real transport re-cycle (disconnect → connect) so the fresh auth (token + `transitSessionId`) is actually sent and the server re-links the *same* session (same key), instead of silently continuing on stale auth. A new internal `_preservingSession` guard stops the disconnect handler from wiping the key being deliberately carried forward. Non-transit and already-disconnected paths are unchanged.
+
+  **Backward compatible.** Only affects transit-encryption deployments that refresh auth tokens while the socket is connected. **No integration changes required** — the fix is entirely internal to `reconnectSocket()`.
+
 ### v1.3.9
 
 - **New: group @mentions.** Tag members in a group message; a mentioned user is notified even if they muted the group (the mention pierces mute). Mentions are stored inline in the message text as self-describing tokens `@[DisplayName](userId)` (and `@[all](all)` for @all), plus a flat, denormalized `mentions: string[]` array on the message for fan-out and "who was mentioned" lookups. No offsets are stored — the token is self-locating and survives edits.

package/dist/index.cjs

@@ -1216,6 +1216,12 @@ var conversationsApi = {
   async unpin(conversationId) {
     await getApiClient().post(`/conversations/${conversationId}/unpin`);
   },
+  async markUnread(conversationId) {
+    await getApiClient().post(`/conversations/${conversationId}/unread`);
+  },
+  async markRead(conversationId) {
+    await getApiClient().post(`/conversations/${conversationId}/unread/clear`);
+  },
   async leave(conversationId, andDelete) {
     const url = andDelete ? `/conversations/${conversationId}/leave?delete=true` : `/conversations/${conversationId}/leave`;
     await getApiClient().post(url);
@@ -1525,6 +1531,7 @@ var _getToken = null;
 var _userId;
 var _tenantId;
 var _config2 = null;
+var _preservingSession = false;
 function setStatus(s) {
   _status = s;
   _statusListeners.forEach((l) => l(s));
@@ -1676,7 +1683,7 @@ async function _doConnect(config, getToken) {
   _socket.on("connect", () => setStatus("connected"));
   _socket.on("disconnect", () => {
     setStatus("disconnected");
-    clearTransitSession();
+    if (!_preservingSession) clearTransitSession();
   });
   _socket.on("connect_error", (err) => {
     console.error("[AntzChat] Socket connect_error:", err?.message, err?.data);
@@ -1779,7 +1786,13 @@ function reconnectSocket(token, userId, tenantId) {
         ...tenantId && { tenantId },
         transitSessionId: existing.sessionId
       };
-      _socket.connect();
+      _preservingSession = true;
+      try {
+        if (_socket.connected) _socket.disconnect();
+        _socket.connect();
+      } finally {
+        _preservingSession = false;
+      }
       return;
     }
     if (_getToken) {