@amityco/ts-sdk-react-native 6.36.1-938a6a9.0 → 7.0.1-91b5585.0

package/src/channelRepository/api/deleteChannel.ts

@@ -1,6 +1,7 @@
 import { getActiveClient } from '~/client/api';
 
-import { getChannel } from './getChannel';
+import { getChannel } from '../internalApi/getChannel';
+import { constructChannelDynamicValue } from '../utils/constructChannelDynamicValue';
 
 /**
  * ```js
@@ -29,5 +30,5 @@ export const deleteChannel = async (
   const deleted = await getChannel(channelId);
   // no need for event, fired by server
 
-  return deleted.data;
+  return constructChannelDynamicValue(deleted.data);
 };

package/src/channelRepository/api/getChannelByIds.ts

@@ -8,8 +8,8 @@ import { pushToTombstone } from '~/cache/api/pushToTombstone';
 import { prepareChannelPayload } from '../utils';
 import { fireEvent } from '~/core/events';
 import { prepareUnreadCountInfo } from '../utils/prepareUnreadCountInfo';
-import { LinkedObject } from '~/utils/linkedObject';
-import { constructChannelDynamicValue } from '../utils/constructChannelDynamicValue';
+
+import { constructChannelObject } from '../utils/constructChannelObject';
 
 /**
  * ```js
@@ -65,7 +65,7 @@ export const getChannelByIds = async (
   fireEvent('local.channel.fetched', data.channels);
 
   return {
-    data: data.channels.map(channel => LinkedObject.channel(constructChannelDynamicValue(channel))),
+    data: data.channels.map(channel => constructChannelObject(channel)),
     cachedAt,
   };
 };
@@ -91,7 +91,7 @@ getChannelByIds.locally = (
 
   if (!client.cache) return;
 
-  const cached = queryCache<Amity.InternalChannel>(['channel', 'get'])?.filter(({ data }) => {
+  const cached = queryCache<Amity.StaticInternalChannel>(['channel', 'get'])?.filter(({ data }) => {
     return channelIds.includes(data.channelPublicId);
   });
 
@@ -101,7 +101,7 @@ getChannelByIds.locally = (
   const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
 
   return {
-    data: channels.map(channel => LinkedObject.channel(channel)),
+    data: channels.map(channel => constructChannelObject(channel)),
     cachedAt: oldest.cachedAt,
   };
 };

package/src/channelRepository/api/index.ts

@@ -9,5 +9,3 @@ export * from './leaveChannel';
 
 export * from './muteChannel';
 export * from './unmuteChannel';
-
-export * from './markAsRead';

package/src/channelRepository/channelMembership/observers/getMembers/ChannelMemberLiveCollectionController.ts

@@ -137,14 +137,6 @@ export class ChannelMemberLiveCollectionController extends LiveCollectionControl
       });
     }
 
-    if (this.query.search) {
-      // eslint-disable-next-line no-console
-      console.warn(
-        '`search` param will be deprecated in the next major release. If you want to search channel members by displayName, Please use `searchMembers()` instead.',
-      );
-      channelMembers = filterBySearchTerm(channelMembers, this.query.search);
-    }
-
     if (this.query.includeDeleted === false) {
       channelMembers = channelMembers.filter(member => member.user?.isDeleted !== true);
     }

package/src/channelRepository/channelMembership/observers/getMembers/getMembers.ts

@@ -38,14 +38,6 @@ export const applyFilter = <T extends Amity.Membership<'channel'>>(
     });
   }
 
-  if (params.search) {
-    // eslint-disable-next-line no-console
-    console.warn(
-      '`search` param will be deprecated in the next major release. If you want to search channel members by displayName, Please use `searchMembers()` instead.',
-    );
-    channelMembers = filterBySearchTerm(channelMembers, params.search);
-  }
-
   // sort, 'lastCreated' is the default sort order
   const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
   channelMembers = channelMembers.sort(

package/src/channelRepository/channelMembership/observers/searchMembers/SearchChannelMemberLiveCollectionController.ts

@@ -135,14 +135,6 @@ export class SearchChannelMemberLiveCollectionController extends LiveCollectionC
       channelMembers = channelMembers.filter(member => member.user?.isDeleted !== true);
     }
 
-    if (this.query.search) {
-      // eslint-disable-next-line no-console
-      console.warn(
-        '`search` param will be deprecated in the next major release. If you want to search channel members by displayName, Please use `searchMembers()` instead.',
-      );
-      channelMembers = filterBySearchTerm(channelMembers, this.query.search);
-    }
-
     return channelMembers;
   }
 }

package/src/channelRepository/channelMembership/observers/searchMembers/searchMembers.ts

@@ -38,14 +38,6 @@ export const applyFilter = <T extends Amity.Membership<'channel'>>(
     });
   }
 
-  if (params.search) {
-    // eslint-disable-next-line no-console
-    console.warn(
-      '`search` param will be deprecated in the next major release. If you want to search channel members by displayName, Please use `searchMembers()` instead.',
-    );
-    channelMembers = filterBySearchTerm(channelMembers, params.search);
-  }
-
   // sort, 'lastCreated' is the default sort order
   const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
   channelMembers = channelMembers.sort(

package/src/channelRepository/{api → internalApi}/getChannel.ts

@@ -27,7 +27,7 @@ import { constructChannelDynamicValue } from '../utils/constructChannelDynamicVa
  */
 export const getChannel = async (
   channelId: Amity.Channel['channelPublicId'],
-): Promise<Amity.Cached<Amity.InternalChannel>> => {
+): Promise<Amity.Cached<Amity.StaticInternalChannel>> => {
   const client = getActiveClient();
   client.log('channel/getChannel', channelId);
 
@@ -60,7 +60,7 @@ export const getChannel = async (
   const { channels } = data;
 
   return {
-    data: constructChannelDynamicValue(channels.find(channel => channel.channelId === channelId)!),
+    data: channels.find(channel => channel.channelId === channelId)!,
     cachedAt,
   };
 };
@@ -80,7 +80,7 @@ export const getChannel = async (
  */
 getChannel.locally = (
   channelId: Amity.Channel['channelPublicId'],
-): Amity.Cached<Amity.InternalChannel> | undefined => {
+): Amity.Cached<Amity.StaticInternalChannel> | undefined => {
   const client = getActiveClient();
   client.log('channel/getChannel.locally', channelId);
 
@@ -94,7 +94,7 @@ getChannel.locally = (
   if (!cached || cached?.length === 0) return;
 
   return {
-    data: constructChannelDynamicValue(cached[0].data),
+    data: cached[0].data,
     cachedAt: cached[0].cachedAt,
   };
 };

package/src/channelRepository/internalApi/getChannelByIds.ts

@@ -0,0 +1,105 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { queryCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { prepareChannelPayload } from '../utils';
+import { fireEvent } from '~/core/events';
+import { prepareUnreadCountInfo } from '../utils/prepareUnreadCountInfo';
+
+/**
+ * ```js
+ * import { getChannelByIds } from '@amityco/ts-sdk'
+ * const channels = await getChannelByIds(['foo', 'bar'])
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Channel} objects
+ *
+ * @param channelIds the IDs of the {@link Amity.Channel} to fetch
+ * @returns the associated collection of {@link Amity.Channel} objects
+ *
+ * @category Channel API
+ * @async
+ */
+export const getChannelByIds = async (
+  channelIds: Amity.Channel['channelPublicId'][],
+): Promise<Amity.Cached<Amity.StaticInternalChannel[]>> => {
+  const client = getActiveClient();
+  client.log('channel/getChannelByIds', channelIds);
+
+  const encodedChannelIds = channelIds.map(channelId => encodeURIComponent(channelId));
+
+  let payload: Amity.ChannelPayload;
+
+  try {
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const response = await client.http.get<Amity.ChannelPayload>(`/api/v3/channels/list`, {
+      params: { channelIds: encodedChannelIds },
+    });
+
+    payload = response.data;
+  } catch (error) {
+    channelIds.forEach(channelId => {
+      if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+        // NOTE: use channelPublicId as tombstone cache key since we cannot get the channelPrivateId that come along with channel data from server
+        pushToTombstone('channel', channelId);
+      }
+    });
+
+    throw error;
+  }
+
+  const data = await prepareChannelPayload(payload);
+
+  if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+    await prepareUnreadCountInfo(payload);
+  }
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  fireEvent('local.channel.fetched', data.channels);
+
+  return {
+    data: data.channels,
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { getChannelByIds } from '@amityco/ts-sdk'
+ * const channels = getChannelByIds.locally(['foo', 'bar']) ?? []
+ * ```
+ *
+ * Fetches a collection of {@link Amity.Channel} objects from cache
+ *
+ * @param channelIds the IDs of the {@link Amity.Channel} to fetch
+ * @returns the associated collection of {@link Amity.Channel} objects
+ *
+ * @category Channel API
+ */
+getChannelByIds.locally = (
+  channelIds: Amity.Channel['channelPublicId'][],
+): Amity.Cached<Amity.StaticInternalChannel[]> | undefined => {
+  const client = getActiveClient();
+  client.log('channel/getChannelByIds.locally', channelIds);
+
+  if (!client.cache) return;
+
+  const cached = queryCache<Amity.StaticInternalChannel>(['channel', 'get'])?.filter(({ data }) => {
+    return channelIds.includes(data.channelPublicId);
+  });
+
+  if (!cached || cached?.length < channelIds.length) return;
+
+  const channels = cached.map(({ data }) => data);
+  const oldest = cached.sort((a, b) => (a.cachedAt! < b.cachedAt! ? -1 : 1))?.[0];
+
+  return {
+    data: channels,
+    cachedAt: oldest.cachedAt,
+  };
+};

package/src/channelRepository/{api → internalApi}/markAsRead.ts

@@ -8,9 +8,6 @@ import { fireEvent } from '~/core/events';
  * import { ChannelRepository } from '@amityco/ts-sdk-react-native'
  * const success = await ChannelRepository.markAsRead('channelId')
  * ```
- *
- * @deprecated Please use the {@link Amity.Channel.markAsRead} method instead
- *
  * Updating all {@link Amity.SubChannel} in specify {@link Amity.Channel} as read
  *
  * @param channelId the ID of to specify {@link Amity.Channel}

package/src/channelRepository/observers/getChannel.ts

@@ -1,7 +1,7 @@
 import { convertEventPayload } from '~/utils/event';
 import { onChannelMarkerFetched } from '~/marker/events';
 import { liveObject } from '~/utils/liveObject';
-import { getChannel as _getChannel } from '../api/getChannel';
+import { getChannel as _getChannel } from '../internalApi/getChannel';
 import {
   onChannelDeleted,
   onChannelJoined,
@@ -28,14 +28,12 @@ import {
   handleSubChannelUpdated,
 } from '~/messagePreview/utils/updateMessagePreviewFromMessage';
 import { getActiveClient } from '~/client/api/activeClient';
-import { getChannelMessagePreviewWithUser } from '~/messagePreview/utils';
 import { isEqual } from '~/utils/isEqual';
 import { updateChannelCache } from '../utils/updateChannelCache';
 import { onChannelMarkerUpdated } from '~/marker/events/onChannelMarkerUpdated';
 import { onSubChannelCreated } from '~/subChannelRepository';
-import { LinkedObject } from '~/utils/linkedObject';
 import { onChannelUnreadUpdatedLocal } from '~/marker/events/onChannelUnreadUpdatedLocal';
-import { constructChannelDynamicValue } from '../utils/constructChannelDynamicValue';
+import { constructChannelObject } from '../utils/constructChannelObject';
 
 /* begin_public_function
   id: channel.get
@@ -68,15 +66,14 @@ export const getChannel = (
   let snapshot: Omit<Amity.LiveObjectCallback<Amity.Channel>, 'origin'>;
 
   const reactor = async (
-    response: Amity.LiveObject<Amity.InternalChannel<any>>,
+    response: Amity.LiveObject<Amity.StaticInternalChannel<any>>,
   ): Promise<Amity.LiveObjectCallback<Amity.Channel> | undefined> => {
-    if (!response.data) return callback(response as Amity.LiveObject<Amity.Channel>);
+    if (!response.data) return callback(response as unknown as Amity.LiveObject<Amity.Channel>);
 
     const data = {
       ...response,
-      data: LinkedObject.channel(
-        constructChannelDynamicValue(getChannelMessagePreviewWithUser(response.data)),
-      ),
+
+      data: constructChannelObject(response.data),
     };
 
     const { origin, ...newSnapshot } = data;
@@ -120,7 +117,11 @@ export const getChannel = (
             if (message.channelId !== channelId) return;
 
             // channelId from message is channelInternalId
-            const channel = pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data;
+            const channel = pullFromCache<Amity.StaticInternalChannel>([
+              'channel',
+              'get',
+              channelId,
+            ])?.data;
             if (!channel) return;
 
             updateChannelCache(channel, {
@@ -149,7 +150,11 @@ export const getChannel = (
             if (message.channelId !== channelId) return;
 
             // channelId from message is channelInternalId
-            const channel = pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data;
+            const channel = pullFromCache<Amity.StaticInternalChannel>([
+              'channel',
+              'get',
+              channelId,
+            ])?.data;
             if (!channel) return;
 
             updateChannelCache(channel, {
@@ -167,7 +172,11 @@ export const getChannel = (
       convertEventPayload(
         (callback: Amity.Listener<Amity.InternalMessage>) => {
           const updateMessagePreview = async (message: Amity.InternalMessage) => {
-            const channel = pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data;
+            const channel = pullFromCache<Amity.StaticInternalChannel>([
+              'channel',
+              'get',
+              channelId,
+            ])?.data;
             if (!channel || channel.messagePreviewId !== message.messageId) return;
 
             const messagePreviewSetting = await client.getMessagePreviewSetting(false);
@@ -187,7 +196,11 @@ export const getChannel = (
       convertEventPayload(
         (callback: Amity.Listener<Amity.InternalMessage>) => {
           const updateMessagePreview = async (message: Amity.InternalMessage) => {
-            const channel = pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data;
+            const channel = pullFromCache<Amity.StaticInternalChannel>([
+              'channel',
+              'get',
+              channelId,
+            ])?.data;
             if (!channel || channel.messagePreviewId !== message.messageId) return;
 
             const messagePreviewSetting = await client.getMessagePreviewSetting(false);
@@ -230,7 +243,11 @@ export const getChannel = (
 
             await _getChannel(channelId);
 
-            const channel = pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data;
+            const channel = pullFromCache<Amity.StaticInternalChannel>([
+              'channel',
+              'get',
+              channelId,
+            ])?.data;
             if (!channel) return;
 
             callback(subChannel);
@@ -262,7 +279,11 @@ export const getChannel = (
             )
               return;
 
-            const channel = pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data;
+            const channel = pullFromCache<Amity.StaticInternalChannel>([
+              'channel',
+              'get',
+              channelId,
+            ])?.data;
             if (!channel) return;
 
             callback(subChannel);

package/src/channelRepository/observers/getChannels/ChannelLiveCollectionController.ts

@@ -43,7 +43,7 @@ import {
   handleMessageUpdated,
   handleSubChannelUpdated,
 } from '~/messagePreview/utils';
-import { getChannel } from '~/channelRepository/api/getChannel';
+import { getChannel } from '~/channelRepository/internalApi/getChannel';
 import { getActiveClient } from '~/client';
 import { prepareChannelPayload } from '~/channelRepository/utils';
 import { ChannelPaginationNoPageController } from './ChannelPagnationNoPageController';
@@ -55,9 +55,8 @@ import { prepareUnreadCountInfo } from '~/channelRepository/utils/prepareUnreadC
 import { resolveUnreadInfoOnChannelEvent } from '~/channelRepository/utils/resolveUnreadInfoOnChannelEvent';
 import { onChannelResolved } from '~/channelRepository/events/onChannelResolved';
 import { onUserMessageFeedMarkerResolved } from '~/marker/events/onUserMessageFeedMarkerResolved';
-import { LinkedObject } from '~/utils/linkedObject';
 import { onChannelUnreadUpdatedLocal } from '~/marker/events/onChannelUnreadUpdatedLocal';
-import { constructChannelDynamicValue } from '~/channelRepository/utils/constructChannelDynamicValue';
+import { constructChannelObject } from '~/channelRepository/utils/constructChannelObject';
 
 export class ChannelLiveCollectionController extends LiveCollectionController<
   'channel',
@@ -133,14 +132,14 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
     const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(this.cacheKey)?.data;
     if (!collection) return;
 
-    let data =
+    let data: Amity.Channel[] =
       collection.data
-        .map(channelId => pullFromCache<Amity.Channel>(['channel', 'get', channelId])!)
+        .map(
+          channelId => pullFromCache<Amity.StaticInternalChannel>(['channel', 'get', channelId])!,
+        )
         .filter(Boolean)
         .map(({ data }) => data)
-        .map(getChannelMessagePreviewWithUser)
-        .map(constructChannelDynamicValue)
-        .map(LinkedObject.channel) ?? [];
+        .map(constructChannelObject) ?? [];
 
     if (this.paginationController instanceof ChannelPaginationController) {
       data = this.applyFilter(data);
@@ -264,7 +263,7 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
                   Amity.ReferenceType.USER_MESSAGE_FEED_MARKER,
                 );
 
-              const channelCache = pullFromCache<Amity.Channel>([
+              const channelCache = pullFromCache<Amity.StaticInternalChannel>([
                 'channel',
                 'get',
                 message.channelId,
@@ -291,7 +290,7 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
         fn: convertEventPayload(
           (callback: Amity.Listener<Amity.InternalMessage>) => {
             return onMessageCreatedLocal(message => {
-              const cacheData = pullFromCache<Amity.Channel>([
+              const cacheData = pullFromCache<Amity.StaticInternalChannel>([
                 'channel',
                 'get',
                 message.channelId,
@@ -370,7 +369,7 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
 
               if (this.shouldAbort(message.channelId)) return;
 
-              const channel = pullFromCache<Amity.Channel>([
+              const channel = pullFromCache<Amity.StaticInternalChannel>([
                 'channel',
                 'get',
                 message.channelId,
@@ -404,7 +403,7 @@ export class ChannelLiveCollectionController extends LiveCollectionController<
 
               if (this.shouldAbort(message.channelId)) return;
 
-              const channel = pullFromCache<Amity.Channel>([
+              const channel = pullFromCache<Amity.StaticInternalChannel>([
                 'channel',
                 'get',
                 message.channelId,

package/src/channelRepository/observers/index.ts

@@ -1,4 +1,2 @@
-export * from './observeChannel';
-export * from './observeChannels';
 export * from './getChannel';
 export * from './getChannels';

package/src/channelRepository/utils/constructChannelDynamicValue.ts

@@ -5,18 +5,13 @@ import { getSubChannelsUnreadCount } from './getSubChannelsUnreadCount';
 export const constructChannelDynamicValue = (
   channel: Amity.StaticInternalChannel,
 ): Amity.InternalChannel => {
-  return shallowClone(channel, {
-    get unreadCount() {
-      return getSubChannelsUnreadCount(channel);
-    },
-    get hasMentioned() {
-      return getChannelIsMentioned(channel);
-    },
+  const { messageCount, ...rest } = channel;
+  return shallowClone(rest, {
     get isMentioned() {
-      return getChannelIsMentioned(channel);
+      return getChannelIsMentioned(rest);
     },
     get subChannelsUnreadCount() {
-      return getSubChannelsUnreadCount(channel);
+      return getSubChannelsUnreadCount(rest);
     },
   });
 };

package/src/channelRepository/utils/constructChannelObject.ts

@@ -0,0 +1,16 @@
+import { getChannelMessagePreviewWithUser } from '~/messagePreview/utils';
+import { constructChannelDynamicValue } from './constructChannelDynamicValue';
+import { LinkedObject } from '~/utils/linkedObject';
+
+export const constructChannelObject = (channel: Amity.StaticInternalChannel): Amity.Channel => {
+  /**
+   * convert internal cache data to be public channel data
+   * 1. [getChannelMessagePreviewWithUser] add messagePreview >> Amity.InternalChannel -> Amity.InternalChannel
+   * 2. [constructChannelDynamicValue] construct getter value >> Amity.StaticInternalChannel -> Amity.Channel
+   * 3. [LinkedObject.channel] add markAsRead >> Amity.InternalChannel -> Amity.Channel
+   */
+
+  return LinkedObject.channel(
+    constructChannelDynamicValue(getChannelMessagePreviewWithUser(channel)),
+  );
+};

package/src/channelRepository/utils/getChannelIsMentioned.ts

@@ -29,7 +29,10 @@ const getUnreadInfoCached = (channelId: Amity.RawChannel['channelId']) => {
  * If not found in the both cache, use `false` as defaul value.
  */
 
-export const getChannelIsMentioned = (channel: Amity.RawChannel, marker?: Amity.ChannelMarker) => {
+export const getChannelIsMentioned = (
+  channel: Omit<Amity.RawChannel, 'messageCount'>,
+  marker?: Amity.ChannelMarker,
+) => {
   const client = getActiveClient();
 
   if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {

package/src/channelRepository/utils/getSubChannelsUnreadCount.ts

@@ -30,7 +30,7 @@ const getUnreadInfoCached = (channelId: Amity.RawChannel['channelId']) => {
  */
 
 export const getSubChannelsUnreadCount = (
-  channel: Amity.RawChannel,
+  channel: Omit<Amity.RawChannel, 'messageCount'>,
   marker?: Amity.ChannelMarker,
 ) => {
   const client = getActiveClient();

package/src/channelRepository/utils/resolveChannels.ts

@@ -1,8 +1,13 @@
-import { getChannelByIds } from '../api/getChannelByIds';
+import { queryCache } from '~/cache/api';
+import { getChannelByIds } from '../internalApi/getChannelByIds';
 import { fireEvent } from '~/core/events';
 
 export const resolveChannels = async (channelIds: Amity.InternalChannel['channelPublicId'][]) => {
-  const { data: channels } = await getChannelByIds(channelIds);
+  await getChannelByIds(channelIds);
+  const channels =
+    queryCache<Amity.StaticInternalChannel>(['channel', 'get'])
+      ?.filter(({ data }) => data.channelPublicId && channelIds.includes(data.channelPublicId))
+      ?.map(({ data }) => data) ?? [];
 
   fireEvent('local.channel.resolved', channels);
 };

package/src/channelRepository/utils/updateChannelCache.ts

@@ -1,7 +1,10 @@
 import { pushToCache } from '~/cache/api';
 import { shallowClone } from '~/utils/shallowClone';
 
-export function updateChannelCache(channel: Amity.Channel, params: Partial<Amity.Channel>) {
+export function updateChannelCache(
+  channel: Amity.StaticInternalChannel,
+  params: Partial<Amity.StaticInternalChannel>,
+) {
   pushToCache(
     ['channel', 'get', channel.channelId],
     // eslint-disable-next-line prefer-object-spread

package/src/client/observers/getUserUnread.ts

@@ -70,7 +70,7 @@ export const getUserUnread = (
 
     callback({
       data: callbackModel
-        ? { ...callbackModel, hasMentioned: callbackModel.isMentioned }
+        ? { ...callbackModel, isMentioned: callbackModel.isMentioned }
         : callbackModel,
 
       loading: data.loading,

package/src/client/observers/index.ts

@@ -1,2 +1 @@
-export * from './getTotalUnreadCount';
 export * from './getUserUnread';

package/src/client/utils/endpoints.ts

@@ -5,7 +5,7 @@ export const API_REGIONS = {
 } as const;
 
 const URLS = {
-  http: 'https://api.{region}.amity.co',
+  http: 'https://apix.{region}.amity.co',
   mqtt: 'wss://sse.{region}.amity.co:443/mqtt',
 } as const;
 

package/src/client/utils/markerSyncEngine.ts

@@ -229,15 +229,6 @@ export const stopUnreadSync = () => {
   unRegisterEventListeners();
 };
 
-/**
- * @deprecated Please use `startUnreadSync` instead
- */
-export const stopUnreadSyncing = () => {
-  console.warn('`stopUnreadSyncing` has been deprecated, please use `stopUnreadSync` instead');
-
-  return stopUnreadSync();
-};
-
 setIntervalTask(async () => {
   if (!isSyncRunning) return;
 

package/src/client/utils/subscribeGlobalTopic.ts

@@ -7,6 +7,7 @@ import {
   getSmartFeedSubChannelTopic,
   getUserTopic,
   subscribeTopic,
+  getLiveStreamTopic,
 } from '~/core/subscription';
 
 export const subscribeGlobalTopic = () => {
@@ -19,6 +20,8 @@ export const subscribeGlobalTopic = () => {
     // subscribing to user topic is necessary to handle ban event
     subscribeTopic(getUserTopic(getActiveUser())),
     subscribeTopic(getMarkerUserFeedTopic()),
+
+    subscribeTopic(getLiveStreamTopic()),
   ];
 
   return () => disposers.forEach(fn => fn());

package/src/commentRepository/observers/index.ts

@@ -1,4 +1,2 @@
-export * from './observeComments';
-export * from './observeComment';
 export * from './getComment';
 export * from './getComments';

package/src/communityRepository/api/index.ts

@@ -6,6 +6,3 @@ export * from './deleteCommunity';
 
 export * from './joinCommunity';
 export * from './leaveCommunity';
-
-// deprecated
-export * from './getTopTrendingCommunities';