@ethora/chat-component-rn 26.8.1 → 26.8.3

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/push.api.ts

@@ -1,86 +1,209 @@
 import axios from 'axios';
 import { Platform } from 'react-native';
 import { store } from '../../roomStore';
+import http from '../apiClient';
+import type { PushTokenType } from '../../types/types';
 
-// Both of these used to be hardcoded to the ethoradev environment
-// (push.ethoradev.com, @xmpp.ethoradev.com). That is a development
-// deployment: shipping it inside the SDK meant every host app, including
-// production ones, registered its device against dev infrastructure and
-// then quietly received no pushes. They are resolved from the host's own
-// config now, with the production cluster as the fallback.
-const DEFAULT_PUSH_API_URL = 'https://push.chat.ethora.com/api/v1';
-const DEFAULT_XMPP_HOST = 'xmpp.chat.ethora.com';
+export type { PushTokenType } from '../../types/types';
+
+export type PushDeviceType = 'ios' | 'android' | 'web';
 
 /**
- * Push service base URL. `config.pushNotifications.apiUrl` wins, so a
- * self-hosted or enterprise deployment can point at its own service
- * without forking the SDK.
+ * Registration failed in a way the host should know about: the backend
+ * refused the payload (`status` + `body` carry its answer) or the request
+ * never got there (`status` undefined).
  */
-const resolvePushApiUrl = (): string => {
-  const config = store.getState().chatSettingStore?.config;
-  return (
-    (config?.pushNotifications?.apiUrl || '').trim() || DEFAULT_PUSH_API_URL
+export class PushRegistrationError extends Error {
+  readonly status?: number;
+  readonly body?: unknown;
+
+  constructor(message: string, status?: number, body?: unknown) {
+    super(message);
+    this.name = 'PushRegistrationError';
+    this.status = status;
+    this.body = body;
+  }
+}
+
+export const isPushRegistrationError = (
+  error: unknown
+): error is PushRegistrationError =>
+  (error as PushRegistrationError)?.name === 'PushRegistrationError';
+
+const EXPO_PUSH_TOKEN = /^Expo(?:nent)?PushToken\[[^\]]+\]$/;
+const APNS_TOKEN = /^[0-9a-f]{64,}$/i;
+
+export const detectPushTokenType = (token: string): PushTokenType => {
+  const t = token.trim();
+  if (EXPO_PUSH_TOKEN.test(t)) {
+    return 'expo';
+  }
+  if (APNS_TOKEN.test(t)) {
+    return 'apns';
+  }
+  return 'fcm';
+};
+
+export const resolvePushDeviceType = (): PushDeviceType =>
+  Platform.OS === 'ios' ? 'ios' : 'android';
+
+const toRegistrationError = (error: any, what: string): PushRegistrationError => {
+  const status: number | undefined = error?.response?.status;
+  const body = error?.response?.data;
+  const detail =
+    (typeof body?.error === 'string' && body.error) ||
+    error?.message ||
+    'unknown error';
+  return new PushRegistrationError(
+    status
+      ? `${what} refused (HTTP ${status}): ${detail}`
+      : `${what} failed: ${detail}`,
+    status,
+    body
   );
 };
 
-/**
- * The XMPP host the JID is qualified with. Must match the host the client
- * actually connects to, or the push service files the subscription under a
- * JID nothing ever sends to.
- */
+const isUnknownFieldError = (error: any): boolean =>
+  error?.response?.status === 422 &&
+  /not allowed/i.test(String(error?.response?.data?.error ?? ''));
+
+export interface PushSubscriptionPayload {
+  registrationToken: string;
+  deviceType: PushDeviceType;
+  tokenType?: PushTokenType;
+}
+
+export interface RegisterPushSubscriptionArgs {
+  appId: string;
+  token: string;
+  tokenType: PushTokenType;
+  authToken: string;
+}
+
+export const buildPushSubscriptionPayload = (
+  token: string,
+  tokenType: PushTokenType
+): PushSubscriptionPayload => ({
+  registrationToken: token,
+  deviceType: resolvePushDeviceType(),
+  tokenType,
+});
+
+export async function registerPushSubscription({
+  appId,
+  token,
+  tokenType,
+  authToken,
+}: RegisterPushSubscriptionArgs): Promise<void> {
+  const path = `/v1/push/subscription/${encodeURIComponent(appId)}`;
+  const headers = { Authorization: authToken };
+  const payload = buildPushSubscriptionPayload(token, tokenType);
+
+  try {
+    await http.post(path, payload, { headers });
+    return;
+  } catch (error: any) {
+    const canDowngrade = tokenType === 'apns' || tokenType === 'fcm';
+    if (!(canDowngrade && isUnknownFieldError(error))) {
+      throw toRegistrationError(
+        error,
+        tokenType === 'expo'
+          ? 'Push registration (the backend does not accept Expo push tokens yet)'
+          : 'Push registration'
+      );
+    }
+  }
+
+  try {
+    await http.post(
+      path,
+      { registrationToken: payload.registrationToken, deviceType: payload.deviceType },
+      { headers }
+    );
+  } catch (error: any) {
+    throw toRegistrationError(error, 'Push registration');
+  }
+}
+
+export interface UnregisterPushSubscriptionArgs {
+  appId: string;
+  token: string;
+  authToken: string;
+}
+
+export async function unregisterPushSubscription({
+  appId,
+  token,
+  authToken,
+}: UnregisterPushSubscriptionArgs): Promise<void> {
+  const headers = { Authorization: authToken };
+  try {
+    await http.delete(`/v1/push/subscription/${encodeURIComponent(appId)}`, {
+      headers,
+      data: { registrationToken: token },
+    });
+    return;
+  } catch (error: any) {
+    if (error?.response?.status !== 404) {
+      throw toRegistrationError(error, 'Push unregistration');
+    }
+  }
+  try {
+    await http.delete('/v1/users/endpoints', {
+      headers,
+      data: { endpoint: token },
+    });
+  } catch (error: any) {
+    throw toRegistrationError(error, 'Push unregistration');
+  }
+}
+
+const DEFAULT_XMPP_HOST = 'xmpp.chat.ethora.com';
+
+export interface PushGatewaySubscriptionPayload {
+  projectName: string;
+  registrationToken: string;
+  deviceType: PushDeviceType;
+  jid: string;
+}
+
+export interface GatewaySubscribeArgs {
+  apiUrl: string;
+  token: string;
+  userJid: string;
+  projectName: string;
+  authToken: string;
+}
+
 const resolveXmppHost = (): string => {
   const config = store.getState().chatSettingStore?.config;
   return (config?.xmppSettings?.host || '').trim() || DEFAULT_XMPP_HOST;
 };
 
-const pushAxios = axios.create({
-  headers: {
-    'Content-Type': 'application/json',
-  },
+const gatewayAxios = axios.create({
+  headers: { 'Content-Type': 'application/json' },
 });
 
-export interface PushSubscriptionPayload {
-  projectId: string;
-  registrationToken: string;
-  deviceType: 'web' | 'android' | 'ios';
-  jid: string;
-}
+export const buildPushGatewayPayload = ({
+  token,
+  userJid,
+  projectName,
+}: Pick<GatewaySubscribeArgs, 'token' | 'userJid' | 'projectName'>): PushGatewaySubscriptionPayload => ({
+  projectName,
+  registrationToken: token,
+  deviceType: resolvePushDeviceType(),
+  jid: userJid.includes('@') ? userJid : `${userJid}@${resolveXmppHost()}`,
+});
 
-export async function subscribeToPushNotifications(
-  fcmToken: string,
-  userJid: string,
-  projectName: string = ''
+export async function subscribeToPushGateway(
+  args: GatewaySubscribeArgs
 ): Promise<void> {
-  const deviceType: 'web' | 'android' | 'ios' = Platform.select({
-    ios: 'ios',
-    android: 'android',
-    default: 'web',
-  }) as 'web' | 'android' | 'ios';
-
-  // `userJid` arrives as either a bare localpart or an already-qualified
-  // JID depending on the caller; don't double-qualify it.
-  const jid = userJid.includes('@')
-    ? userJid
-    : `${userJid}@${resolveXmppHost()}`;
-
-  const payload: PushSubscriptionPayload = {
-    projectId: projectName,
-    registrationToken: fcmToken,
-    deviceType,
-    jid,
-  };
-
   try {
-    const token = store.getState().chatSettingStore?.user?.token || '';
-
-    const response = await pushAxios.post('/subscriptions', payload, {
-      baseURL: resolvePushApiUrl(),
-      headers: {
-        Authorization: `Bearer ${token}`,
-      },
+    await gatewayAxios.post('/subscriptions', buildPushGatewayPayload(args), {
+      baseURL: args.apiUrl,
+      headers: { Authorization: `Bearer ${args.authToken}` },
     });
-    return response.data;
   } catch (error: any) {
-    console.error('Failed to subscribe to push notifications:', error);
+    throw toRegistrationError(error, 'Push gateway registration');
   }
 }

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

@@ -130,6 +130,7 @@ function dispatchRoomsFromRestItems(items: ApiRoom[]): void {
       icon: item.picture || item.icon,
       createdAt: item.createdAt,
       updatedAt: item.updatedAt,
+      muted: item.muted === true,
       description: (item as any).description,
       type: (item as any).type,
       // ChatProfileModal renders this list under the description/type
@@ -181,7 +182,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 +207,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 +222,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 +241,7 @@ export async function postPrivateRoom(
 
   try {
     const response = await http.post(
-      '/chats/private',
+      '/v1/chats/private',
       { username },
       {
         headers: {
@@ -254,13 +255,21 @@ export async function postPrivateRoom(
   }
 }
 
+export async function setRoomMuted(chatName: string, muted: boolean): Promise<boolean> {
+  const token = store.getState().chatSettingStore.user.token || '';
+  const url = `/v1/chats/my/${encodeURIComponent(chatName)}/mute`;
+  const config = { headers: { Authorization: token } };
+  const response = muted ? await http.put(url, {}, config) : await http.delete(url, config);
+  return response.data?.result?.muted ?? muted;
+}
+
 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}`,
+      `/v1/chats/reports/${chatName}`,
       { category, text },
       {
         headers: {
@@ -282,7 +291,7 @@ export async function postAddRoomMember(
 
   try {
     const response = await http.post(
-      `/chats/users-access`,
+      `/v1/chats/users-access`,
       { chatName, members },
       {
         headers: {
@@ -301,7 +310,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 +329,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 +369,7 @@ export async function createChatCall(
 
   try {
     await http.post(
-      `/chats/call/create/${chatName}`,
+      `/v1/chats/call/create/${chatName}`,
       { kind },
       {
         headers: {