@amityco/ts-sdk-react-native 6.29.3-669217e.0 → 6.29.3-fe4e045.0

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

@@ -2,6 +2,23 @@ export {};
 
 declare global {
   namespace Amity {
+    const enum UserSortByEnum {
+      FirstCreated = 'firstCreated',
+      LastCreated = 'lastCreated',
+      /** @deprecated sortBy displayName is not available */
+      DisplayName = 'displayName',
+    }
+
+    type UserSortBy = `${Amity.UserSortByEnum}`;
+
+    const enum SearchUserSortByEnum {
+      FirstCreated = 'firstCreated',
+      LastCreated = 'lastCreated',
+      DisplayName = 'displayName',
+    }
+
+    type SearchUserSortBy = `${Amity.SearchUserSortByEnum}`;
+
     type UserActionType =
       | 'onFetch'
       | 'onUpdate'
@@ -10,14 +27,27 @@ declare global {
       | 'onUnflagged'
       | 'onFlagCleared';
 
-    type InternalUser = {
+    type RawUser = {
       _id: string;
       userId: string;
-      isGlobalBanned: boolean;
+      userInternalId: string;
+      userPublicId: string;
       displayName?: string;
-      avatarFileId?: Amity.File<'image'>['fileId'];
+      avatarFileId?: string;
       avatarCustomUrl?: string;
       description?: string;
+      isBrand: boolean;
+      isGlobalBan: boolean;
+    } & Amity.Metadata &
+      Amity.Taggable &
+      Amity.Flaggable &
+      Amity.Accredited &
+      Amity.Timestamps &
+      Amity.SoftDelete &
+      Amity.Subscribable;
+
+    type InternalUser = Amity.RawUser & {
+      isGlobalBanned: boolean;
     } & Amity.Metadata &
       Amity.Taggable &
       Amity.Flaggable &
@@ -31,16 +61,29 @@ declare global {
     };
 
     type QueryUsers = {
+      /** @deprecated use searchUsers instead */
       displayName?: Amity.InternalUser['displayName'];
       filter?: 'all' | 'flagged';
-      sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+      sortBy?: Amity.UserSortBy | Amity.UserSortByEnum;
       limit?: number;
       page?: string;
     };
 
-    type UserLiveCollection = Amity.LiveCollectionParams<Omit<QueryUsers, 'page'>>;
+    type QuerySearchUsers = {
+      displayName?: Amity.InternalUser['displayName'];
+      filter?: 'all' | 'flagged';
+      sortBy?: Amity.SearchUserSortBy | Amity.SearchUserSortByEnum;
+      limit?: number;
+      page?: string;
+    };
+
+    type UserLiveCollection = Amity.LiveCollectionParams<Omit<Amity.QueryUsers, 'page'>>;
+
+    type SearchUserLiveCollection = Amity.LiveCollectionParams<
+      Omit<Amity.QuerySearchUsers, 'sortBy'>
+    >;
 
-    type UserSearchLiveCollection = Amity.LiveCollectionParams<Omit<QueryUsers, 'sortBy'>>;
+    type UserSearchLiveCollection = Amity.SearchUserLiveCollection;
 
     type UserLiveCollectionCache = Amity.LiveCollectionCache<
       Amity.InternalUser['userId'],

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,6 +145,10 @@ export class ChannelMemberLiveCollectionController extends LiveCollectionControl
       channelMembers = filterBySearchTerm(channelMembers, this.query.search);
     }
 
+    if (this.query.includeDeleted === false) {
+      channelMembers = channelMembers.filter(member => member.user?.isDeleted !== true);
+    }
+
     // sort, 'lastCreated' is the default sort order
     const sortBy = this.query.sortBy ? this.query.sortBy : 'lastCreated';
     channelMembers = channelMembers.sort(

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

@@ -0,0 +1,148 @@
+/* eslint-disable no-use-before-define */
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { SearchChannelMemberPaginationController } from './SearchChannelMemberPaginationController';
+import { SearchChannelMemberQueryStreamController } from './SearchChannelMemberQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import {
+  onChannelJoined,
+  onChannelLeft,
+  onChannelMemberAdded,
+  onChannelMemberRemoved,
+  onChannelMemberBanned,
+  onChannelMemberUnbanned,
+  onChannelMemberRoleAdded,
+  onChannelMemberRoleRemoved,
+} 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',
+  Amity.SearchChannelMembersLiveCollection,
+  Amity.Membership<'channel'>,
+  SearchChannelMemberPaginationController
+> {
+  private queryStreamController: SearchChannelMemberQueryStreamController;
+
+  private query: Amity.SearchChannelMembersLiveCollection;
+
+  constructor(
+    query: Amity.SearchChannelMembersLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Membership<'channel'>>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['channelUsers', 'collection', queryStreamId];
+    const paginationController = new SearchChannelMemberPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new SearchChannelMemberQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareChannelPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.ChannelMembershipPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'channelUser'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onChannelJoined, action: 'onJoin' },
+      { fn: onChannelLeft, action: 'onLeft' },
+      { fn: onChannelMemberAdded, action: 'onMemberAdded' },
+      { fn: onChannelMemberRemoved, action: 'onMemberRemoved' },
+      { fn: onChannelMemberBanned, action: 'onChannelMemberBanned' },
+      { fn: onChannelMemberUnbanned, action: 'onChannelMemberUnbanned' },
+      { fn: onChannelMemberRoleAdded, action: 'onChannelMemberRoleAdded' },
+      { fn: onChannelMemberRoleRemoved, action: 'onChannelMemberRoleRemoved' },
+      { fn: onUserDeleted(this.query.channelId), action: 'onChannelMemberChanged' },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(id => pullFromCache<Amity.Membership<'channel'>>(['channelUsers', 'get', id])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [],
+    );
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      loading,
+      error,
+    });
+  }
+
+  applyFilter(data: Amity.Membership<'channel'>[]) {
+    let channelMembers = filterByPropIntersection(data, 'roles', this.query.roles);
+
+    if (this.query.memberships) {
+      /*
+       * even though membership includes muted as a possible value
+       * when querying the server.
+       * Muted is specified under seperarte property namely isMuted
+       * Hence why I've seperately checked for it's equality
+       */
+      channelMembers = channelMembers.filter(member => {
+        if (this.query.memberships?.includes('muted') && member.isMuted) {
+          return true;
+        }
+
+        if (member.membership !== 'none') {
+          return this.query.memberships?.includes(member.membership);
+        }
+
+        return false;
+      });
+    }
+
+    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(
+        '`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/SearchChannelMemberPaginationController.ts

@@ -0,0 +1,31 @@
+/* eslint-disable no-use-before-define */
+
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+/**
+ * TODO: handle cache receive cache option, and cache policy
+ * TODO: check if querybyIds is supported
+ */
+export class SearchChannelMemberPaginationController extends PaginationController<
+  'channelUser',
+  Amity.ChannelMembersLiveCollection
+> {
+  async getRequest(queryParams: Amity.ChannelMembersLiveCollection, token: string | undefined) {
+    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/SearchChannelMemberQueryStreamController.ts

@@ -0,0 +1,112 @@
+/* eslint-disable no-use-before-define */
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client';
+
+export class SearchChannelMemberQueryStreamController extends QueryStreamController<
+  Amity.ChannelMembershipPayload,
+  Amity.SearchChannelMembersLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (
+    response: Amity.ChannelMembershipPayload,
+  ) => Promise<Amity.ProcessedChannelPayload>;
+
+  constructor(
+    query: Amity.SearchChannelMembersLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (
+      response: Amity.ChannelMembershipPayload,
+    ) => Promise<Amity.ProcessedChannelPayload>,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.ChannelMembershipPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.ChannelPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.channelUsers.map(({ channelId, userId }) =>
+          getResolver('channelUsers')({ channelId, userId }),
+        ),
+      });
+    } else {
+      const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(
+        this.cacheKey,
+      )?.data;
+
+      const channelUsers = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [
+          ...new Set([
+            ...channelUsers,
+            ...response.channelUsers.map(({ channelId, userId }) =>
+              getResolver('channelUsers')({ channelId, userId }),
+            ),
+          ]),
+        ],
+      });
+    }
+  }
+
+  reactor(action: string) {
+    return (channel: Amity.InternalChannel, channelMember: Amity.Membership<'channel'>) => {
+      if (this.query.channelId !== channelMember.channelId) return;
+
+      const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(
+        this.cacheKey,
+      )?.data;
+      if (!collection) return;
+
+      const channelMemberCacheId = getResolver('channelUsers')({
+        channelId: this.query.channelId,
+        userId: channelMember.userId,
+      });
+
+      if (channelMember.membership === 'none') {
+        collection.data = collection.data.filter(m => m !== channelMemberCacheId);
+      } else if (!collection.data.includes(channelMemberCacheId)) {
+        collection.data = [channelMemberCacheId, ...collection.data];
+      }
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (
+        reactor: (
+          channel: Amity.InternalChannel,
+          channelMember: Amity.Membership<'channel'>,
+        ) => void,
+      ) => Amity.Unsubscriber;
+      action: string;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

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

@@ -0,0 +1 @@
+export * from './searchMembers';

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

@@ -0,0 +1,111 @@
+/* eslint-disable no-use-before-define */
+import { getActiveClient } from '~/client/api';
+import {
+  filterByPropIntersection,
+  filterBySearchTerm,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { dropFromCache } from '~/cache/api';
+import { SearchChannelMemberLiveCollectionController } from './SearchChannelMemberLiveCollectionController';
+
+/*
+ * Exported for testing
+ * @hidden
+ */
+export const applyFilter = <T extends Amity.Membership<'channel'>>(
+  data: T[],
+  params: Amity.ChannelMembersLiveCollection,
+): T[] => {
+  let channelMembers = filterByPropIntersection(data, 'roles', params.roles);
+
+  if (params.memberships) {
+    /*
+     * even though membership includes muted as a possible value
+     * when querying the server.
+     * Muted is specified under seperarte property namely isMuted
+     * Hence why I've seperately checked for it's equality
+     */
+    channelMembers = channelMembers.filter(member => {
+      // @ts-ignore
+      if (params.memberships.includes('muted') && member.isMuted) {
+        return true;
+      }
+
+      // @ts-ignore
+      return params.memberships.includes(member.membership);
+    });
+  }
+
+  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(
+    sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated,
+  );
+
+  return channelMembers;
+};
+
+/* begin_public_function
+  id: channel.member.query
+*/
+/**
+ * ```js
+ * import { searchChannelMembers } from '@amityco/ts-sdk-react-native'
+ *
+ * let channelMembers = []
+ * const unsub = searchChannelMembers({
+ *   channelId: Amity.Channel['channelId'],
+ * }, response => merge(channelMembers, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.ChannelUser}s
+ *
+ * @param params for querying channel users
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the channel users
+ *
+ * @category Channel Live Collection
+ */
+export const searchMembers = (
+  params: Amity.SearchChannelMembersLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Membership<'channel'>>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    // eslint-disable-next-line no-console
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`searchChannelMembers(tmpid: ${timestamp}) > listen`);
+
+  const searchChannelMemberLiveCollection = new SearchChannelMemberLiveCollectionController(
+    params,
+    callback,
+  );
+  const disposers = searchChannelMemberLiveCollection.startSubscription();
+
+  const cacheKey = searchChannelMemberLiveCollection.getCacheKey();
+
+  disposers.push(() => {
+    dropFromCache(cacheKey);
+  });
+
+  return () => {
+    log(`searchChannelMembers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};
+/* end_public_function */

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

@@ -1,5 +1,5 @@
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { withUsers } from '~/group/utils/withUser';
+import { convertRawMembershipToMembership } from '~/group/utils/withUser';
 import { getChannelMarkers } from '~/marker/api/getChannelMarkers';
 
 import { updateChannelMessagePreviewCache } from '~/messagePreview/utils';
@@ -7,8 +7,7 @@ import { getActiveClient } from '~/client/api/activeClient';
 import { pullFromCache } from '~/cache/api/pullFromCache';
 import { getSubChannelsUnreadCount } from './getSubChannelsUnreadCount';
 import { getChannelIsMentioned } from './getChannelIsMentioned';
-import { getUserMessageFeedMakers } from '~/marker/api/getUserMessageFeedMarkers';
-import { persistUnreadCountInfo } from '~/marker/utils/persistUnreadCountInfo';
+import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
 
 export const MARKER_INCLUDED_CHANNEL_TYPE = ['broadcast', 'conversation', 'community'];
 export const isUnreadCountSupport = ({ type }: Pick<Amity.RawChannel, 'type'>) =>
@@ -99,12 +98,17 @@ export const prepareChannelPayload = async (
   );
 
   // user marker to channel users
-  const channelUsers: Amity.Membership<'channel'>[] = withUsers(rawPayload.channelUsers);
+  const channelUsers: Amity.Membership<'channel'>[] = rawPayload.channelUsers.map(channelUser => {
+    return convertRawMembershipToMembership<'channel'>(channelUser);
+  });
+
+  const users = rawPayload.users.map(convertRawUserToInternalUser);
 
   const { messageFeedsInfo, messagePreviews, ...restRawPayload } = rawPayload;
 
   return {
     ...restRawPayload,
+    users,
     channels,
     channelUsers,
   };

package/src/client/api/index.ts

@@ -17,7 +17,4 @@ export * from './markerSync';
 
 export * from './enableUnreadCount';
 
-export * from './registerPushNotification';
-export * from './unregisterPushNotification';
-
 export * from './setUploadedFileAccessType';

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,