@amityco/ts-sdk 6.35.2-cd7f86f.0 → 6.35.3-024c022.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/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,107 @@
+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';
+import { LinkedObject } from '~/utils/linkedObject';
+import { constructChannelDynamicValue } from '../utils/constructChannelDynamicValue';
+
+/**
+ * ```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.Channel[]>> => {
+  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.map(channel => LinkedObject.channel(constructChannelDynamicValue(channel))),
+    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.Channel[]> | undefined => {
+  const client = getActiveClient();
+  client.log('channel/getChannelByIds.locally', channelIds);
+
+  if (!client.cache) return;
+
+  const cached = queryCache<Amity.InternalChannel>(['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.map(channel => LinkedObject.channel(channel)),
+    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'
  * 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,
@@ -68,12 +68,13 @@ 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,
+      // TODO: refactor to be a function to construct public channel object
       data: LinkedObject.channel(
         constructChannelDynamicValue(getChannelMessagePreviewWithUser(response.data)),
       ),

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';
@@ -133,13 +133,18 @@ 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)
+        // add messagePreview >> Amity.InternalChannel -> Amity.InternalChannel
         .map(getChannelMessagePreviewWithUser)
+        // construct getter value >> Amity.StaticInternalChannel -> Amity.Channel
         .map(constructChannelDynamicValue)
+        // add markAsRead >> Amity.InternalChannel -> Amity.Channel
         .map(LinkedObject.channel) ?? [];
 
     if (this.paginationController instanceof ChannelPaginationController) {

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,9 @@
+import { getChannelMessagePreviewWithUser } from '~/messagePreview/utils';
+import { constructChannelDynamicValue } from './constructChannelDynamicValue';
+import { LinkedObject } from '~/utils/linkedObject';
+
+export const constructChannelObject = (channel: Amity.StaticInternalChannel): 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 { queryCache } from '~/cache/api';
 import { getChannelByIds } from '../api/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/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';

package/src/communityRepository/api/queryCommunities.ts

@@ -30,7 +30,7 @@ export const queryCommunities = async (
 
   // safe decapsulation
   const { page, limit = 10, ...params } = query ?? {};
-  const { displayName, membership, includeDeleted, ...restParams } = params ?? {};
+  const { membership, includeDeleted, ...restParams } = params ?? {};
 
   const options = (() => {
     if (page) return { token: page };
@@ -48,7 +48,6 @@ export const queryCommunities = async (
       params: {
         ...restParams,
         isDeleted: inferIsDeleted(includeDeleted),
-        keyword: displayName,
         filter: membership,
         options,
       },

package/src/communityRepository/communityMembership/observers/getMembers/CommunityMembersLiveCollectionController.ts

@@ -149,10 +149,6 @@ export class CommunityMembersLiveCollectionController extends LiveCollectionCont
       });
     }
 
-    if (this.query.search) {
-      communityMembers = filterBySearchTerm(communityMembers, this.query.search);
-    }
-
     if (this.query.includeDeleted === false) {
       communityMembers = communityMembers.filter(({ user }) => user?.isDeleted !== true);
     }
@@ -161,14 +157,6 @@ export class CommunityMembersLiveCollectionController extends LiveCollectionCont
       case 'firstCreated':
         communityMembers = communityMembers.sort(sortByFirstCreated);
         break;
-      case 'displayName':
-        communityMembers = communityMembers.sort((a, b) => {
-          if (a?.user?.displayName && b?.user?.displayName) {
-            return a?.user?.displayName.localeCompare(b?.user?.displayName);
-          }
-          return 0;
-        });
-        break;
       case 'lastCreated':
       default:
         communityMembers = communityMembers.sort(sortByLastCreated);

package/src/communityRepository/communityMembership/observers/getMembers/CommunityMembersQueryStreamController.ts

@@ -76,13 +76,6 @@ export class CommunityMembersQueryStreamController extends QueryStreamController
       )?.data;
       if (!collection) return;
 
-      if (
-        action === EnumCommunityMemberActions.OnCommunityUserRoleAdded &&
-        this.query.sortBy === 'displayName'
-      ) {
-        return;
-      }
-
       communityMembers.forEach(communityMember => {
         const communityMemberCacheId = getResolver('communityUsers')({
           communityId: this.query.communityId,

package/src/communityRepository/communityMembership/observers/getMembers.ts

@@ -26,10 +26,6 @@ export const applyFilter = <T extends Amity.Membership<'community'>>(
     });
   }
 
-  if (params.search) {
-    communityMembers = filterBySearchTerm(communityMembers, params.search);
-  }
-
   const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
   communityMembers = communityMembers.sort(
     sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated,

package/src/communityRepository/communityMembership/observers/searchMembers/SearchCommunityMembersPaginationController.ts

@@ -7,7 +7,7 @@ import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
  */
 export class SearchCommunityMembersPaginationController extends PaginationController<
   'communityUser',
-  Amity.CommunityMemberLiveCollection
+  Amity.SearchCommunityMemberLiveCollection
 > {
   async getRequest(
     queryParams: Amity.SearchCommunityMemberLiveCollection,

package/src/communityRepository/observers/getCommunities/CommunitiesLiveCollectionController.ts

@@ -138,22 +138,18 @@ export class CommunityLiveCollectionController extends LiveCollectionController<
       communities = filterByCommunityMembership(communities, this.query.membership, userId);
     }
 
-    if (!this.query.displayName) {
-      const sortFn = (() => {
-        switch (this.query.sortBy) {
-          case 'firstCreated':
-            return sortByFirstCreated;
-          case 'lastCreated':
-            return sortByLastCreated;
-          case 'displayName':
-            return sortByDisplayName;
-          default:
-            return sortByLastCreated;
-        }
-      })();
-
-      communities = communities.sort(sortFn);
-    }
+    const sortFn = (() => {
+      switch (this.query.sortBy) {
+        case 'firstCreated':
+          return sortByFirstCreated;
+        case 'lastCreated':
+          return sortByLastCreated;
+        default:
+          return sortByLastCreated;
+      }
+    })();
+
+    communities = communities.sort(sortFn);
 
     return communities;
   }

package/src/communityRepository/observers/getCommunities/CommunitiesPaginationController.ts

@@ -20,7 +20,6 @@ export class CommunitiesPaginationController extends PaginationController<
         params: {
           ...params,
           isDeleted: inferIsDeleted(params.includeDeleted),
-          keyword: params.displayName,
           filter: params.membership,
           options,
         },

package/src/communityRepository/observers/getCommunities/CommunitiesQueryStreamController.ts

@@ -64,10 +64,6 @@ export class CommunitiesQueryStreamController extends QueryStreamController<
       const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(this.cacheKey)?.data;
       if (!collection) return;
 
-      if (this.query.displayName && action === EnumCommunityActions.OnCommunityCreated) {
-        return;
-      }
-
       /*
        * Simply update a collection and let responder decide what to do with data
        */

package/src/communityRepository/observers/index.ts

@@ -1,5 +1,3 @@
-export * from './observeCommunity';
-
 export * from './searchCommunities';
 export * from './getCommunities';
 export * from './getCommunity';

package/src/core/events.ts

@@ -15,10 +15,6 @@ const WS_EVENTS = [
   'sessionStateChange',
   // for internal use by accessTokenExpiryWatcher
   'tokenExpired',
-
-  'v3.video-streaming.didRecord',
-  'v3.video-streaming.didStart',
-  'v3.video-streaming.didStop',
 ] as const;
 
 const MQTT_EVENTS = [
@@ -30,6 +26,12 @@ const MQTT_EVENTS = [
   'end',
   'reconnect',
 
+  'video-streaming.didStart',
+  'video-streaming.didRecord',
+  'video-streaming.didStop',
+  'video-streaming.didFlag',
+  'video-streaming.didTerminate',
+
   'user.didGlobalBan',
 ] as const;
 

package/src/core/subscription.ts

@@ -168,3 +168,9 @@ export function subscribeTopic(
 
   return mqtt.subscribe(topic, callback);
 }
+
+export const getLiveStreamTopic = (): string => {
+  const user = getActiveUser();
+
+  return `${getNetworkId(user)}/videostreaming`;
+};