@ethora/chat-component-rn 26.8.2 → 26.8.4

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/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
@@ -254,6 +255,14 @@ 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 || '';

package/src/roomStore/chatSettingsSlice.ts

@@ -12,6 +12,7 @@ import {
 import { Iso639_1Codes } from '../types/models/language.model';
 import type { TranslateMode } from '../utils/translateModePolicy';
 import { secureUserStorage } from '../helpers/secureUserStorage';
+import { applyThemePreference, type ThemePreference } from '../theme/theme';
 
 export interface ChatState {
   user: User;
@@ -29,6 +30,14 @@ export interface ChatState {
    * See utils/translateModePolicy.
    */
   translateMode?: TranslateMode;
+  /**
+   * Appearance picked in Settings (light / dark / system). Persisted per
+   * device; folded into `config.dark` by setConfig / setThemePreference so
+   * every consumer of `config` sees the effective value.
+   */
+  themePreference?: ThemePreference;
+  /** Push notifications toggle from Settings. `undefined` = on. */
+  pushEnabled?: boolean;
 }
 
 export const unpackAndTransform = (input?: User): User => {
@@ -126,11 +135,22 @@ const reducers = {
       };
     }
   },
+  setThemePreference: (
+    state: WritableDraft<ChatState>,
+    action: PayloadAction<ThemePreference | undefined>
+  ) => {
+    state.themePreference = action.payload;
+    state.config = applyThemePreference(state.config as IConfig | undefined, action.payload) as any;
+  },
+  setPushEnabled: (state: WritableDraft<ChatState>, action: PayloadAction<boolean>) => {
+    state.pushEnabled = action.payload;
+  },
   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;
+    // type inference but are inert at write-time. The user's in-app
+    // appearance choice survives a host re-dispatch.
+    state.config = applyThemePreference(action.payload, state.themePreference) as any;
   },
   setActiveModal: (state: WritableDraft<ChatState>, action: PayloadAction<ModalType | undefined>) => {
     state.activeModal = action.payload;
@@ -220,6 +240,8 @@ export const {
   setStoreClient,
   setLangSource,
   setTranslateMode,
+  setThemePreference,
+  setPushEnabled,
 } = chatSlice.actions;
 
 export default chatSlice.reducer;