@antzsoft/chat-core 1.1.2 → 1.1.3

package/README.md

@@ -625,6 +625,13 @@ class AntzChatClient {
    * Same presigned URL pipeline as message attachments — platformUploadFn is handled automatically.
    */
   uploadIcon(conversationId: string, file: UploadableFile): Promise<Conversation>;
+
+  /**
+   * Remove the group icon (admin only).
+   * Deletes the asset from storage and clears iconMeta on the conversation.
+   * Returns the updated conversation with iconUrl: undefined.
+   */
+  removeIcon(conversationId: string): Promise<Conversation>;
 }
 ```
 
@@ -849,15 +856,16 @@ import { conversationsApi } from '@antzsoft/chat-core';
 | `createDirect` | `(data: CreateDirectData) => Promise<Conversation>` | Start or retrieve a direct conversation with another user. |
 | `update` | `(conversationId: string, data: UpdateConversationData) => Promise<Conversation>` | Update group name or description. |
 | `uploadIcon` | `(conversationId: string, fileId: string) => Promise<Conversation>` | Set the group icon from an already-uploaded file (admin only). Call `client.uploadFiles()` first to get the `fileId`, then pass it here. Server copies `storageKey` into `conversation.iconMeta`, deletes the `chat_files` record, and returns the conversation with a fresh `iconUrl`. |
-| `delete` | `(conversationId: string) => Promise<void>` | Delete a conversation (admin only). |
-| `addParticipants` | `(conversationId: string, userIds: string[], role?: 'admin' \| 'member') => Promise<Conversation>` | Add one or more participants. `role` defaults to `'member'`. Previously removed members who are re-added always receive the specified role — a former admin re-added without `role: 'admin'` comes back as a member. |
-| `removeParticipant` | `(conversationId: string, userId: string) => Promise<Conversation>` | Remove a participant. |
+| `removeIcon` | `(conversationId: string) => Promise<Conversation>` | Remove the group icon (admin only). Deletes the asset from storage, clears `iconMeta` on the conversation, and returns the updated conversation with `iconUrl: undefined`. Non-admins receive `403 Forbidden`. |
+| `delete` | `(conversationId: string) => Promise<void>` | Hide a conversation from the caller's list. Works for any participant (active or inactive) on both DMs and groups — no admin role required. For DMs this is "Delete Chat"; for groups this is "Delete Group" (after already exiting). Other participants are completely unaffected. |
+| `addParticipants` | `(conversationId: string, userIds: string[], role?: 'admin' \| 'member') => Promise<Conversation>` | Add one or more participants. `role` defaults to `'member'`. Previously removed members who are re-added always receive the specified role — a former admin re-added without `role: 'admin'` comes back as a member. Message visibility on re-add depends on whether the user previously deleted the conversation (see [Message History & Re-add](#message-history--re-add)). |
+| `removeParticipant` | `(conversationId: string, userId: string) => Promise<Conversation>` | Remove a participant (admin only). |
 | `updateParticipantRole` | `(conversationId: string, userId: string, role: 'admin' \| 'member') => Promise<Conversation>` | Promote or demote a participant. |
 | `mute` | `(conversationId: string, mutedUntil?: string) => Promise<void>` | Mute notifications. Pass an ISO date string to mute until a specific time. |
 | `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. |
-| `leave` | `(conversationId: string) => Promise<void>` | Leave a group conversation. |
+| `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. |
 
 ```typescript
@@ -974,6 +982,11 @@ console.log(updated.iconUrl); // fresh signed URL, regenerated on every response
 // - Previous icon deleted from storage automatically on replace
 // - Non-admins get 403 Forbidden
 
+// Remove the group icon (admin only).
+// Deletes the asset from storage and clears iconMeta. Returns conversation with iconUrl: undefined.
+const noIcon = await conversationsApi.removeIcon(group.id);
+// noIcon.iconUrl === undefined
+
 // Add members (default role: member)
 await conversationsApi.addParticipants(group.id, ['user-d', 'user-e']);
 
@@ -1539,6 +1552,9 @@ import { usersApi } from '@antzsoft/chat-core';
 | `list` | `(params?: { query?: string; page?: number; limit?: number }) => Promise<PaginatedResponse<User>>` | List users, optionally filtered by a search query. Omit `page`/`limit` for all results. |
 | `getById` | `(userId: string) => Promise<User>` | Fetch a single user by their chat system ID. |
 | `getLastSeen` | `(userId: string) => Promise<{ lastSeenAt: string \| null }>` | Fetch a user's last-seen timestamp. Use on initial load; after that the store is kept live by `user_offline` socket events. |
+| `updateProfile` | `(payload: UpdateProfilePayload) => Promise<User>` | Update the current user's profile fields. Works in both builtin and non-builtin modes. |
+| `updatePreferences` | `(prefs: UserPreferences) => Promise<User>` | Partial update of notification preferences. |
+| `getPreferences` | `() => Promise<UserPreferences \| null>` | Fetch current notification preferences. Returns `null` if no record exists yet. |
 
 All methods return `User` objects that include `externalId` for non-builtin modes.
 
@@ -1560,6 +1576,43 @@ const user = await usersApi.getById('64abc...');
 console.log(user.displayName, user.externalId);
 ```
 
+#### `updateProfile` — immediate profile update
+
+Use this to push a profile change to the chat server without waiting for the next sync cycle. Useful in **non-builtin (external/SSO) modes** when the host app knows a field just changed in the identity provider — e.g. the user updated their name in the main system.
+
+```typescript
+import { usersApi, type UpdateProfilePayload } from '@antzsoft/chat-core';
+
+await usersApi.updateProfile({
+  firstName:   'Jane',
+  lastName:    'Smith',
+  displayName: 'Jane S.',   // optional — auto-derived from firstName+lastName if omitted (builtin)
+  email:       'jane@example.com',
+  phone:       '+919900000000',
+});
+```
+
+**Behaviour by mode:**
+
+| Field | Builtin | Non-builtin (external / SSO / WSO2) |
+|---|---|---|
+| `firstName` | Written directly | Written immediately; overwritten on next sync if user-service has a different value |
+| `lastName` | Written directly | Written immediately; overwritten on next sync if user-service has a different value |
+| `email` | Written directly | Written immediately; overwritten on next sync if user-service has a different value |
+| `displayName` | Written. Auto-derived from `firstName`+`lastName` if omitted | Written immediately |
+| `phone` | Written directly | Written immediately |
+| `username` | Not allowed | Not allowed |
+| `status` | Not allowed | Not allowed |
+
+**Uniqueness constraints (both modes):**
+- `email` must be unique within the tenant → `409 Conflict` if another user holds it
+- `phone` must be unique within the tenant → `409 Conflict` if another user holds it
+
+**Background sync in non-builtin mode:**
+- On `AntzChatClient` socket connect, if the user's shadow record is stale (> 6 hours since last sync), the server fires a single-user sync from the upstream user-service in the background.
+- The 2-hour bulk cron also keeps all shadow records up to date.
+- `updateProfile()` lets the host app push changes immediately rather than waiting for the next sync cycle.
+
 ---
 
 ### App Config API (`appConfigApi`)
@@ -2398,7 +2451,18 @@ document.querySelectorAll('[data-conv-id]').forEach((el) => {
 
 ## Changelog
 
+### v1.1.3
+- **New: `conversationsApi.leave(conversationId, andDelete?)` — `andDelete` param** — Pass `andDelete: true` to exit a group and hide it from the caller's list in a single atomic server call ("Exit and Delete"). Previously required two separate calls.
+- **New: Auto-promote on last-admin exit** — When the only admin leaves a group, the server now automatically promotes the longest-standing active member to admin before completing the exit. Previously the server returned `400 Bad Request` requiring the admin to manually promote someone first.
+- **Changed: `conversationsApi.delete()` — no longer admin-only** — Any participant (active or inactive) can call `delete()` to hide their own copy of a DM or group. For DMs this is "Delete Chat". For groups this is "Delete Group" (for already-exited members). Other participants are unaffected.
+- **New: Message visibility windows (`membershipPeriods`)** — Each participant now tracks an array of membership time windows. The message fetch API enforces these windows so gap messages (sent while the user was not a member) are always hidden. Previously re-added users could see all messages including those sent during their absence.
+- **New: DM reappear on new message** — After a user deletes a DM, if the other participant sends a new message the conversation automatically reappears in the deleted user's list. The user sees only messages from the reappearance point onwards.
+- **New: `useConversations()` returns `leaveGroup`, `leaveAndDeleteGroup`, `deleteGroup` / `deleteConversation` mutations** — Available in both the web SDK and RN SDK hooks.
+
 ### v1.1.2
+- **New: `usersApi.updateProfile()`** — Update the current user's profile fields (`firstName`, `lastName`, `email`, `displayName`, `phone`) immediately without waiting for the next sync cycle. Works in both builtin and non-builtin modes. Email and phone are enforced unique per tenant (409 on conflict). In non-builtin modes, fields may be overwritten on the next background sync if user-service returns different values.
+- **New: On-connect per-user sync** — In non-builtin modes, `AntzChatClient.connect()` now triggers a background sync of the current user's profile from the upstream user-service if the shadow record is stale (> 6 hours). Previously only the 2-hour bulk cron kept shadow records updated.
+- **New: Phone number uniqueness enforced** — `phone` is now unique per tenant (schema index + pre-check on register and `updateProfile`). A `409 Conflict` is returned if another user in the same tenant already holds the phone number.
 - **New: Participants stored in a dedicated collection** — Participants are no longer embedded inside conversation documents. Each participant is now its own document in a separate collection, removing the MongoDB 16 MB document size ceiling for large groups and eliminating write contention on high-membership conversations. No client API changes.
 - **New: Transit encryption** — All socket payloads are now encrypted end-to-end using a per-session symmetric key negotiated on connect. Transparent to callers — no SDK API changes required.
 - **Fix: Disbanded groups now visible in read-only mode for removed members** — Previously removed members' views of disbanded groups were inconsistent. Removed participants now always see the conversation in read-only mode until they explicitly call `leave()`.
@@ -2453,7 +2517,7 @@ document.querySelectorAll('[data-conv-id]').forEach((el) => {
 - Fix: attachment last-message content preview
 - Fix: avatar upload via `AntzChatClient`
 - Fix: `client.connect()` on React Native
-- Group icon — create & update
+- Group icon — create, update & remove
 - Scroll to first unread message
 - Push notifications — device token registration (RN & Web)
 

package/dist/index.cjs

@@ -301,45 +301,61 @@ function b64ToBuf(b64) {
 }
 
 // src/crypto/session.ts
-var _session = null;
-var _readyResolve = null;
-var _readyPromise = null;
-var _transitConfigured = null;
+var _KEY = /* @__PURE__ */ Symbol.for("__antz_chat_transit__");
+function getState() {
+  const g = globalThis;
+  if (!g[_KEY]) {
+    g[_KEY] = {
+      session: null,
+      sessionEverEstablished: false,
+      readyResolve: null,
+      readyPromise: null,
+      transitConfigured: null
+    };
+  }
+  return g[_KEY];
+}
 function configureTransit(enabled) {
-  _transitConfigured = enabled;
+  const s = getState();
+  s.transitConfigured = enabled;
   if (!enabled) {
-    _readyResolve?.();
-    _readyResolve = null;
+    s.readyResolve?.();
+    s.readyResolve = null;
   }
 }
 function waitForTransitReady() {
-  if (!_transitConfigured) return Promise.resolve();
-  if (_session) return Promise.resolve();
-  if (!_readyPromise) {
-    _readyPromise = new Promise((resolve) => {
-      _readyResolve = resolve;
+  const s = getState();
+  if (!s.transitConfigured) return Promise.resolve();
+  if (s.session) return Promise.resolve();
+  if (s.sessionEverEstablished) return Promise.resolve();
+  if (!s.readyPromise) {
+    s.readyPromise = new Promise((resolve) => {
+      s.readyResolve = resolve;
     });
   }
-  return _readyPromise;
+  return s.readyPromise;
 }
 function setTransitSession(session) {
-  _session = session;
-  _readyResolve?.();
-  _readyResolve = null;
+  const s = getState();
+  s.session = session;
+  s.sessionEverEstablished = true;
+  s.readyResolve?.();
+  s.readyResolve = null;
 }
 function clearTransitSession() {
-  _session = null;
-  _readyPromise = null;
-  _readyResolve = null;
+  const s = getState();
+  s.session = null;
+  s.readyPromise = null;
+  s.readyResolve = null;
 }
 function isTransitEnabled() {
-  return _session?.enabled === true;
+  return getState().session?.enabled === true;
 }
 function getSessionKey() {
-  return _session?.sessionKey ?? null;
+  return getState().session?.sessionKey ?? null;
 }
 function getSessionId() {
-  return _session?.sessionId ?? null;
+  return getState().session?.sessionId ?? null;
 }
 
 // src/api/client.ts
@@ -699,8 +715,9 @@ var conversationsApi = {
   async unpin(conversationId) {
     await getApiClient().delete(`/conversations/${conversationId}/pin`);
   },
-  async leave(conversationId) {
-    await getApiClient().delete(`/conversations/${conversationId}/leave`);
+  async leave(conversationId, andDelete) {
+    const url = andDelete ? `/conversations/${conversationId}/leave?delete=true` : `/conversations/${conversationId}/leave`;
+    await getApiClient().delete(url);
   },
   async getMembers(conversationId, filter) {
     const { data } = await getApiClient().get(
@@ -740,6 +757,12 @@ var conversationsApi = {
       { fileId }
     );
     return normalizeConversation(data);
+  },
+  async removeIcon(conversationId) {
+    const { data } = await getApiClient().delete(
+      `/conversations/${conversationId}/icon`
+    );
+    return normalizeConversation(data);
   }
 };
 
@@ -868,6 +891,16 @@ var usersApi = {
     const { data } = await getApiClient().get(`/users/${userId}`);
     return { lastSeenAt: data.lastSeenAt ?? null };
   },
+  /**
+   * Update basic profile fields for the current user.
+   * Works in both builtin and non-builtin modes. Use this to push an immediate
+   * profile update to the chat server when the host app knows a change just
+   * happened — without waiting for the next 2-hour sync cycle.
+   */
+  async updateProfile(payload) {
+    const { data } = await getApiClient().put("/users/me", payload);
+    return data;
+  },
   /**
    * Update notification preferences for the current user.
    * Partial update — only send fields you want to change.
@@ -1219,6 +1252,36 @@ function refreshSocketAuth() {
 // src/socket/emitters.ts
 var ACK_TIMEOUT = 5e3;
 var RECONNECT_WAIT_TIMEOUT = 15e3;
+var QUEUE_MAX_SIZE = 100;
+var QUEUE_ENTRY_TTL = 3e4;
+var sendQueue = [];
+var sendQueueRunning = false;
+async function drainSendQueue() {
+  if (sendQueueRunning) return;
+  sendQueueRunning = true;
+  while (sendQueue.length > 0) {
+    const entry = sendQueue.shift();
+    if (Date.now() - entry.enqueuedAt > QUEUE_ENTRY_TTL) {
+      entry.reject(new Error("[AntzChat] Message dropped: queued too long"));
+      continue;
+    }
+    try {
+      entry.resolve(await entry.run());
+    } catch (e) {
+      entry.reject(e);
+    }
+  }
+  sendQueueRunning = false;
+}
+function queueSendMessage(payload) {
+  if (sendQueue.length >= QUEUE_MAX_SIZE) {
+    return Promise.reject(new Error("[AntzChat] Send queue full: too many messages in flight"));
+  }
+  return new Promise((resolve, reject) => {
+    sendQueue.push({ run: () => withAck("send_message", payload), resolve, reject, enqueuedAt: Date.now() });
+    drainSendQueue();
+  });
+}
 function waitForReconnect() {
   return new Promise((resolve, reject) => {
     const timer = setTimeout(() => {
@@ -1266,7 +1329,7 @@ var socketEmit = {
     fireAndForget("leave_room", { conversationId });
   },
   sendMessage(payload) {
-    return withAck("send_message", payload);
+    return queueSendMessage(payload);
   },
   updateMessage(messageId, text) {
     return withAck("update_message", { messageId, text });