@ethora/chat-component-rn 26.8.1 → 26.8.2

package/src/main.ts

@@ -7,7 +7,10 @@
  *
  *   <Chat
  *     config={{
- *       baseUrl: 'https://api.chat.ethora.com/v1',
+ *       // The API ROOT — the SDK versions every path itself
+ *       // (`/v1/...`, `/v2/...`). A legacy `.../v1` is accepted and
+ *       // normalised, so existing integrations keep working.
+ *       baseUrl: 'https://api.chat.ethora.com',
  *       xmppSettings: { host: 'xmpp.chat.ethora.com' },
  *       jwtLogin: { enabled: true, token: '<paste JWT>' },
  *       initBeforeLoad: true,
@@ -28,8 +31,11 @@ export { XmppProvider } from './context/xmppProvider';
 
 // Hooks that consumers usually need (badge counts, logout, push, etc.).
 export { useUnread } from './hooks/useUnreadMessagesCounter';
+
+export { handlePushPayload, openRoomFromPush } from './helpers/pushPayload';
+export type { PushPayloadOutcome } from './helpers/pushPayload';
 export { useChatRoomFocus } from './hooks/useChatRoomFocus';
-export { logoutService } from './hooks/useLogout';
+export { logoutService, useLogout } from './hooks/useLogout';
 export { useQRCodeChat, handleQRChatId } from './hooks/useQRCodeChatHandler';
 export { resendMessage } from './utils/resendMessage';
 // Font loader, exposed so hosts can also load the font outside <Chat> if needed.
@@ -66,3 +72,21 @@ export type {
 } from './types/types';
 export type { Iso639_1Codes } from './types/models/language.model';
 export type { TranslateMode } from './utils/translateModePolicy';
+
+// Auth-token rotation. Exposed so hosts can drive a refresh themselves
+// (it is deduped and shares the SDK's lock) and, more importantly, so
+// they can tell a dead session from a transient failure: only
+// `RefreshFatalError` means "log the user out". Every other rejection —
+// network, 5xx, a lost REFRESH_IN_PROGRESS race — must leave the
+// session alone.
+export {
+  refreshAuthTokens,
+  refreshAuthTokensQuietly,
+  RefreshFatalError,
+  isRefreshFatalError,
+} from './networking/authRefresh';
+export type {
+  RefreshErrorCode,
+  RefreshResult,
+  RefreshOptions,
+} from './networking/authRefresh';

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

@@ -18,8 +18,9 @@ export async function loginEmail(email: string, password: string) {
     user: User;
     refreshToken: string;
     token: string;
+    fileToken?: string;
   }>(
-    '/users/login-with-email',
+    '/v1/users/login-with-email',
     {
       email,
       password,
@@ -29,6 +30,16 @@ export async function loginEmail(email: string, password: string) {
 
   console.log('loginEmail res', res.data);
 
+  // The fileToken arrives at the TOP level of the login response, next to
+  // token/refreshToken — not inside `user`. Folding it in here is what
+  // makes secure media (`secure-files.*`, uploaded via /v2/files/secure)
+  // render at all: without it every such image 403s and the bubble comes
+  // up blank.
+  res.data.user = {
+    ...res.data.user,
+    fileToken: res.data.fileToken || '',
+  };
+
   return res;
 }
 
@@ -39,7 +50,7 @@ export function loginSocial(
   authToken: string = 'authToken'
 ) {
   return http.post<any>(
-    '/users/login',
+    '/v1/users/login',
     {
       idToken,
       accessToken,
@@ -58,7 +69,7 @@ export function registerSocial(
   signUpPlan?: string
 ) {
   return http.post(
-    '/users',
+    '/v1/users',
     {
       idToken,
       accessToken,
@@ -72,7 +83,7 @@ export function registerSocial(
 
 export function checkEmailExist(email: string) {
   return http.get(
-    '/users/checkEmail/' + email,
+    '/v1/users/checkEmail/' + email,
 
     { headers: { Authorization: getCurrentAppToken() } }
   );
@@ -84,7 +95,8 @@ export async function loginViaJwt(clientToken: string): Promise<User> {
     user: User;
     refreshToken: string;
     token: string;
-  }>('/users/client', null, { headers: { 'x-custom-token': clientToken } });
+    fileToken?: string;
+  }>('/v1/users/client', null, { headers: { 'x-custom-token': clientToken } });
 
   console.log('✅ loginViaJwt: Received response', {
     hasUser: !!response.data.user,
@@ -103,6 +115,8 @@ export async function loginViaJwt(clientToken: string): Promise<User> {
     ...response.data.user,
     refreshToken: response.data.refreshToken,
     token: response.data.token,
+    // Top-level, same as loginEmail — see the note there.
+    fileToken: response.data.fileToken || '',
   };
 
   return user;
@@ -131,7 +145,7 @@ export async function loginViaJwt(clientToken: string): Promise<User> {
 
 export function uploadFile(formData: FormData) {
   const token = store.getState().chatSettingStore?.user?.token ?? '';
-  return http.post('/files/', formData, {
+  return http.post('/v1/files/', formData, {
     headers: {
       Authorization: token,
       Accept: '*/*',
@@ -144,55 +158,149 @@ export function uploadFile(formData: FormData) {
   });
 }
 
-export async function uploadFileViaFetch(formData: FormData): Promise<{ data: any }> {
+const SECURE_UPLOAD_PATH = '/v2/files/secure';
+const LEGACY_UPLOAD_PATH = '/v1/files/';
+
+const cloneFormData = (formData: FormData): FormData => {
+  const copy = new FormData();
+  const source = formData as any;
+
+  if (Array.isArray(source?._parts)) {
+    for (const [key, value] of source._parts) {
+      copy.append(key, value);
+    }
+    return copy;
+  }
+
+  if (typeof source?.forEach === 'function') {
+    source.forEach((value: any, key: string) => copy.append(key, value));
+    return copy;
+  }
+
+  if (typeof source?.getParts === 'function') {
+    for (const part of source.getParts()) {
+      // `headers` is derived by getParts() and must not be copied back —
+      // RN regenerates it from the value.
+      const { fieldName, string, headers: _headers, ...file } = part;
+      copy.append(fieldName, string !== undefined ? string : file);
+    }
+  }
+
+  return copy;
+};
+
+function postMultipart(
+  url: string,
+  body: FormData,
+  path: string
+): Promise<{ data: any }> {
   const token = store.getState().chatSettingStore?.user?.token ?? '';
-  const baseUrl = getCurrentBaseURL();
-  const url = `${baseUrl.replace(/\/$/, '')}/files/`;
 
-  pushLog('http', `→ POST ${url} (fetch)`, {
-    headers: { Authorization: token ? token.slice(0, 16) + '…' : '[empty]', Accept: '*/*' },
+  pushLog('http', `→ POST ${url} (xhr)`, {
+    path,
+    baseUrl: getCurrentBaseURL() || '[empty]',
+    headers: {
+      Authorization: token ? token.slice(0, 16) + '…' : '[empty]',
+      Accept: '*/*',
+    },
   });
 
-  let res: Response;
-  try {
-    res = await fetch(url, {
-      method: 'POST',
-      headers: {
-        Authorization: token,
-        Accept: '*/*',
-      },
-      body: formData as any,
-    });
-  } catch (e: any) {
-    pushLog('http', `← ERR fetch /files/`, {
-      name: e?.name,
-      message: e?.message,
-      stack: e?.stack,
-    });
-    const err: any = new Error(e?.message || 'Network request failed');
-    err.code = 'ERR_NETWORK';
-    err.cause = e;
-    err.config = { url: '/files/' };
-    throw err;
-  }
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+
+    const failNetwork = (reason: string) => {
+      pushLog('http', `← ERR xhr ${path}`, { reason, url });
+      const err: any = new Error(reason);
+      err.code = 'ERR_NETWORK';
+      err.config = { url: path };
+      reject(err);
+    };
+
+    xhr.onload = () => {
+      const status = xhr.status;
+      let responseBody: any = null;
+      try {
+        responseBody = JSON.parse(xhr.responseText);
+      } catch {
+        responseBody = xhr.responseText || null;
+      }
+
+      if (status < 200 || status >= 300) {
+        pushLog('http', `← ${status} POST ${path} (xhr)`, responseBody);
+        const err: any = new Error(`Upload failed: ${status}`);
+        // Shaped like an axios error so callers' `err.response.status`
+        // checks keep working — notably useSendMessage's retry with the
+        // singular "file" field on 500.
+        err.response = { status, statusText: xhr.statusText, data: responseBody };
+        err.config = { url: path };
+        reject(err);
+        return;
+      }
+
+      pushLog('http', `← ${status} POST ${path} (xhr)`, {
+        resultsCount: Array.isArray(responseBody?.results)
+          ? responseBody.results.length
+          : 'n/a',
+      });
+      resolve({ data: responseBody });
+    };
+
+    xhr.onerror = () => failNetwork('Network request failed');
+    xhr.ontimeout = () => failNetwork('Upload timed out');
+    xhr.onabort = () => failNetwork('Upload aborted');
+
+    xhr.open('POST', url);
+    xhr.setRequestHeader('Authorization', token);
+    xhr.setRequestHeader('Accept', '*/*');
+    // Deliberately no Content-Type — see the note above.
+    xhr.send(body as any);
+  });
+}
+
+const canFallBackToLegacyUpload = (error: unknown): boolean => {
+  const status = (error as { response?: { status?: number } })?.response
+    ?.status;
+  if (typeof status !== 'number') {return true;}
+  return status !== 401 && status !== 413;
+};
+
+let secureUploadUnavailable = false;
+
+export async function uploadFileV2(
+  formData: FormData,
+  activeRoomJID: string
+): Promise<{ data: any }> {
+  const chatName = (activeRoomJID || '').split('@')[0];
+  const apiRoot = getCurrentBaseURL().replace(/\/$/, '');
+
+  if (!secureUploadUnavailable && chatName) {
+    const body = cloneFormData(formData);
+    body.append('chatName', chatName);
 
-  if (!res.ok) {
-    let body: any = null;
     try {
-      body = await res.json();
-    } catch {
-      try { body = await res.text(); } catch { body = null; }
+      return await postMultipart(
+        `${apiRoot}${SECURE_UPLOAD_PATH}`,
+        body,
+        SECURE_UPLOAD_PATH
+      );
+    } catch (error) {
+      if (!canFallBackToLegacyUpload(error)) {throw error;}
+
+      secureUploadUnavailable = true;
+      console.warn(
+        `[chat] ${SECURE_UPLOAD_PATH} unreachable, falling back to ${LEGACY_UPLOAD_PATH} for this session`,
+        error
+      );
     }
-    pushLog('http', `← ${res.status} POST /files/ (fetch)`, body);
-    const err: any = new Error(`Upload failed: ${res.status}`);
-    err.response = { status: res.status, statusText: res.statusText, data: body };
-    err.config = { url: '/files/' };
-    throw err;
   }
 
-  const data = await res.json();
-  pushLog('http', `← ${res.status} POST /files/ (fetch)`, {
-    resultsCount: Array.isArray(data?.results) ? data.results.length : 'n/a',
-  });
-  return { data };
+  return postMultipart(
+    `${apiRoot}${LEGACY_UPLOAD_PATH}`,
+    formData,
+    LEGACY_UPLOAD_PATH
+  );
 }
+
+export const __resetSecureUploadLatchForTests = (): void => {
+  secureUploadUnavailable = false;
+};

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

@@ -7,7 +7,7 @@ export async function getUserByXmppUsername(
 ): Promise<RoomMember | null> {
   try {
     const res = await http.get<{ result: RoomMember }>(
-      `/apps/users/${xmppUsername}`,
+      `/v1/apps/users/${xmppUsername}`,
       {
         headers: { Authorization: token },
       }

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

@@ -181,7 +181,7 @@ export async function getRooms(): Promise<{ items: ApiRoom[] }> {
 
   getRoomsInFlightToken = token;
   getRoomsInFlight = (async () => {
-    const response = await http.get('/chats/my', {
+    const response = await http.get('/v1/chats/my', {
       headers: { Authorization: token },
     });
     lastGetRoomsResponse = response.data;
@@ -206,7 +206,7 @@ export async function getRoomByName(chatName: string): Promise<ApiRoom> {
   const token = store.getState().chatSettingStore.user.token || '';
 
   try {
-    const response = await http.get(`/chats/my/${chatName}`, {
+    const response = await http.get(`/v1/chats/my/${chatName}`, {
       headers: {
         Authorization: token,
       },
@@ -221,7 +221,7 @@ export async function postRoom(data: PostRoom) {
   const token = store.getState().chatSettingStore.user.token || '';
 
   try {
-    const response = await http.post('/chats', data, {
+    const response = await http.post('/v1/chats', data, {
       headers: {
         Authorization: token,
       },
@@ -240,7 +240,7 @@ export async function postPrivateRoom(
 
   try {
     const response = await http.post(
-      '/chats/private',
+      '/v1/chats/private',
       { username },
       {
         headers: {
@@ -260,7 +260,7 @@ export async function postReportRoom(data: PostReportRoom) {
 
   try {
     const response = await http.post(
-      `/chats/reports/${chatName}`,
+      `/v1/chats/reports/${chatName}`,
       { category, text },
       {
         headers: {
@@ -282,7 +282,7 @@ export async function postAddRoomMember(
 
   try {
     const response = await http.post(
-      `/chats/users-access`,
+      `/v1/chats/users-access`,
       { chatName, members },
       {
         headers: {
@@ -301,7 +301,7 @@ export async function deleteRoomMember(data: DeleteRoomMember) {
   const token = store.getState().chatSettingStore.user.token || '';
 
   try {
-    const response = await http.delete(`/chats/users-access`, {
+    const response = await http.delete(`/v1/chats/users-access`, {
       headers: {
         Authorization: token,
       },
@@ -320,7 +320,7 @@ export async function deleteRoom(name: string) {
   const token = store.getState().chatSettingStore.user.token || '';
 
   try {
-    const response = await http.delete('/chats', {
+    const response = await http.delete('/v1/chats', {
       headers: {
         Authorization: token,
       },
@@ -360,7 +360,7 @@ export async function createChatCall(
 
   try {
     await http.post(
-      `/chats/call/create/${chatName}`,
+      `/v1/chats/call/create/${chatName}`,
       { kind },
       {
         headers: {

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

@@ -1,4 +1,5 @@
 import http from '../apiClient';
+import { normalizeApiPath } from '../apiClient';
 import { store } from '../../roomStore';
 import { User } from '../../types/types';
 
@@ -10,7 +11,7 @@ interface GetMyUserOptions {
 export async function getMyUser(options?: GetMyUserOptions): Promise<User> {
   const token =
     options?.token || store.getState().chatSettingStore.user.token || '';
-  const endpoint = options?.endpoint || '/users/my';
+  const endpoint = normalizeApiPath(options?.endpoint) || '/v1/users/my';
 
   const response = await http.get(endpoint, {
     headers: { Authorization: token },
@@ -24,7 +25,7 @@ export async function getMyUser(options?: GetMyUserOptions): Promise<User> {
 
 export function getDocuments(walletAddress: string) {
   const token = store.getState().chatSettingStore.user.token || '';
-  return http.get(`/docs/${walletAddress}`, {
+  return http.get(`/v1/docs/${walletAddress}`, {
     headers: {
       Authorization: `Bearer ${token}`,
     },
@@ -33,7 +34,7 @@ export function getDocuments(walletAddress: string) {
 
 export function getExportMyData() {
   const token = store.getState().chatSettingStore.user.token || '';
-  return http.get('/users/exportData', {
+  return http.get('/v1/users/exportData', {
     headers: {
       Authorization: token,
       responseType: 'arraybuffer',
@@ -43,7 +44,7 @@ export function getExportMyData() {
 
 export function deleteDocument(fileId: string) {
   const token = store.getState().chatSettingStore.user.token || '';
-  return http.delete(`/files/${fileId}`, {
+  return http.delete(`/v1/files/${fileId}`, {
     headers: {
       Authorization: token,
     },
@@ -51,18 +52,18 @@ export function deleteDocument(fileId: string) {
 }
 
 export function deleteMe() {
-  return http.delete('/users');
+  return http.delete('/v1/users');
 }
 
 export function updateMe(data: any) {
-  return http.put('/users', data);
+  return http.put('/v1/users', data);
 }
 
 export async function updateProfile(fd: FormData): Promise<{ user: User }> {
   const token = store.getState().chatSettingStore.user.token || '';
 
   try {
-    const response = await http.put('/users', fd, {
+    const response = await http.put('/v1/users', fd, {
       headers: {
         Authorization: token,
         'Content-Type': 'multipart/form-data',
@@ -73,3 +74,74 @@ export async function updateProfile(fd: FormData): Promise<{ user: User }> {
     throw new Error('Error updating profile');
   }
 }
+
+/** One entry of `GET /v2/files/`, normalised for the UI. */
+export interface UserFile {
+  id: string;
+  name: string;
+  url: string;
+  mimetype: string;
+  createdAt?: string;
+  size?: number;
+}
+
+/**
+ * Files uploaded by the signed-in user (the JWT owner) — the profile
+ * screen's Media and Documents tabs.
+ *
+ * v2 answers `{ results, pagination }` and, for backward compatibility,
+ * also `{ limit, offset, total, items }`; older deployments only have the
+ * legacy shape. Read whichever is there instead of betting on one. Field
+ * names vary the same way between deployments (`location` vs `locations[]`,
+ * `originalname` vs `filename`), so each one falls through its aliases and
+ * anything without a usable URL is dropped rather than rendered as a dead
+ * row.
+ */
+export async function getUserFiles(options?: {
+  limit?: number;
+  offset?: number;
+}): Promise<UserFile[]> {
+  const token = store.getState().chatSettingStore.user.token || '';
+  const response = await http.get('/v2/files/', {
+    params: {
+      limit: options?.limit ?? 100,
+      offset: options?.offset ?? 0,
+    },
+    headers: { Authorization: token },
+  });
+
+  const payload = response?.data ?? {};
+  const rows: any[] = payload.results ?? payload.items ?? [];
+
+  return rows
+    .map((row: any): UserFile | null => {
+      const url = row?.location || row?.locations?.[0] || row?.url || '';
+      if (!url) {return null;}
+      return {
+        id: String(row?._id ?? row?.id ?? url),
+        name:
+          row?.originalname ||
+          row?.filename ||
+          row?.documentName ||
+          row?.name ||
+          url.split('/').pop() ||
+          'file',
+        url,
+        mimetype: row?.mimetype || row?.mimeType || row?.type || '',
+        createdAt: row?.createdAt || row?.updatedAt,
+        size: typeof row?.size === 'number' ? row.size : undefined,
+      };
+    })
+    .filter(Boolean) as UserFile[];
+}
+
+/** Images and video go to the Media tab, everything else to Documents. */
+export const isMediaFile = (file: UserFile): boolean => {
+  const mime = (file.mimetype || '').toLowerCase();
+  if (mime.startsWith('image/') || mime.startsWith('video/')) {return true;}
+  if (mime) {return false;}
+  // Deployments that don't store a mimetype still name the file.
+  return /\.(jpe?g|png|gif|webp|heic|heif|mp4|mov|m4v|3gp|avi|mkv)$/i.test(
+    file.name
+  );
+};