@ethora/chat-component-rn 26.4.2 → 26.5.2

package/src/networking/api-requests/rooms.api.ts

@@ -1,3 +1,4 @@
+import { ApiRoom, DeleteRoomMember, PostAddRoomMember, PostReportRoom, PostRoom, RoomMember } from '../../types/models/room.model';
 import { store } from '../../roomStore';
 import { addRoom } from '../../roomStore/roomsSlice';
 import { IRoom } from '../../types/types';
@@ -9,21 +10,6 @@ interface ApiRoomMember {
   lastName?: string;
 }
 
-interface ApiRoom {
-  _id?: string;
-  name: string;
-  title?: string;
-  jid?: string;
-  description?: string;
-  participants?: number;
-  type?: string;
-  icon?: string;
-  picture?: string;
-  members?: ApiRoomMember[];
-  createdAt?: string;
-  updatedAt?: string;
-}
-
 /**
  * Materialize a REST `/chats/my` item into an `IRoom` + dispatch
  * `addRoom`. Without this, REST-fetched rooms never make it into
@@ -133,6 +119,136 @@ export async function getRooms(): Promise<{ items: ApiRoom[] }> {
   }
 }
 
+export async function getRoomByName(chatName: string): Promise<ApiRoom> {
+  const token = store.getState().chatSettingStore.user.token || '';
+
+  try {
+    const response = await http.get(`/chats/my/${chatName}`, {
+      headers: {
+        Authorization: token,
+      },
+    });
+    return response.data;
+  } catch (error) {
+    throw new Error('Error updating profile');
+  }
+}
+
+export async function postRoom(data: PostRoom) {
+  const token = store.getState().chatSettingStore.user.token || '';
+
+  try {
+    const response = await http.post('/chats', data, {
+      headers: {
+        Authorization: token,
+      },
+    });
+    return response.data.result;
+  } catch (error) {
+    throw new Error('Error updating profile');
+  }
+}
+
+export async function postPrivateRoom(
+  username: string,
+  title: string = 'Private chat'
+): Promise<ApiRoom> {
+  const token = store.getState().chatSettingStore.user.token || '';
+
+  try {
+    const response = await http.post(
+      '/chats/private',
+      { username },
+      {
+        headers: {
+          Authorization: token,
+        },
+      }
+    );
+    return response.data.result;
+  } catch (error) {
+    throw new Error('Error updating profile');
+  }
+}
+
+export async function postReportRoom(data: PostReportRoom) {
+  const { chatName, category, text } = data;
+  const token = store.getState().chatSettingStore.user.token || '';
+
+  try {
+    const response = await http.post(
+      `/chats/reports/${chatName}`,
+      { category, text },
+      {
+        headers: {
+          Authorization: token,
+        },
+      }
+    );
+    return response.data.result;
+  } catch (error) {
+    throw new Error('Error updating profile');
+  }
+}
+
+export async function postAddRoomMember(
+  data: PostAddRoomMember
+): Promise<RoomMember[]> {
+  const { chatName, members } = data;
+  const token = store.getState().chatSettingStore.user.token || '';
+
+  try {
+    const response = await http.post(
+      `/chats/users-access`,
+      { chatName, members },
+      {
+        headers: {
+          Authorization: token,
+        },
+      }
+    );
+    return response?.data?.results || [];
+  } catch (error) {
+    throw new Error('Error updating profile');
+  }
+}
+
+export async function deleteRoomMember(data: DeleteRoomMember) {
+  const { roomId, members } = data;
+  const token = store.getState().chatSettingStore.user.token || '';
+
+  try {
+    const response = await http.delete(`/chats/users-access`, {
+      headers: {
+        Authorization: token,
+      },
+      data: {
+        chatName: roomId,
+        members,
+      },
+    });
+    return response.data.result;
+  } catch (error) {
+    throw new Error('Error updating profile');
+  }
+}
+
+export async function deleteRoom(name: string) {
+  const token = store.getState().chatSettingStore.user.token || '';
+
+  try {
+    const response = await http.delete('/chats', {
+      headers: {
+        Authorization: token,
+      },
+      data: { name },
+    });
+    return response.data.result;
+  } catch (error) {
+    throw new Error('Error deleting room');
+  }
+}
+
 export function clearRoomsRestCache() {
   lastGetRoomsResponse = null;
   lastGetRoomsResponseAt = 0;

package/src/networking/api-requests/user.api.ts

@@ -41,6 +41,15 @@ export function getExportMyData() {
   });
 }
 
+export function deleteDocument(fileId: string) {
+  const token = store.getState().chatSettingStore.user.token || '';
+  return http.delete(`/files/${fileId}`, {
+    headers: {
+      Authorization: token,
+    },
+  });
+}
+
 export function deleteMe() {
   return http.delete('/users');
 }

package/src/networking/apiClient.ts

@@ -2,13 +2,16 @@ import axios from 'axios';
 import { store } from '../roomStore';
 
 import { logout, refreshTokens } from '../roomStore/chatSettingsSlice';
-import { appToken as defaultAppToken } from '../../api.config';
 import { installAxiosCapture } from '../utils/devLogger';
 
-const DEFAULT_BASE_URL = 'https://api.chat.ethora.com/v1';
+// Per product-code-policy: no compiled-in Ethora endpoints or tokens.
+// Consumers must call `setBaseURL(baseUrl, appToken)` (or pass
+// `baseUrl` + the token-bearing user / jwt-login config via the
+// top-level `<Chat>` props) before any REST call is issued.
+const DEFAULT_BASE_URL = '';
 
 let currentBaseURL = DEFAULT_BASE_URL;
-let currentAppToken: string = defaultAppToken;
+let currentAppToken: string = '';
 
 const http = axios.create({
   baseURL: currentBaseURL,
@@ -126,13 +129,14 @@ http.interceptors.response.use(
       // Consumer-supplied refresh function. Call it, dispatch the new
       // tokens, retry the original request.
       try {
-        const { refreshToken, accessToken } = store
-          .getState()
-          .chatSettingStore?.config?.refreshTokens?.refreshFunction();
+        const fn = store.getState().chatSettingStore?.config?.refreshTokens?.refreshFunction;
+        if (!fn) return Promise.reject(error);
+        const result = await fn();
+        const { refreshToken: newRefreshToken, accessToken } = result || { refreshToken: '', accessToken: '' };
         store.dispatch(
           refreshTokens({
             token: accessToken,
-            refreshToken: refreshToken,
+            refreshToken: newRefreshToken || '',
           })
         );
         // BUGFIX: previously this branch returned `undefined` after

package/src/networking/stanzaHandlers.ts

@@ -10,7 +10,7 @@ import {
   setRoomRole,
   updateRoom,
 } from '../roomStore/roomsSlice';
-import { IRoom } from '../types/types';
+import { IRoom, RoomMember } from '../types/types';
 import { createMessageFromXml } from '../helpers/createMessageFromXml';
 import { getDataFromXml } from '../helpers/getDataFromXml';
 import { setDeleteModal } from '../roomStore/chatSettingsSlice';
@@ -64,14 +64,18 @@ const onRealtimeMessage = async (stanza: Element) => {
     // dedupes by xmppId, which is how the optimistic pending bubble flips
     // to delivered in-place instead of rendering twice.
     const parsed = await getDataFromXml(stanza);
-    const { data: pData, id: pId, body: pBody, ...pRest } = parsed || ({} as any);
+    const { data: pData, id: pId, body: pBody, ...pRest } =
+      parsed ?? ({} as Partial<NonNullable<typeof parsed>>);
+    // Cast at the call site: createMessageFromXml accepts the merged
+    // wrapped/positional shape; IUser type drift between models prevents
+    // a narrower type here without a wider refactor.
     const message = await createMessageFromXml({
       data: pData || data.attrs,
       id: pId || id,
-      body: pBody,
+      body: pBody ?? '',
       ...pRest,
-      isDeleted: !!deleted || !!(pRest as any)?.deleted,
-    });
+      isDeleted: !!deleted || !!pRest?.deleted,
+    } as Parameters<typeof createMessageFromXml>[0]);
 
     const roomJID = stanza.attrs.from.split('/')[0];
     store.dispatch(
@@ -123,7 +127,7 @@ const onDeleteMessage = async (stanza: Element) => {
 
     store.dispatch(
       deleteRoomMessage({
-        roomJID: stanzaId.attrs.by,
+        roomJID: stanzaId?.attrs.by,
         messageId: deleted.attrs.id,
       })
     );
@@ -142,9 +146,9 @@ const onEditMessage = async (stanza: Element) => {
 
     store.dispatch(
       editRoomMessage({
-        roomJID: stanzaId.attrs.by,
-        messageId: replace.attrs.id,
-        text: replace.attrs.text,
+        roomJID: stanzaId?.attrs.by,
+        messageId: replace?.attrs.id,
+        text: replace?.attrs.text,
       })
     );
   }
@@ -246,7 +250,7 @@ const handleComposing = async (stanza: Element, currentUser: string) => {
     if (composingUser && !isSelf) {
       const chatJID = stanza.attrs?.from.split('/')[0];
 
-      let composingList = [];
+      let composingList: string[] = [];
 
       stanza?.getChild('composing')
         ? composingList.push(
@@ -300,31 +304,51 @@ const onChatInvite = async (stanza: Element, client: any) => {
 };
 
 const onGetMembers = (stanza: Element) => {
-  const jid = store.getState().rooms.activeRoomJID;
-  // Defensive: many iq stanzas don't have an id (server pings,
-  // disco#info responses, etc.).
   if (String(stanza.attrs?.id || '') !== 'roomMemberInfo') {return;}
-  // The original implementation used the browser-only DOMParser, which
-  // throws `ReferenceError: Property 'DOMParser' doesn't exist` in
-  // React Native. Walk the ltx element tree directly instead — the
-  // shape is the same: nested <query><activity .../></query> children.
+
   try {
-    const queries = (stanza as any).getChildren?.('query') || [];
-    const activities: any[] = [];
+    const queries: Element[] = stanza.getChildren('query') ?? [];
+    const activities: Element[] = [];
+    let roomJid = '';
     for (const q of queries) {
-      const acts = q?.getChildren?.('activity') || [];
+      if (!roomJid && q.attrs?.room) {roomJid = q.attrs.room;}
+      const acts = q.getChildren('activity') ?? [];
       for (const a of acts) {activities.push(a);}
     }
-    const roomMembers = activities.map((a: any) => ({
-      name: a?.attrs?.name,
-      role: a?.attrs?.role,
-      ban_status: a?.attrs?.ban_status,
-      last_active: Number(a?.attrs?.last_active),
-      jid: a?.attrs?.jid,
-    }));
-    if (jid) {
-      store.dispatch(updateRoom({ jid, updates: { roomMembers } as any }));
-    }
+
+    const jid = roomJid || store.getState().rooms.activeRoomJID;
+    if (!jid || activities.length === 0) {return;}
+
+    const existingRoom = store.getState().rooms.rooms[jid];
+    const existingMembers: RoomMember[] = existingRoom?.roomMembers ?? [];
+    const existingByJid = new Map<string, RoomMember>(
+      existingMembers
+        .filter((m): m is RoomMember & { jid: string } => !!m.jid)
+        .map((m) => [m.jid, m])
+    );
+
+    const roomMembers: RoomMember[] = activities.map((a) => {
+      const memberJid: string | undefined = a.attrs?.jid;
+      const existing = memberJid ? existingByJid.get(memberJid) : undefined;
+      // The activity stanza carries only the XMPP-side fields
+      // (name/role/ban_status/last_active/jid). REST-loaded existing
+      // members supply firstName/lastName/xmppUsername/_id; when there's
+      // no REST match yet we leave those as empty strings.
+      return {
+        firstName: existing?.firstName ?? '',
+        lastName: existing?.lastName ?? '',
+        xmppUsername: existing?.xmppUsername ?? '',
+        _id: existing?._id ?? '',
+        ...existing,
+        name: a.attrs?.name,
+        role: a.attrs?.role,
+        ban_status: a.attrs?.ban_status,
+        last_active: Number(a.attrs?.last_active),
+        jid: memberJid,
+      };
+    });
+
+    store.dispatch(updateRoom({ jid, updates: { roomMembers } }));
   } catch (err) {
     console.warn('onGetMembers parse failed', err);
   }

package/src/networking/xmpp/actionSetTimestampToPrivateStore.xmpp.ts

@@ -30,7 +30,7 @@ export async function actionSetTimestampToPrivateStore(
   } else {
     await setChatsPrivateStoreRequest(
       client,
-      populateChats(chats, timestamp.toString())
+      populateChats(chats || [], timestamp.toString())
     );
     return true;
   }

package/src/networking/xmpp/getChatsPrivateStoreRequest.xmpp.ts

@@ -48,7 +48,7 @@ export async function getChatsPrivateStoreRequest(client: Client) {
       )
     );
 
-    client.send(message).catch((err) => {
+    client.send(message).catch((err: any) => {
       clearTimeout(timeout);
       client.off('stanza', stanzaHdlrPointer);
       reject(err);

package/src/networking/xmpp/getHistory.xmpp.ts

@@ -79,9 +79,9 @@ export const getHistory = async (
             const message = await createMessageFromXml({
               data,
               id,
-              body,
+              body: body || '',
               ...rest,
-            });
+            } as any);
 
             mainMessages.push(message);
           }
@@ -119,7 +119,7 @@ export const getHistory = async (
       )
     );
 
-    client?.send(message).catch((err) => console.log('err on load', err));
+    client?.send(message).catch((err: any) => console.log('err on load', err));
   });
 
   const timeoutPromise = createTimeoutPromise(10000);

package/src/networking/xmpp/getRooms.xmpp.ts

@@ -24,7 +24,7 @@ export const getRooms = async (client: Client): Promise<any> => {
       xml('query', { xmlns: 'ns:getrooms' })
     );
 
-    client.send(message).catch((err) => {
+    client.send(message).catch((err: any) => {
       console.error('Error sending getRooms request:', err);
       unsubscribe();
       reject(err);

package/src/networking/xmpp/handleStanzas.xmpp.ts

@@ -44,7 +44,7 @@ export function handleStanza(stanza: Element, xmppWs: XmppClient) {
       onPresenceInRoom(stanza);
       onGetMembers(stanza);
       onGetRoomInfo(stanza);
-      onGetLastMessageArchive(stanza);
+      onGetLastMessageArchive(stanza, xmppWs);
       break;
     case 'room-config':
       onNewRoomCreated(stanza, xmppWs);

package/src/networking/xmppClient.ts

@@ -57,6 +57,7 @@ export class XmppClient {
   suppressReconnect = false;
 
   // ---- QoS state (mirrors web XmppClient) ----------------------------
+  presencesReady = false;
   disableLastRead = false;
   private activeRoomJID: string | null = null;
   private activeRoomBoostUntil = 0;
@@ -282,7 +283,7 @@ export class XmppClient {
       }
 
       this.attachEventListeners();
-      this.client.start().catch((error) => {
+      this.client.start().catch((error: any) => {
         console.error('Error starting xmpp client:', error);
         this.status = 'error';
       });
@@ -306,6 +307,7 @@ export class XmppClient {
     this.client.on('online', () => {
       console.log('XMPP online.', new Date());
       this.status = 'online';
+      this.presencesReady = true;
       this.reconnectAttempts = 0;
       try {
         devPushLog(
@@ -316,7 +318,7 @@ export class XmppClient {
       } catch {}
     });
 
-    this.client.on('error', (error) => {
+    this.client.on('error', (error: any) => {
       console.error('XMPP client error:', error);
       try {
         devPushLog(
@@ -419,7 +421,7 @@ export class XmppClient {
   //room functions
 
   async createRoomStanza(title: string, description: string, to?: string) {
-    return await createRoom(title, description, this.client, to);
+    return await createRoom(title, description, this.client);
   }
 
   async inviteRoomRequestStanza(to: string, roomJid: string) {

package/src/roomStore/Middleware/newMessageMidlleware.tsx

@@ -24,7 +24,7 @@ export const newMessageMidlleware: Middleware =
 
     const { roomJID, message } = action.payload;
 
-    if (rooms[roomJID]?.lastMessageTimestamp <= Number(message.id)) {
+    if ((rooms[roomJID]?.lastMessageTimestamp ?? 0) <= Number(message.id)) {
       storeAPI.dispatch(
         updateRoom({
           jid: roomJID,

package/src/roomStore/Middleware/reactionsMiddleware.tsx

@@ -31,8 +31,8 @@ export const reactionsMiddleware: Middleware =
             updates: {
               lastMessageTimestamp: nanoToMs(
                 rooms[roomJID].messages[rooms[roomJID].messages.length - 1].id
-              ),
-              lastMessage: newLastMessage,
+              ) ?? 0,
+              lastMessage: newLastMessage as any,
             },
           })
         );
@@ -47,14 +47,14 @@ export const reactionsMiddleware: Middleware =
               name: `${data.senderFirstName} ${data.senderLastName}`,
               id: `emoji-${new Date().toString()}`,
             },
-            date: new Date(nanoToMs(latestReactionTimestamp)).toISOString(),
+            date: new Date(nanoToMs(latestReactionTimestamp) ?? 0).toISOString(),
           },
         };
 
         storeAPI.dispatch(
           updateRoom({
             jid: roomJID,
-            updates,
+            updates: updates as any,
           })
         );
       }
@@ -66,7 +66,7 @@ export const reactionsMiddleware: Middleware =
     }
 
     if (
-      rooms[roomJID]?.lastMessageTimestamp <= nanoToMs(latestReactionTimestamp)
+      (rooms[roomJID]?.lastMessageTimestamp ?? 0) <= (nanoToMs(latestReactionTimestamp) ?? 0)
     ) {
       updLastMessage();
     } else if (!rooms[roomJID]?.lastMessageTimestamp) {

package/src/roomStore/chatSettingsSlice.ts

@@ -1,4 +1,5 @@
-import { createSlice, PayloadAction } from '@reduxjs/toolkit';
+import { createSlice, PayloadAction, type Slice } from '@reduxjs/toolkit';
+import type { WritableDraft } from 'immer';
 import {
   DeleteModal,
   EditAction,
@@ -12,7 +13,7 @@ import { Iso639_1Codes } from '../types/models/language.model';
 import { localStorageConstants } from '../helpers/constants/LOCAL_STORAGE';
 import { asyncLocalStorage } from '../hooks/useLocalStorage';
 
-interface ChatState {
+export interface ChatState {
   user: User;
   config?: IConfig;
   activeModal?: ModalType;
@@ -23,7 +24,7 @@ interface ChatState {
   langSource?: Iso639_1Codes;
 }
 
-const unpackAndTransform = (input?: User): User => {
+export const unpackAndTransform = (input?: User): User => {
   return {
     description: '',
     token: input?.token || '',
@@ -95,70 +96,76 @@ const initialState: ChatState = {
   config: { colors: { primary: '#0052CD', secondary: '#F3F6FC' } },
 };
 
-export const chatSlice = createSlice({
+// Reducers extracted as a named const so the slice can be annotated
+// with Slice<State, typeof reducers, Name>. Without this, tsc inlines
+// immer's internal WritableNonArrayDraft type in the emitted .d.ts and
+// declaration emission fails with TS4023.
+const reducers = {
+  setUser: (state: WritableDraft<ChatState>, action: PayloadAction<User>) => {
+    state.user = unpackAndTransform(action.payload);
+    asyncLocalStorage(localStorageConstants.ETHORA_USER).set(
+      unpackAndTransform(action.payload)
+    );
+  },
+  updateUser(state: WritableDraft<ChatState>, action: PayloadAction<{ updates: Partial<User> }>) {
+    const { updates } = action.payload;
+    const user = state.user;
+    if (user) {
+      state.user = {
+        ...user,
+        ...updates,
+      };
+    }
+  },
+  setConfig: (state: WritableDraft<ChatState>, action: PayloadAction<IConfig | undefined>) => {
+    // Cast away immer's WritableDraft — IConfig contains callable
+    // fields (eventHandlers, customComponent) that confuse the draft
+    // type inference but are inert at write-time.
+    state.config = action.payload as any;
+  },
+  setActiveModal: (state: WritableDraft<ChatState>, action: PayloadAction<ModalType | undefined>) => {
+    state.activeModal = action.payload;
+  },
+  setActiveFile: (state: WritableDraft<ChatState>, action: PayloadAction<ModalFile>) => {
+    state.activeFile = action.payload;
+  },
+  setDeleteModal: (state: WritableDraft<ChatState>, action: PayloadAction<DeleteModal | undefined>) => {
+    state.deleteModal = action.payload;
+  },
+  setStoreClient: (state: WritableDraft<ChatState>, action: PayloadAction<any>) => {
+    state.client = action.payload;
+  },
+  setSelectedUser: (state: WritableDraft<ChatState>, action: PayloadAction<IUser | undefined>) => {
+    state.selectedUser = action.payload;
+  },
+  refreshTokens: (
+    state: WritableDraft<ChatState>,
+    action: PayloadAction<{ token: string; refreshToken: string }>
+  ) => {
+    state.user.refreshToken = action.payload.refreshToken;
+    state.user.token = action.payload.token;
+    // AsyncStorage is async; fire-and-forget so the reducer stays sync.
+    asyncLocalStorage(localStorageConstants.ETHORA_USER).set(state.user);
+  },
+  logout: (state: WritableDraft<ChatState>) => {
+    state.user = unpackAndTransform();
+    state.config = undefined;
+    state.client = undefined;
+    state.langSource = undefined;
+    asyncLocalStorage(localStorageConstants.ETHORA_USER).remove();
+  },
+  setLangSource: (
+    state: WritableDraft<ChatState>,
+    action: PayloadAction<Iso639_1Codes | undefined>
+  ) => {
+    state.langSource = action.payload;
+  },
+};
+
+export const chatSlice: Slice<ChatState, typeof reducers, 'chat'> = createSlice({
   name: 'chat',
   initialState,
-  reducers: {
-    setUser: (state, action: PayloadAction<User>) => {
-      state.user = unpackAndTransform(action.payload);
-      asyncLocalStorage(localStorageConstants.ETHORA_USER).set(
-        unpackAndTransform(action.payload)
-      );
-    },
-    updateUser(state, action: PayloadAction<{ updates: Partial<User> }>) {
-      const { updates } = action.payload;
-      const user = state.user;
-      if (user) {
-        state.user = {
-          ...user,
-          ...updates,
-        };
-      }
-    },
-    setConfig: (state, action: PayloadAction<IConfig | undefined>) => {
-      // Cast away immer's WritableDraft — IConfig contains callable
-      // fields (eventHandlers, customComponent) that confuse the draft
-      // type inference but are inert at write-time.
-      state.config = action.payload as any;
-    },
-    setActiveModal: (state, action: PayloadAction<ModalType | undefined>) => {
-      state.activeModal = action.payload;
-    },
-    setActiveFile: (state, action: PayloadAction<ModalFile>) => {
-      state.activeFile = action.payload;
-    },
-    setDeleteModal: (state, action: PayloadAction<DeleteModal | undefined>) => {
-      state.deleteModal = action.payload;
-    },
-    setStoreClient: (state, action: PayloadAction<any>) => {
-      state.client = action.payload;
-    },
-    setSelectedUser: (state, action: PayloadAction<IUser | undefined>) => {
-      state.selectedUser = action.payload;
-    },
-    refreshTokens: (
-      state,
-      action: PayloadAction<{ token: string; refreshToken: string }>
-    ) => {
-      state.user.refreshToken = action.payload.refreshToken;
-      state.user.token = action.payload.token;
-      // AsyncStorage is async; fire-and-forget so the reducer stays sync.
-      asyncLocalStorage(localStorageConstants.ETHORA_USER).set(state.user);
-    },
-    logout: (state) => {
-      state.user = unpackAndTransform();
-      state.config = undefined;
-      state.client = undefined;
-      state.langSource = undefined;
-      asyncLocalStorage(localStorageConstants.ETHORA_USER).remove();
-    },
-    setLangSource: (
-      state,
-      action: PayloadAction<Iso639_1Codes | undefined>
-    ) => {
-      state.langSource = action.payload;
-    },
-  },
+  reducers,
 });
 
 export const {