@amityco/ts-sdk 6.29.3-e60fd01.0 → 6.30.0

package/dist/utils/tests/dummy/follow.d.ts

@@ -7,8 +7,8 @@ export declare const follow22: Amity.FollowStatus;
 export declare const follow23: Amity.FollowStatus;
 export declare const follows: {
     userId: string;
-    page1: Amity.FollowStatus[];
-    page2: Amity.FollowStatus[];
+    page1: Amity.RawFollowStatus[];
+    page2: Amity.RawFollowStatus[];
 };
 export declare const followPayload: Amity.FollowersPayload;
 //# sourceMappingURL=follow.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "6.29.3-e60fd01.0",
+  "version": "6.30.0",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",

package/src/@types/core/events.ts

@@ -139,13 +139,13 @@ declare global {
     };
 
     type MqttFollowEvents = {
-      'follow.created': Amity.FollowersPayload | Amity.FollowStatusPayload;
-      'follow.requested': Amity.FollowersPayload | Amity.FollowStatusPayload;
-      'follow.accepted': Amity.FollowersPayload | Amity.FollowStatusPayload;
-      'follow.unfollowed': Amity.FollowersPayload | Amity.FollowStatusPayload;
-      'follow.requestCanceled': Amity.FollowersPayload | Amity.FollowStatusPayload;
-      'follow.requestDeclined': Amity.FollowersPayload | Amity.FollowStatusPayload;
-      'follow.followerDeleted': Amity.FollowersPayload | Amity.FollowStatusPayload;
+      'follow.created': Amity.FollowersPayload;
+      'follow.requested': Amity.FollowersPayload;
+      'follow.accepted': Amity.FollowersPayload;
+      'follow.unfollowed': Amity.FollowersPayload;
+      'follow.requestCanceled': Amity.FollowersPayload;
+      'follow.requestDeclined': Amity.FollowersPayload;
+      'follow.followerDeleted': Amity.FollowersPayload;
     };
 
     type MqttMarkerEvents = {
@@ -166,6 +166,35 @@ declare global {
       MqttMarkerEvents &
       MqttStoryEvents;
 
+    type LocalPostEvents = {
+      'local.post.updated': Amity.PostPayload;
+      'local.post.deleted': Amity.PostPayload;
+      'local.post.addReaction': { post: Amity.InternalPost };
+      'local.post.removeReaction': { post: Amity.InternalPost };
+    };
+
+    type LocalCommentEvents = {
+      'local.comment.created': Amity.CommentPayload;
+      'local.comment.deleted': Amity.CommentPayload;
+      'local.comment.addReaction': { comment: Amity.InternalComment };
+      'local.comment.removeReaction': { comment: Amity.InternalComment };
+    };
+
+    type LocalCommunityEvents = {
+      'local.community.roleAdded': Amity.ProcessedCommunityPayload;
+      'local.community.roleRemoved': Amity.ProcessedCommunityPayload;
+      'local.community.userAdded': Amity.CommunityMembershipPayload;
+      'local.community.userRemoved': Amity.CommunityMembershipPayload;
+    };
+
+    type LocalFollowEvents = {
+      'local.follow.created': Amity.FollowStatusPayload;
+      'local.follow.requested': Amity.FollowStatusPayload;
+      'local.follow.accepted': Amity.FollowStatusPayload;
+      'local.follow.unfollowed': Amity.FollowStatusPayload;
+      'local.follow.requestDeclined': Amity.FollowStatusPayload;
+    };
+
     type LocalEvents = {
       'local.channel.updated': MakeRequired<Amity.ProcessedChannelPayload, 'channels'>;
       'local.channel.fetched': Amity.InternalChannel[];
@@ -213,17 +242,15 @@ declare global {
       'local.story.error': Amity.StoryPayload;
       'local.story.reload': { referenceIds: Amity.Story['referenceId'][] };
 
-      'local.post.updated': Amity.PostPayload;
-      
-      'local.comment.created': Amity.CommentPayload;
-      'local.comment.deleted': Amity.CommentPayload;
-
       sessionStateChange: Amity.SessionStates;
       // used by accessTokenExpiryWatcher
       tokenExpired: Amity.SessionStates.TOKEN_EXPIRED;
       tokenTerminated: Amity.SessionStates.TERMINATED;
       unreadCountEnabled: boolean;
-    };
+    } & LocalPostEvents &
+      LocalCommentEvents &
+      LocalCommunityEvents &
+      LocalFollowEvents;
 
     type Events = WsEvents & MqttEvents & MqttRTE & LocalEvents;
   }

package/src/@types/core/model.ts

@@ -113,7 +113,7 @@ declare global {
       advertiser: Pick<Amity.Advertiser, 'advertiserId'>;
 
       pinTarget: Pick<Amity.InternalPinTarget, 'targetId'>;
-      pin: Pick<Amity.InternalPin, 'referenceId'>;
+      pin: Pick<Amity.InternalPin, 'placement' | 'referenceId'>;
     };
   }
 }

package/src/@types/core/payload.ts

@@ -21,6 +21,9 @@ declare global {
       globalStoryFeed: Amity.GlobalStoryFeedPayload;
       reaction: Amity.ReactionPayload;
       pinnedPost: Amity.PinnedPostPayload;
+      follower: Amity.FollowersPayload;
+      following: Amity.FollowingsPayload;
+      blockUser: Amity.BlockedUserPayload;
     };
 
     type UserPayload = {
@@ -387,16 +390,26 @@ declare global {
     type GlobalFeedPayload = Amity.PostPayload;
 
     type FollowStatusPayload = {
-      follows: Amity.FollowStatus[];
+      follows: Amity.RawFollowStatus[];
+    };
+
+    type ProcessedFollowStatusPayload = {
+      follows: Amity.InternalFollowStatus[];
     };
 
     type FollowInfoMePayload = {
       followCounts: Amity.FollowCount[];
     };
 
-    // TODO: apply Amity.RawUser type
-    type FollowersPayload = Amity.FollowStatusPayload &
-      Omit<Amity.UserPayload, 'users'> & { users: Amity.InternalUser[] };
+    type FollowersPayload = Amity.FollowStatusPayload & Amity.UserPayload;
+
+    type ProcessedFollowersPayload = Amity.ProcessedFollowStatusPayload & {
+      users: Amity.InternalUser[];
+    };
+
+    type FollowingsPayload = Amity.FollowersPayload;
+
+    type ProcessedFollowingsPayload = Amity.ProcessedFollowersPayload;
 
     type FollowInfoPayload = FollowInfoMePayload & Amity.FollowStatusPayload;
 
@@ -405,9 +418,16 @@ declare global {
       followCounts: Amity.FollowCount[];
     };
 
-    // TODO: apply Amity.RawUser type
-    type BlockedUserPayload = Amity.FollowStatusPayload[] &
-      Omit<Amity.UserPayload, 'users'> & { users: Amity.InternalUser[] } & Amity.BlockedUserPaged;
+    type ProcessedBlockedPayload = {
+      follows: Amity.ProcessedFollowStatusPayload['follows'];
+      followCounts: Amity.FollowCount[];
+    };
+
+    type BlockedUserPayload = Amity.FollowersPayload;
+
+    type ProcessedBlockedUserPayload = Amity.BlockedUserPayload & {
+      users: Amity.InternalUser[];
+    };
 
     type MessagePreviewPayload<T extends Amity.MessageContentType = any> = {
       messageId: string;

package/src/@types/core/permissions.ts

@@ -31,10 +31,10 @@ declare global {
       DeleteUserFeedPostPermission = 'DELETE_USER_FEED_POST',
       EditUserFeedCommentPermission = 'EDIT_USER_FEED_COMMENT',
       DeleteUserFeedCommentPermission = 'DELETE_USER_FEED_COMMENT',
-      EditCommunityFeedPostPermission = 'EDIT_COMMUNITY_FEED_POST',
-      DeleteCommunityFeedPostPermission = 'DELETE_COMMUNITY_FEED_POST',
-      EditCommunityFeedCommentPermission = 'EDIT_COMMUNITY_FEED_COMMENT',
-      DeleteCommunityFeedCommentPermission = 'DELETE_COMMUNITY_FEED_COMMENT',
+      EditCommunityFeedPostPermission = 'EDIT_COMMUNITY_POST',
+      DeleteCommunityFeedPostPermission = 'DELETE_COMMUNITY_POST',
+      EditCommunityFeedCommentPermission = 'EDIT_COMMUNITY_COMMENT',
+      DeleteCommunityFeedCommentPermission = 'DELETE_COMMUNITY_COMMENT',
       CreateCommunityCategoryPermission = 'CREATE_COMMUNITY_CATEGORY',
       EditCommunityCategoryPermission = 'EDIT_COMMUNITY_CATEGORY',
       DeleteCommunityCategoryPermission = 'DELETE_COMMUNITY_CATEGORY',

package/src/@types/domains/follow.ts

@@ -2,24 +2,38 @@ export {};
 
 declare global {
   namespace Amity {
-    type FollowActionType =
-      | 'onRequested'
-      | 'onAccepted'
-      | 'onDeclined'
-      | 'onCanceled'
-      | 'onFollowed'
-      | 'onUnfollowed'
-      | 'onDeleted';
-
-    type FollowStatusType = 'all' | 'pending' | 'accepted' | 'blocked' | 'none';
-
-    type FollowStatus = {
+    const enum FollowActionTypeEnum {
+      OnRequested = 'onRequested',
+      OnAccepted = 'onAccepted',
+      OnDeclined = 'onDeclined',
+      OnCanceled = 'onCanceled',
+      OnFollowed = 'onFollowed',
+      OnUnfollowed = 'onUnfollowed',
+      OnDeleted = 'onDeleted',
+    }
+
+    type FollowActionType = `${FollowActionTypeEnum}`;
+
+    const enum FollowStatusTypeEnum {
+      All = 'all',
+      Pending = 'pending',
+      Accepted = 'accepted',
+      Blocked = 'blocked',
+      None = 'none',
+    }
+
+    type FollowStatusType = `${FollowStatusTypeEnum}`;
+
+    type RawFollowStatus = {
       from: Amity.InternalUser['userId'];
       to: Amity.InternalUser['userId'];
       status: Exclude<FollowStatusType, 'all'>;
     } & Amity.CreatedAt &
       Amity.UpdatedAt;
 
+    type InternalFollowStatus = Amity.RawFollowStatus;
+    type FollowStatus = InternalFollowStatus;
+
     type FollowCount = {
       userId: Amity.InternalUser['userId'];
       followerCount: number;

package/src/@types/domains/post.ts

@@ -51,7 +51,9 @@ declare global {
       Amity.AnalyticPostData &
       Amity.Mentionable<'user'>;
 
-    type InternalPost<T extends PostContentType = any> = RawPost<T>;
+    type InternalPost<T extends PostContentType = any> = RawPost<T> & {
+      feedType?: 'reviewing' | 'published';
+    };
 
     type PostLinkObject = {
       latestComments: (Amity.Comment | null)[];

package/src/@types/domains/user.ts

@@ -2,7 +2,7 @@ export {};
 
 declare global {
   namespace Amity {
-    enum UserSortByEnum {
+    const enum UserSortByEnum {
       FirstCreated = 'firstCreated',
       LastCreated = 'lastCreated',
       /** @deprecated sortBy displayName is not available */
@@ -11,7 +11,7 @@ declare global {
 
     type UserSortBy = `${Amity.UserSortByEnum}`;
 
-    enum SearchUserSortByEnum {
+    const enum SearchUserSortByEnum {
       FirstCreated = 'firstCreated',
       LastCreated = 'lastCreated',
       DisplayName = 'displayName',

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

@@ -22,6 +22,7 @@ import {
   sortByLastCreated,
 } from '~/core/query';
 import { prepareChannelPayload } from '~/channelRepository/utils';
+import { onUserDeleted } from '~/channelRepository/events/onUserDeleted';
 
 export class ChannelMemberLiveCollectionController extends LiveCollectionController<
   'channelUser',
@@ -87,6 +88,7 @@ export class ChannelMemberLiveCollectionController extends LiveCollectionControl
       { fn: onChannelMemberUnbanned, action: 'onChannelMemberUnbanned' },
       { fn: onChannelMemberRoleAdded, action: 'onChannelMemberRoleAdded' },
       { fn: onChannelMemberRoleRemoved, action: 'onChannelMemberRoleRemoved' },
+      { fn: onUserDeleted(this.query.channelId), action: 'onChannelMemberChanged' },
     ]);
   }
 
@@ -143,10 +145,8 @@ export class ChannelMemberLiveCollectionController extends LiveCollectionControl
       channelMembers = filterBySearchTerm(channelMembers, this.query.search);
     }
 
-    if (typeof this.query.includeDeleted === 'boolean') {
-      channelMembers = channelMembers.filter(
-        member => member.user?.isDeleted === this.query.includeDeleted,
-      );
+    if (this.query.includeDeleted === false) {
+      channelMembers = channelMembers.filter(member => member.user?.isDeleted !== true);
     }
 
     // sort, 'lastCreated' is the default sort order

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

@@ -12,15 +12,18 @@ export class ChannelMemberPaginationController extends PaginationController<
   Amity.ChannelMembersLiveCollection
 > {
   async getRequest(queryParams: Amity.ChannelMembersLiveCollection, token: string | undefined) {
-    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted, ...params } = queryParams;
     const options = token ? { token } : { limit };
 
+    const isDeleted = includeDeleted === false ? false : undefined;
+
     const { data: queryResponse } = await this.http.get<
       Amity.ChannelMembershipPayload & Amity.Pagination
     >(`/api/v4/channels/${encodeURIComponent(params.channelId)}/users`, {
       params: {
         ...params,
         options,
+        isDeleted,
       },
     });
     return queryResponse;

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

@@ -16,6 +16,7 @@ import {
 } from '~/channelRepository/events';
 import { filterByPropIntersection, filterBySearchTerm } from '~/core/query';
 import { prepareChannelPayload } from '~/channelRepository/utils';
+import { onUserDeleted } from '~/channelRepository/events/onUserDeleted';
 
 export class SearchChannelMemberLiveCollectionController extends LiveCollectionController<
   'channelUser',
@@ -81,6 +82,7 @@ export class SearchChannelMemberLiveCollectionController extends LiveCollectionC
       { fn: onChannelMemberUnbanned, action: 'onChannelMemberUnbanned' },
       { fn: onChannelMemberRoleAdded, action: 'onChannelMemberRoleAdded' },
       { fn: onChannelMemberRoleRemoved, action: 'onChannelMemberRoleRemoved' },
+      { fn: onUserDeleted(this.query.channelId), action: 'onChannelMemberChanged' },
     ]);
   }
 
@@ -129,6 +131,10 @@ export class SearchChannelMemberLiveCollectionController extends LiveCollectionC
       });
     }
 
+    if (this.query.includeDeleted === false) {
+      channelMembers = channelMembers.filter(member => member.user?.isDeleted !== true);
+    }
+
     if (this.query.search) {
       // eslint-disable-next-line no-console
       console.warn(

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

@@ -12,15 +12,18 @@ export class SearchChannelMemberPaginationController extends PaginationControlle
   Amity.ChannelMembersLiveCollection
 > {
   async getRequest(queryParams: Amity.ChannelMembersLiveCollection, token: string | undefined) {
-    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted, ...params } = queryParams;
     const options = token ? { token } : { limit };
 
+    const isDeleted = includeDeleted === false ? false : undefined;
+
     const { data: queryResponse } = await this.http.get<
       Amity.ChannelMembershipPayload & Amity.Pagination
     >(`/api/v4/channels/${encodeURIComponent(params.channelId)}/users`, {
       params: {
         ...params,
         options,
+        isDeleted,
       },
     });
     return queryResponse;

package/src/channelRepository/events/onUserDeleted.ts

@@ -0,0 +1,46 @@
+import { prepareUserPayload } from '~/userRepository/utils/prepareUserPayload';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { createEventSubscriber } from '~/core/events';
+import { getActiveClient } from '~/client';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+
+export const onUserDeleted =
+  (channelId: string) =>
+  (callback: (channel: Amity.InternalChannel, member: Amity.Membership<'channel'>) => void) => {
+    const client = getActiveClient();
+
+    const filter = (payload: Amity.UserPayload) => {
+      const userPayload = prepareUserPayload(payload);
+
+      if (userPayload.users.length === 0) return;
+
+      const user = userPayload.users[0];
+
+      ingestInCache(userPayload);
+
+      const channelUserCacheKey = getResolver('channelUsers')({
+        channelId,
+        userId: user.userId,
+      });
+
+      const cacheData = pullFromCache<Amity.Membership<'channel'>>([
+        'channelUsers',
+        'get',
+        channelUserCacheKey,
+      ])?.data!;
+
+      upsertInCache(['channelUsers', 'get', channelUserCacheKey], {
+        ...cacheData,
+        user,
+      });
+
+      const channel = pullFromCache<Amity.InternalChannel>(['channel', 'get', channelId])?.data;
+
+      if (!channel) return;
+
+      callback(channel, cacheData);
+    };
+
+    return createEventSubscriber(client, 'user.deleted', 'user.deleted', filter);
+  };

package/src/channelRepository/utils/prepareChannelPayload.ts

@@ -7,7 +7,7 @@ import { getActiveClient } from '~/client/api/activeClient';
 import { pullFromCache } from '~/cache/api/pullFromCache';
 import { getSubChannelsUnreadCount } from './getSubChannelsUnreadCount';
 import { getChannelIsMentioned } from './getChannelIsMentioned';
-import { convertRawUserToInternalUser } from '~/userRepository/utils';
+import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
 
 export const MARKER_INCLUDED_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
 export const isUnreadCountSupport = ({ type }: Pick<Amity.RawChannel, 'type'>) =>

package/src/commentRepository/api/createComment.ts

@@ -51,19 +51,23 @@ export const createComment = async (
   if (client.cache) ingestInCache(data, { cachedAt });
 
   if (['post', 'content'].includes(bundle.referenceType)) {
-    const post = await getPost(bundle.referenceId);
+    const post = pullFromCache<Amity.Post>(['post', 'get', bundle.referenceId])?.data;
 
-    fireEvent('local.post.updated', {
-      posts: [post.data],
-      categories: [],
-      comments: [],
-      communities: [],
-      communityUsers: [],
-      feeds: [],
-      files: [],
-      postChildren: [],
-      users: [],
-    });
+    if (post) {
+      post.commentsCount += 1;
+
+      fireEvent('local.post.updated', {
+        posts: [post],
+        categories: [],
+        comments: [],
+        communities: [],
+        communityUsers: data.communityUsers,
+        feeds: [],
+        files: data.files,
+        postChildren: [],
+        users: data.users,
+      });
+    }
   } else if (bundle.referenceType === 'story') {
     const storyIndex = pullFromCache<Amity.Story['referenceId']>([
       STORY_KEY_CACHE.STORY_ID_TO_REFERENCE_ID,

package/src/commentRepository/api/deleteComment.ts

@@ -3,12 +3,12 @@ import { getActiveClient } from '~/client/api';
 import { upsertInCache } from '~/cache/api';
 import { fireEvent } from '~/core/events';
 
-import { getPost } from '~/postRepository/api/getPost';
 import { pushToTombstone } from '~/cache/api/pushToTombstone';
 import { scheduleTask } from '~/core/microtasks';
 
 import { getStoryByStoryId } from '~/storyRepository/internalApi/getStoryByStoryId';
 import { getComment } from './getComment';
+import { pullFromCache } from '~/cache/api/pullFromCache';
 
 /* begin_public_function
   id: comment.soft_delete, comment.hard_delete
@@ -62,19 +62,29 @@ export const deleteComment = async (
       users: [],
     });
   } else {
-    const post = await getPost(comment.data.referenceId);
+    const post = pullFromCache<Amity.Post>(['post', 'get', comment.data.referenceId])?.data;
 
-    fireEvent('local.post.updated', {
-      posts: [post.data],
-      categories: [],
-      comments: [],
-      communities: [],
-      communityUsers: [],
-      feeds: [],
-      files: [],
-      postChildren: [],
-      users: [],
-    });
+    if (post) {
+      let removeCount: number;
+      if (!deleted.parentId) {
+        // NOTE: delete the parent comment will remove all children comments
+        removeCount = deleted.childrenNumber + 1;
+      } else removeCount = 1;
+
+      post.commentsCount -= removeCount;
+
+      fireEvent('local.post.updated', {
+        posts: [post],
+        categories: [],
+        comments: [],
+        communities: [],
+        communityUsers: [],
+        feeds: [],
+        files: [],
+        postChildren: [],
+        users: [],
+      });
+    }
   }
 
   fireEvent('local.comment.deleted', {

package/src/commentRepository/events/onCommentCreatedLocal.ts

@@ -0,0 +1,22 @@
+import { createCommentEventSubscriber, createLocalCommentEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommentCreated } from '@amityco/ts-sdk'
+ * const dispose = onCommentCreated(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalComment} has been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentCreatedLocal = (
+  callback: Amity.Listener<Amity.InternalComment>,
+): Amity.Unsubscriber => {
+  return createLocalCommentEventSubscriber('local.comment.created', callback);
+};

package/src/commentRepository/events/onCommentDeletedLocal.ts

@@ -0,0 +1,20 @@
+import { createLocalCommentEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommentDeleteLocal } from '@amityco/ts-sdk'
+ * const dispose = onCommentDeleteLocal(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalComment} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onCommentDeleteLocal = (
+  callback: Amity.Listener<Amity.InternalComment>,
+): Amity.Unsubscriber => createLocalCommentEventSubscriber('local.comment.deleted', callback);

package/src/commentRepository/events/onLocalCommentReactionAdded.ts

@@ -0,0 +1,42 @@
+import { getActiveClient } from '~/client/api';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { createEventSubscriber } from '~/core/events';
+import { commentLinkedObject } from '~/utils/linkedObject/commentLinkedObject';
+
+/**
+ * ```js
+ * import { onLocalCommentReactionAdded } from '@amityco/ts-sdk'
+ * const dispose = onLocalCommentReactionAdded(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalComment} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onLocalCommentReactionAdded = (
+  callback: Amity.Listener<Amity.InternalComment>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = ({ comment }: Amity.Events['local.comment.addReaction']) => {
+    if (!client.cache) {
+      callback(comment);
+    } else {
+      upsertInCache(['comment', 'get', comment.commentId], comment);
+
+      callback(commentLinkedObject(comment));
+    }
+  };
+
+  return createEventSubscriber(
+    client,
+    'local.comment.addReaction',
+    'local.comment.addReaction',
+    filter,
+  );
+};

package/src/commentRepository/events/onLocalCommentReactionRemoved.ts

@@ -0,0 +1,42 @@
+import { getActiveClient } from '~/client/api';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { createEventSubscriber } from '~/core/events';
+import { commentLinkedObject } from '~/utils/linkedObject/commentLinkedObject';
+
+/**
+ * ```js
+ * import { onLocalCommentReactionRemoved } from '@amityco/ts-sdk'
+ * const dispose = onLocalCommentReactionRemoved(comment => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.InternalComment} has been reacted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Comment Events
+ */
+export const onLocalCommentReactionRemoved = (
+  callback: Amity.Listener<Amity.InternalComment>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = ({ comment }: Amity.Events['local.comment.removeReaction']) => {
+    if (!client.cache) {
+      callback(comment);
+    } else {
+      upsertInCache(['comment', 'get', comment.commentId], comment);
+
+      callback(commentLinkedObject(comment));
+    }
+  };
+
+  return createEventSubscriber(
+    client,
+    'local.comment.removeReaction',
+    'local.comment.removeReaction',
+    filter,
+  );
+};