@ethora/chat-component-rn 26.6.12 → 26.6.13

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,79 +158,91 @@ export function uploadFile(formData: FormData) {
   });
 }
 
-const UPLOAD_PATH = '/files/';
-
-/**
- * Multipart upload of a picked file, sent over `XMLHttpRequest`.
- *
- * The transport matters here, and both obvious alternatives are wrong:
- *
- *   - `fetch`. Expo SDK 54 shipped a WinterCG-compliant fetch and SDK 57
- *     installs it as the GLOBAL fetch. It accepts only `Blob` / `File` /
- *     string form parts, so React Native's own `{ uri, type, name }` part
- *     — which is exactly what an image/document picker hands us — is
- *     rejected with "Unsupported FormDataPart implementation", surfacing
- *     to the caller as ERR_NETWORK. A host can set
- *     `EXPO_PUBLIC_USE_RN_FETCH=1`, but that opts their whole app out of
- *     Expo's fetch just to satisfy this SDK; not a cost we get to impose
- *     on a consumer.
- *   - axios. It forces its own `Content-Type: multipart/form-data`
- *     WITHOUT a boundary, so the server mis-parses one file as many and
- *     answers HTTP 413 TOO_MANY_FILES (bug #10 — this is why the upload
- *     was moved off axios in the first place).
- *
- * `XMLHttpRequest` avoids both. Expo replaces `fetch`, not `XHR`, so the
- * request still goes through React Native's native networking module,
- * which understands the `{ uri, type, name }` part, streams the file
- * straight from disk (a 50MB video never lands in JS memory) and writes
- * its own `Content-Type` with a valid boundary — which is precisely why
- * we must NOT set that header ourselves below.
- */
-export function uploadFileMultipart(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(/\/$/, '')}${UPLOAD_PATH}`;
 
   pushLog('http', `→ POST ${url} (xhr)`, {
-    headers: { Authorization: token ? token.slice(0, 16) + '…' : '[empty]', Accept: '*/*' },
+    path,
+    baseUrl: getCurrentBaseURL() || '[empty]',
+    headers: {
+      Authorization: token ? token.slice(0, 16) + '…' : '[empty]',
+      Accept: '*/*',
+    },
   });
 
   return new Promise((resolve, reject) => {
     const xhr = new XMLHttpRequest();
 
     const failNetwork = (reason: string) => {
-      pushLog('http', `← ERR xhr ${UPLOAD_PATH}`, { reason });
+      pushLog('http', `← ERR xhr ${path}`, { reason, url });
       const err: any = new Error(reason);
       err.code = 'ERR_NETWORK';
-      err.config = { url: UPLOAD_PATH };
+      err.config = { url: path };
       reject(err);
     };
 
     xhr.onload = () => {
       const status = xhr.status;
-      let body: any = null;
+      let responseBody: any = null;
       try {
-        body = JSON.parse(xhr.responseText);
+        responseBody = JSON.parse(xhr.responseText);
       } catch {
-        body = xhr.responseText || null;
+        responseBody = xhr.responseText || null;
       }
 
       if (status < 200 || status >= 300) {
-        pushLog('http', `← ${status} POST ${UPLOAD_PATH} (xhr)`, body);
+        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: body };
-        err.config = { url: UPLOAD_PATH };
+        err.response = { status, statusText: xhr.statusText, data: responseBody };
+        err.config = { url: path };
         reject(err);
         return;
       }
 
-      pushLog('http', `← ${status} POST ${UPLOAD_PATH} (xhr)`, {
-        resultsCount: Array.isArray(body?.results) ? body.results.length : 'n/a',
+      pushLog('http', `← ${status} POST ${path} (xhr)`, {
+        resultsCount: Array.isArray(responseBody?.results)
+          ? responseBody.results.length
+          : 'n/a',
       });
-      resolve({ data: body });
+      resolve({ data: responseBody });
     };
 
     xhr.onerror = () => failNetwork('Network request failed');
@@ -226,8 +252,55 @@ export function uploadFileMultipart(formData: FormData): Promise<{ data: any }>
     xhr.open('POST', url);
     xhr.setRequestHeader('Authorization', token);
     xhr.setRequestHeader('Accept', '*/*');
-    // Deliberately no Content-Type — see the note above: RN fills it in
-    // along with the multipart boundary it generated.
-    xhr.send(formData as any);
+    // 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);
+
+    try {
+      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
+      );
+    }
+  }
+
+  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',

package/src/networking/apiClient.ts

@@ -1,8 +1,13 @@
 import axios from 'axios';
 import { store } from '../roomStore';
 
-import { logout, refreshTokens } from '../roomStore/chatSettingsSlice';
+import { logout } from '../roomStore/chatSettingsSlice';
 import { installAxiosCapture } from '../utils/devLogger';
+import {
+  refreshAuthTokens,
+  isRefreshFatalError,
+  RefreshResult,
+} from './authRefresh';
 
 // Per product-code-policy: no compiled-in Ethora endpoints or tokens.
 // Consumers must call `setBaseURL(baseUrl, appToken)` (or pass
@@ -21,10 +26,21 @@ const http = axios.create({
 // `http` instance.
 installAxiosCapture(http);
 
+const stripApiVersion = (baseUrl: string): string =>
+  baseUrl.replace(/\/+$/, '').replace(/\/v\d+$/, '');
+
+export const normalizeApiPath = (path?: string): string | undefined => {
+  if (!path) {return path;}
+  if (/^https?:\/\//i.test(path)) {return path;}
+  if (/^\/v\d+\//.test(path)) {return path;}
+  return `/v1${path.startsWith('/') ? '' : '/'}${path}`;
+};
+
 export function setBaseURL(baseUrl?: string, appToken?: string) {
-  if (baseUrl && baseUrl !== currentBaseURL) {
-    currentBaseURL = baseUrl;
-    http.defaults.baseURL = baseUrl;
+  const normalized = baseUrl ? stripApiVersion(baseUrl) : baseUrl;
+  if (normalized && normalized !== currentBaseURL) {
+    currentBaseURL = normalized;
+    http.defaults.baseURL = normalized;
   }
   if (appToken && appToken !== currentAppToken) {
     currentAppToken = appToken;
@@ -39,149 +55,78 @@ export function getCurrentBaseURL() {
   return currentBaseURL;
 }
 
-export function refresh(): Promise<{
-  data: { refreshToken: string; token: string };
-}> {
-  return new Promise((resolve, reject) => {
-    const user = store.getState().chatSettingStore.user;
-    try {
-      http
-        .post(
-          '/users/login/refresh',
-          {},
-          { headers: { Authorization: user.refreshToken } }
-        )
-        .then((response) => {
-          store.dispatch(
-            refreshTokens({
-              token: response.data.token,
-              refreshToken: response.data.refreshToken,
-            })
-          );
-          // BUGFIX: previously the `.then` only dispatched and never
-          // resolved, so every `await refresh()` callsite hung forever
-          // on the happy path. Resolve with the axios response shape so
-          // the interceptor can read `tokens.data.token` to retry.
-          resolve(response);
-        })
-        .catch((error) => {
-          reject(error);
-        });
-    } catch (error) {
-      // BUGFIX: previously the outer-try catch dispatched logout but
-      // never rejected, so a synchronous throw from `http.post` (e.g.
-      // a bad URL) would hang the promise. Reject explicitly.
-      console.log('errr');
-      store.dispatch(logout());
-      reject(error);
-    }
-  });
+/**
+ * @deprecated Import `refreshAuthTokens` from `./authRefresh` instead.
+ *
+ * Kept as a thin forwarder so existing call sites keep working while
+ * they migrate. Declared as a function (not `const refresh =
+ * refreshAuthTokens`) on purpose: this module and `authRefresh` import
+ * each other, and a const would capture the binding before the other
+ * module finished evaluating.
+ */
+export function refresh(): Promise<RefreshResult> {
+  return refreshAuthTokens();
 }
 
-let isRefreshing = false;
-let failedQueue: any[] = [];
-
-const addRequestToQueue = (config: any) => {
-  return new Promise((resolve, reject) => {
-    failedQueue.push({ resolve, reject, config });
-  });
-};
-
-const processQueue = (newAccessToken: string) => {
-  for (const request of failedQueue) {
-    if (newAccessToken) {
-      request.config.headers.Authorization = newAccessToken;
-    }
-
-    request.resolve(http(request.config));
-  }
-
-  failedQueue = [];
-};
-
 http.interceptors.response.use(
   (response) => response,
   async (error) => {
-    // BUGFIX: the original condition was `if (!enabled)` — inverted, so
-    // turning `refreshTokens.enabled: true` actually DISABLED the refresh
-    // path on 401. Use the correct sense.
-    if (!store.getState().chatSettingStore?.config?.refreshTokens?.enabled) {
-      // BUGFIX: previously this branch fell off the end of the async
-      // function and returned `undefined`, which axios treats as a
-      // resolved-with-undefined response. Callers expecting an error
-      // got `undefined` instead, silently swallowing every failure
-      // when the refresh path isn't configured. Re-reject so the
-      // original error reaches the caller.
-      return Promise.reject(error);
-    }
-
     const originalRequest = error.config;
     const status = error.response?.status;
 
     // Refresh paths only fire on 401. Anything else passes through.
-    if (!error.response || status !== 401) {
+    if (!error.response || status !== 401 || !originalRequest) {
       return Promise.reject(error);
     }
 
+    // Never retry twice, and never touch the auth endpoints themselves —
+    // both would recurse. (`_retry` was set but never checked before,
+    // so a request could bounce between 401 and replay indefinitely.)
     if (
-      store.getState().chatSettingStore?.config?.refreshTokens?.refreshFunction
+      originalRequest._retry ||
+      originalRequest.url === '/v1/users/login/refresh' ||
+      originalRequest.url === '/v1/users/login'
     ) {
-      // Consumer-supplied refresh function. Call it, dispatch the new
-      // tokens, retry the original request.
-      try {
-        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: newRefreshToken || '',
-          })
-        );
-        // BUGFIX: previously this branch returned `undefined` after
-        // dispatching, so the original request was never retried and
-        // the caller resolved with undefined. Stamp the new token on
-        // the original config and replay.
-        if (originalRequest?.headers) {
-          originalRequest.headers.Authorization = accessToken;
-        }
-        return http(originalRequest);
-      } catch (refreshErr) {
-        return Promise.reject(refreshErr);
-      }
+      return Promise.reject(error);
     }
 
-    // Built-in `/users/login/refresh` path. Skip if the failing request
-    // IS the refresh / login itself — otherwise we'd loop forever.
-    if (
-      originalRequest.url === '/users/login/refresh' ||
-      originalRequest.url === '/users/login'
-    ) {
+    const refreshConfig =
+      store.getState().chatSettingStore?.config?.refreshTokens;
+
+    // BUGFIX (kept): the original condition here was inverted, so
+    // `refreshTokens.enabled: true` actually DISABLED the refresh path.
+    if (!refreshConfig?.enabled) {
       return Promise.reject(error);
     }
 
-    originalRequest._retry = true;
-
-    if (isRefreshing) {
-      const retryOriginalRequest = addRequestToQueue(originalRequest);
-      return retryOriginalRequest;
+    // Nothing to rotate with — reject rather than firing a doomed
+    // refresh that would look like a bad-token event to the backend.
+    const hasRefreshableSession = Boolean(
+      refreshConfig.refreshFunction ||
+        store.getState().chatSettingStore.user?.refreshToken
+    );
+    if (!hasRefreshableSession) {
+      return Promise.reject(error);
     }
 
-    isRefreshing = true;
+    originalRequest._retry = true;
+
     try {
-      const tokens = await refresh();
-      // (was: console.log('tokens', tokens) — dumped the full response
-      // incl. access/refresh/ws tokens on every refresh; removed.)
-      isRefreshing = false;
-      originalRequest.headers.Authorization = tokens.data.token;
-      processQueue(tokens.data.token);
+      // One shared rotation for every 401 in flight — `refreshAuthTokens`
+      // dedupes internally, which replaces the old isRefreshing/
+      // failedQueue machinery entirely.
+      const tokens = await refreshAuthTokens();
+      originalRequest.headers = originalRequest.headers || {};
+      originalRequest.headers.Authorization = tokens.token;
       return http(originalRequest);
     } catch (refreshErr) {
-      isRefreshing = false;
-      // BUGFIX: previously this returned the error (resolving the
-      // promise with the error as value) instead of rejecting, so
-      // axios callers got the error as a "successful" response body.
+      // Only a genuinely dead session logs the user out. A network
+      // blip, a 5xx, or a REFRESH_IN_PROGRESS race must leave the
+      // session alone — logging out on those is exactly the mass-logout
+      // failure mode the new backend scheme would otherwise cause.
+      if (isRefreshFatalError(refreshErr)) {
+        store.dispatch(logout());
+      }
       return Promise.reject(refreshErr);
     }
   }