@ethora/chat-component-rn 26.8.1 → 26.8.3

package/src/services/pushRegistration.ts

@@ -0,0 +1,356 @@
+import { store } from '../roomStore';
+import {
+  PushRegistrationError,
+  detectPushTokenType,
+  registerPushSubscription,
+  subscribeToPushGateway,
+  unregisterPushSubscription,
+} from '../networking/api-requests/push.api';
+import type { PushTokenType } from '../types/types';
+import { pushLog } from '../utils/devLogger';
+
+export interface RegisterPushTokenOptions {
+  tokenType?: PushTokenType;
+}
+
+export type RegisterPushTokenOutcome =
+  | 'registered'
+  | 'deferred'
+  | 'disabled';
+
+export interface UnregisterPushTokenOptions {
+  tokenType?: PushTokenType;
+}
+
+export type UnregisterPushTokenOutcome =
+  | 'unregistered'
+  | 'forgotten';
+
+export interface RegisteredPushToken {
+  token: string;
+  tokenType: PushTokenType;
+}
+
+type Slot = 'chat' | 'voip';
+const slotOf = (tokenType: PushTokenType): Slot =>
+  tokenType === 'apns-voip' ? 'voip' : 'chat';
+const SLOTS: Slot[] = ['chat', 'voip'];
+
+interface Session {
+  authToken: string;
+  appId: string;
+  xmppUsername: string;
+  projectName: string;
+  gatewayUrl: string;
+  pushDisabled: boolean;
+}
+
+interface ServerRegistration extends RegisteredPushToken {
+  appId: string;
+  xmppUsername: string;
+  gateway: boolean;
+}
+
+const HOOK_RETRY_MS = 30_000;
+
+const held = new Map<Slot, RegisteredPushToken>();
+const registered = new Map<Slot, ServerRegistration>();
+let inflight: Promise<void> | null = null;
+let unwatch: (() => void) | null = null;
+let hookIdentity: string | null = null;
+let hookFailedAt = 0;
+
+const readSession = (): Session => {
+  const slice = store.getState().chatSettingStore;
+  const user = slice?.user;
+  const config = slice?.config;
+  return {
+    authToken: String(user?.token || ''),
+    appId: String(config?.appId || user?.appId || '').trim(),
+    xmppUsername: String(user?.xmppUsername || ''),
+    projectName: String(config?.projectName || '').trim(),
+    gatewayUrl: String(config?.pushNotifications?.apiUrl || '').trim(),
+    pushDisabled: config?.pushNotifications?.enabled === false,
+  };
+};
+
+const isGateway = (session: Session): boolean => !!session.gatewayUrl;
+
+const isReady = (session: Session): boolean =>
+  !!session.authToken &&
+  (isGateway(session)
+    ? !!session.xmppUsername && !!session.projectName
+    : !!session.appId);
+
+const sameRegistration = (
+  token: RegisteredPushToken,
+  current: ServerRegistration | undefined,
+  session: Session
+): boolean =>
+  !!current &&
+  current.token === token.token &&
+  current.tokenType === token.tokenType &&
+  current.gateway === isGateway(session) &&
+  current.appId === session.appId &&
+  current.xmppUsername === session.xmppUsername;
+
+const slotsNeedingRegistration = (session: Session): Slot[] =>
+  SLOTS.filter((slot) => {
+    const token = held.get(slot);
+    return !!token && !sameRegistration(token, registered.get(slot), session);
+  });
+
+const releaseOnServer = async (
+  current: ServerRegistration,
+  authToken: string
+): Promise<void> => {
+  if (current.gateway || !authToken) {
+    return;
+  }
+  await unregisterPushSubscription({
+    appId: current.appId,
+    token: current.token,
+    authToken,
+  });
+};
+
+const registerOne = async (
+  token: RegisteredPushToken,
+  session: Session
+): Promise<void> => {
+  if (isGateway(session)) {
+    if (!session.projectName) {
+      throw new PushRegistrationError(
+        'registerPushToken: config.projectName is required when ' +
+          'pushNotifications.apiUrl points at a push gateway.'
+      );
+    }
+    await subscribeToPushGateway({
+      apiUrl: session.gatewayUrl,
+      token: token.token,
+      userJid: session.xmppUsername,
+      projectName: session.projectName,
+      authToken: session.authToken,
+    });
+  } else {
+    if (!session.appId) {
+      throw new PushRegistrationError(
+        'registerPushToken: an app id is required — set config.appId ' +
+          'or sign in with a user that carries one.'
+      );
+    }
+    await registerPushSubscription({
+      appId: session.appId,
+      token: token.token,
+      tokenType: token.tokenType,
+      authToken: session.authToken,
+    });
+  }
+  registered.set(slotOf(token.tokenType), {
+    ...token,
+    appId: session.appId,
+    xmppUsername: session.xmppUsername,
+    gateway: isGateway(session),
+  });
+  pushLog(
+    'rn',
+    `push: ${token.tokenType} token registered` +
+      (isGateway(session) ? ' (gateway)' : ` for app ${session.appId}`)
+  );
+};
+
+const registerNow = (): Promise<void> => {
+  if (inflight) {
+    return inflight;
+  }
+  inflight = (async () => {
+    const session = readSession();
+    if (session.pushDisabled || !session.authToken) {
+      return;
+    }
+    if (isGateway(session) && !session.xmppUsername) {
+      return;
+    }
+    for (const slot of slotsNeedingRegistration(session)) {
+      const token = held.get(slot)!;
+      const previous = registered.get(slot);
+      if (previous && previous.xmppUsername === session.xmppUsername) {
+        registered.delete(slot);
+        await releaseOnServer(previous, session.authToken).catch((error) =>
+          pushLog('warn', 'push: releasing the replaced token failed', error)
+        );
+      }
+      await registerOne(token, session);
+    }
+  })().finally(() => {
+    inflight = null;
+  });
+  return inflight;
+};
+
+const runTokenHook = (session: Session): void => {
+  const hook = store.getState().chatSettingStore?.config?.pushNotifications
+    ?.getPushTokens;
+  const identity = session.xmppUsername || session.appId;
+  if (!hook || !identity || hookIdentity === identity) {
+    return;
+  }
+  if (Date.now() - hookFailedAt < HOOK_RETRY_MS) {
+    return;
+  }
+  hookIdentity = identity;
+  (async () => {
+    const result = await hook();
+    const list = Array.isArray(result) ? result : result ? [result] : [];
+    for (const entry of list) {
+      if (typeof entry?.token !== 'string' || !entry.token.trim()) {
+        continue;
+      }
+      hold(entry.token.trim(), entry.tokenType);
+    }
+    await registerNow();
+  })().catch((error) => {
+    hookIdentity = null;
+    hookFailedAt = Date.now();
+    pushLog('warn', 'push: getPushTokens failed; will retry', error);
+  });
+};
+
+const hold = (token: string, tokenType?: PushTokenType): RegisteredPushToken => {
+  const resolved = tokenType ?? detectPushTokenType(token);
+  const entry: RegisteredPushToken = { token, tokenType: resolved };
+  held.set(slotOf(resolved), entry);
+  return entry;
+};
+
+const ensureWatching = (): void => {
+  if (unwatch) {
+    return;
+  }
+  unwatch = store.subscribe(() => {
+    const session = readSession();
+    if (!session.authToken) {
+      hookIdentity = null;
+      return;
+    }
+    if (session.pushDisabled || !isReady(session)) {
+      return;
+    }
+    runTokenHook(session);
+    if (slotsNeedingRegistration(session).length === 0) {
+      return;
+    }
+    registerNow().catch((error) => {
+      pushLog('warn', 'push: deferred token registration failed', error);
+    });
+  });
+};
+
+export const installPushTokenHook = (): void => {
+  ensureWatching();
+  const session = readSession();
+  if (session.authToken && !session.pushDisabled && isReady(session)) {
+    runTokenHook(session);
+  }
+};
+
+export async function registerPushToken(
+  token: string,
+  options?: RegisterPushTokenOptions
+): Promise<RegisterPushTokenOutcome> {
+  if (typeof token !== 'string' || !token.trim()) {
+    throw new TypeError('registerPushToken: token must be a non-empty string');
+  }
+  hold(token.trim(), options?.tokenType);
+  ensureWatching();
+
+  const session = readSession();
+  if (session.pushDisabled) {
+    return 'disabled';
+  }
+  if (!session.authToken || (isGateway(session) && !session.xmppUsername)) {
+    return 'deferred';
+  }
+  await registerNow();
+  return 'registered';
+}
+
+export async function releasePushRegistration(): Promise<void> {
+  const current = Array.from(registered.values());
+  registered.clear();
+  hookIdentity = null;
+  const session = readSession();
+  if (!current.length || !session.authToken) {
+    return;
+  }
+  await Promise.all(
+    current.map((entry) =>
+      releaseOnServer(entry, session.authToken)
+        .then(() =>
+          pushLog('rn', `push: ${entry.tokenType} token released for app ${entry.appId}`)
+        )
+        .catch((error) =>
+          pushLog('warn', 'push: releasing the token on logout failed', error)
+        )
+    )
+  );
+}
+
+export async function unregisterPushToken(
+  options?: UnregisterPushTokenOptions
+): Promise<UnregisterPushTokenOutcome> {
+  const slots = options?.tokenType ? [slotOf(options.tokenType)] : SLOTS;
+  const toRelease: ServerRegistration[] = [];
+  for (const slot of slots) {
+    held.delete(slot);
+    const current = registered.get(slot);
+    if (current) {
+      registered.delete(slot);
+      toRelease.push(current);
+    }
+  }
+  const session = readSession();
+  const removable = toRelease.filter((entry) => !entry.gateway);
+  if (!removable.length) {
+    return 'forgotten';
+  }
+  if (!session.authToken) {
+    pushLog(
+      'warn',
+      'push: unregisterPushToken called without a session; the backend still holds the token'
+    );
+    return 'forgotten';
+  }
+  const results = await Promise.allSettled(
+    removable.map((entry) => releaseOnServer(entry, session.authToken))
+  );
+  const failure = results.find((r) => r.status === 'rejected') as
+    | PromiseRejectedResult
+    | undefined;
+  if (failure) {
+    throw failure.reason;
+  }
+  return 'unregistered';
+}
+
+export const getRegisteredPushToken = (): RegisteredPushToken | null => {
+  const chat = held.get('chat');
+  return chat ? { ...chat } : null;
+};
+
+export const getRegisteredPushTokens = (): RegisteredPushToken[] =>
+  SLOTS.map((slot) => held.get(slot))
+    .filter((t): t is RegisteredPushToken => !!t)
+    .map((t) => ({ ...t }));
+
+export const __resetPushRegistrationForTests = (): void => {
+  held.clear();
+  registered.clear();
+  inflight = null;
+  hookIdentity = null;
+  hookFailedAt = 0;
+  if (unwatch) {
+    unwatch();
+    unwatch = null;
+  }
+};

package/src/services/pushSubscriptionService.ts

@@ -1,15 +1,11 @@
 import { Client } from '@xmpp/client';
-import { User } from '../types/types';
 import AsyncStorage from '@react-native-async-storage/async-storage';
-import { subscribeToPushNotifications } from '../networking/api-requests/push.api';
 import { subscribeToRoomMessages } from '../networking/xmpp/subscribeToRoomMessages.xmpp';
 
 const SUBSCRIBED_ROOMS_KEY = 'ethora_subscribed_rooms';
 
 export class PushSubscriptionService {
   private subscribedRooms: Set<string> = new Set();
-  private isPushSubscribed: boolean = false;
-  private lastSubscriptionKey: string | null = null;
   private isInitialized: boolean = false;
 
   private async loadSubscribedRoomsFromStorage(): Promise<void> {
@@ -36,34 +32,6 @@ export class PushSubscriptionService {
     }
   }
 
-  async subscribeToPush(
-    fcmToken: string,
-    user: User,
-    projectName: string,
-  ): Promise<void> {
-    const walletAddress = user.defaultWallet?.walletAddress || user.walletAddress;
-    const subscriptionKey = `${fcmToken}_${walletAddress}`;
-
-    if (this.isPushSubscribed && this.lastSubscriptionKey === subscriptionKey) {
-      console.log('⚠️ Push already subscribed with this token, skipping...');
-      return;
-    }
-
-    try {
-      const userJid: string = user.xmppUsername || '';
-
-      if (!userJid) {
-        throw new Error('User JID is required for push subscription');
-      }
-
-      await subscribeToPushNotifications(fcmToken, userJid, projectName);
-      this.isPushSubscribed = true;
-      this.lastSubscriptionKey = subscriptionKey;
-    } catch (error: any) {
-      console.error('Failed to subscribe to push after all retries:', error);
-    }
-  }
-
   async subscribeToRoom(
     client: Client,
     roomJID: string,
@@ -81,7 +49,9 @@ export class PushSubscriptionService {
         this.subscribedRooms.add(roomJID);
         await this.saveSubscribedRoomsToStorage();
       }
-      console.log('Successfully Subscribed to room', roomJID);
+      if (!result) {
+        console.warn('[PushService] MucSub subscribe refused for', roomJID);
+      }
       return result;
     } catch (error) {
       console.error(`[PushService] Failed to subscribe to room ${roomJID}:`, error);
@@ -92,36 +62,37 @@ export class PushSubscriptionService {
   async subscribeToRooms(
     client: Client,
     roomJIDs: string[],
-    userNick?: string
+    userNick?: string,
+    concurrency = 8
   ): Promise<void> {
     let successful = 0;
     let failed = 0;
 
-    console.log('test roomJIDs', roomJIDs);
+    await this.loadSubscribedRoomsFromStorage();
+    const pending = roomJIDs.filter((jid) => !this.subscribedRooms.has(jid));
+    if (!pending.length) {
+      return;
+    }
 
-    for (const roomJID of roomJIDs) {
-      try {
-        const result = await this.subscribeToRoom(client, roomJID, userNick);
-        console.log('test roomJID-1', result);
-        if (result) {
+    for (let i = 0; i < pending.length; i += concurrency) {
+      const batch = pending.slice(i, i + concurrency);
+      const results = await Promise.allSettled(
+        batch.map((roomJID) => this.subscribeToRoom(client, roomJID, userNick))
+      );
+      for (const r of results) {
+        if (r.status === 'fulfilled' && r.value) {
           successful++;
         } else {
           failed++;
         }
-        await new Promise(resolve => setTimeout(resolve, 100));
-      } catch (error) {
-        failed++;
-        console.error(`Failed to subscribe to room ${roomJID}:`, error);
       }
     }
 
-    console.log(`Subscribed to ${successful} rooms, ${failed} failed`);
+    console.log(`[PushService] MucSub: ${successful} rooms subscribed, ${failed} failed`);
   }
 
   async reset(): Promise<void> {
     this.subscribedRooms.clear();
-    this.isPushSubscribed = false;
-    this.lastSubscriptionKey = null;
     this.isInitialized = false;
 
     try {

package/src/theme/index.ts

@@ -0,0 +1,10 @@
+/** @format */
+
+export {
+  LIGHT_THEME,
+  DARK_THEME,
+  resolveTheme,
+  isDarkTheme,
+} from './theme';
+export type { ChatTheme, ChatThemeColors, ChatThemeOverrides } from './theme';
+export { useTheme } from '../hooks/useTheme';

package/src/theme/styled.d.ts

@@ -0,0 +1,9 @@
+/** @format */
+
+import 'styled-components/native';
+import type { ChatTheme } from './theme';
+
+declare module 'styled-components/native' {
+  // eslint-disable-next-line @typescript-eslint/no-empty-interface
+  export interface DefaultTheme extends ChatTheme {}
+}