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

package/src/postRepository/events/utils.ts

@@ -1,10 +1,9 @@
 import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { createEventSubscriber, fireEvent } from '~/core/events';
-import { pullFromCache, queryCache, upsertInCache } from '~/cache/api';
-import { pushToTombstone } from '~/cache/api/pushToTombstone';
-import { prepareMembershipPayload } from '~/group/utils';
+import { dropFromCache, pullFromCache, queryCache, upsertInCache } from '~/cache/api';
 import { isInTombstone } from '~/cache/api/isInTombstone';
+import { preparePostPayload } from '~/postRepository/utils/payload';
 
 export const createPostEventSubscriber = (
   event: keyof Amity.MqttPostEvents,
@@ -16,9 +15,9 @@ export const createPostEventSubscriber = (
     if (!client.cache) {
       callback(payload.posts[0]);
     } else {
-      const { communities, ...others } = payload;
+      const data = preparePostPayload(payload);
 
-      const data = prepareMembershipPayload(others, 'communityUsers');
+      const { communities } = data;
 
       ingestInCache(data);
 
@@ -49,7 +48,7 @@ export const createPostEventSubscriber = (
         // But if it is hard delete, it will pushed into tombstone before fire an event to BE. it means it will stay in tombstone already
         // and will got skip to notify in a previous code block
         if (postedUserId !== client.userId) {
-          pushToTombstone('post', postId);
+          dropFromCache(['post', 'get', postId]);
         }
 
         return callback(payload.posts[0]);
@@ -76,3 +75,39 @@ export const createPostEventSubscriber = (
 
   return createEventSubscriber(client, event, event, filter);
 };
+
+export const createLocalPostEventSubscriber = (
+  event: keyof Omit<Amity.LocalPostEvents, 'local.post.addReaction' | 'local.post.removeReaction'>,
+  callback: Amity.Listener<Amity.InternalPost>,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.PostPayload) => {
+    if (!client.cache) {
+      callback(payload.posts[0]);
+    } else {
+      const data = preparePostPayload(payload);
+
+      const { communities } = data;
+
+      ingestInCache(data);
+
+      if (communities?.[0] && !['local.post.updated'].includes(event)) {
+        fireEvent('community.updated', {
+          communities,
+          categories: [],
+          communityUsers: data.communityUsers,
+          feeds: [],
+          files: [],
+          users: [],
+        });
+      }
+
+      const post = pullFromCache<Amity.InternalPost>(['post', 'get', payload.posts[0].postId])!;
+
+      callback(post.data);
+    }
+  };
+
+  return createEventSubscriber(client, event, event, filter);
+};

package/src/postRepository/internalApi/index.ts

@@ -1,16 +1 @@
-export * from './getPostByIds';
-
-export * from './createPost';
-export * from './updatePost';
-export * from './editPost';
-
-export * from './deletePost';
-export * from './softDeletePost';
-export * from './hardDeletePost';
-
-export * from './approvePost';
-export * from './declinePost';
-
-export * from './flagPost';
-export * from './unflagPost';
-export * from './isPostFlaggedByMe';
+export * from './getPost';

package/src/postRepository/observers/getPinnedPosts/PinnedPostLiveCollectionController.ts

@@ -0,0 +1,104 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { PinnedPostPaginationController } from './PinnedPostPaginationController';
+import { PinnedPostQueryStreamController } from './PinnedPostQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { isNonNullable } from '~/utils';
+import { LinkedObject } from '~/utils/linkedObject';
+import { sortByLastCreated } from '~/core/query';
+
+export class PinnedPostLiveCollectionController extends LiveCollectionController<
+  'pinnedPost',
+  Amity.PinnedPostLiveCollection,
+  Amity.PinnedPost,
+  PinnedPostPaginationController
+> {
+  private queryStreamController: PinnedPostQueryStreamController;
+
+  private query: Amity.PinnedPostLiveCollection;
+
+  constructor(
+    query: Amity.PinnedPostLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.PinnedPost>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['pinnedPosts', 'collection', queryStreamId];
+    const paginationController = new PinnedPostPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new PinnedPostQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      response => response,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.PostLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.PinnedPostPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'pinnedPost'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  startSubscription() {
+    return [] as Amity.Unsubscriber[];
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.PinnedPostLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    let data = (
+      collection.data
+        .map(id => pullFromCache<Amity.InternalPin>(['pin', 'get', id])!)
+        .filter(isNonNullable)
+        .map(({ data }) => data) ?? []
+    ).map(LinkedObject.pinnedPost);
+
+    data = this.applyFilter(data);
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      data,
+      loading,
+      error,
+    });
+  }
+
+  private applyFilter(data: Amity.PinnedPost[]) {
+    let pinnedPost = data;
+    switch (this.query.sortBy) {
+      case 'lastCreated':
+        pinnedPost = pinnedPost.sort(({ post: postA }, { post: postB }) =>
+          sortByLastCreated({ createdAt: postA?.createdAt! }, { createdAt: postB?.createdAt! }),
+        );
+        break;
+      default:
+        break;
+    }
+    return pinnedPost;
+  }
+}

package/src/postRepository/observers/getPinnedPosts/PinnedPostPaginationController.ts

@@ -0,0 +1,23 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+export class PinnedPostPaginationController extends PaginationController<
+  'pinnedPost',
+  Amity.PinnedPostLiveCollection
+> {
+  async getRequest(queryParams: Amity.PinnedPostLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, ...params } = queryParams;
+
+    const { communityId, placement } = params;
+
+    const path = placement
+      ? `/api/v1/pinned-posts/communities/${communityId}/${placement}`
+      : `/api/v1/pinned-posts/communities/${communityId}`;
+
+    const { data: queryResponse } = await this.http.get<Amity.PinnedPostPayload & Amity.Pagination>(
+      path,
+    );
+
+    return queryResponse;
+  }
+}

package/src/postRepository/observers/getPinnedPosts/PinnedPostQueryStreamController.ts

@@ -0,0 +1,61 @@
+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 PinnedPostQueryStreamController extends QueryStreamController<
+  Amity.PinnedPostPayload,
+  Amity.PinnedPostLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.PinnedPostPayload) => Amity.ProcessedPostPayload;
+
+  constructor(
+    query: Amity.PinnedPostLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (response: Amity.PinnedPostPayload) => Amity.ProcessedPostPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async saveToMainDB(response: Amity.PinnedPostPayload) {
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(response, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.PinnedPostPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.pins.map(getResolver('pin')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.PinnedPostLiveCollectionCache>(this.cacheKey)?.data;
+
+      const pinnedPosts = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [...new Set([...pinnedPosts, ...response.pins.map(getResolver('pin'))])],
+      });
+
+      this.notifyChange({
+        origin: Amity.LiveDataOrigin.SERVER,
+        loading: false,
+      });
+    }
+  }
+}

package/src/postRepository/observers/getPinnedPosts.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api';
+import { dropFromCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { PinnedPostLiveCollectionController } from './getPinnedPosts/PinnedPostLiveCollectionController';
+
+/**
+ * Get pinned posts for a community
+ *
+ * @param communityId the ID of the community
+ * @param placement the placement of the pinned post ('announcement' or 'default'), or null to fetch all pinned posts
+ * @returns the associated pinned post(s)
+ *
+ * @category Pined Posts Live Collection
+ *
+ */
+export const getPinnedPosts = (
+  params: Amity.LiveCollectionParams<Amity.PinnedPostLiveCollection>,
+  callback: Amity.LiveCollectionCallback<Amity.PinnedPost>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getPinnedPosts(tmpid: ${timestamp}) > listen`);
+
+  const pinnedPostLiveCollection = new PinnedPostLiveCollectionController(params, callback);
+  const disposers = pinnedPostLiveCollection.startSubscription();
+
+  const cacheKey = pinnedPostLiveCollection.getCacheKey();
+
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`getPinnedPosts(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/postRepository/observers/getPost.ts

@@ -15,6 +15,10 @@ import { pullFromCache, pushToCache } from '~/cache/api';
 import { LinkedObject } from '~/utils/linkedObject';
 import { onCommentCreated, onCommentDeleted } from '~/commentRepository';
 import { convertEventPayload } from '~/utils/event';
+import { onPostUpdatedLocal } from '~/postRepository/events/onPostUpdatedLocal';
+import { onLocalPostReactionAdded } from '~/postRepository/events/onLocalPostReactionAdded';
+import { onLocalPostReactionRemoved } from '~/postRepository/events/onLocalPostReactionRemoved';
+import { onLocalPostDeleted } from '~/postRepository/events/onLocalPostDeleted';
 
 /* begin_public_function
   id: post.get
@@ -52,6 +56,8 @@ export const getPost = (
   return liveObject(postId, responder, 'postId', _getPost, [
     onPostApproved,
     onPostDeclined,
+    onLocalPostReactionAdded,
+    onLocalPostReactionRemoved,
     (callback: Amity.Listener<Amity.InternalPost>) => {
       return onPostDeleted((post: Amity.InternalPost) => {
         let targetPost = post;
@@ -89,6 +95,8 @@ export const getPost = (
     },
     onPostUnflagged,
     onPostUpdated,
+    onPostUpdatedLocal,
+    onLocalPostDeleted,
     convertEventPayload(
       (callback: Amity.Listener<Amity.InternalComment>) => {
         return onCommentCreated(async (comment: Amity.InternalComment) => {

package/src/postRepository/observers/getPosts/PostLiveCollectionController.ts

@@ -28,6 +28,10 @@ import { preparePostPayload } from '~/postRepository/utils/payload';
 import { convertEventPayload } from '~/utils/event';
 import { onCommentCreated, onCommentDeleted } from '~/commentRepository';
 import { getPost } from '~/postRepository/internalApi/getPost';
+import { onPostUpdatedLocal } from '~/postRepository/events/onPostUpdatedLocal';
+import { onLocalPostReactionAdded } from '~/postRepository/events/onLocalPostReactionAdded';
+import { onLocalPostReactionRemoved } from '~/postRepository/events/onLocalPostReactionRemoved';
+import { onLocalPostDeleted } from '~/postRepository/events/onLocalPostDeleted';
 
 export class PostLiveCollectionController extends LiveCollectionController<
   'post',
@@ -84,6 +88,7 @@ export class PostLiveCollectionController extends LiveCollectionController<
     return this.queryStreamController.subscribeRTE([
       { fn: onPostCreated, action: EnumPostActions.OnPostCreated },
       { fn: onPostUpdated, action: EnumPostActions.OnPostUpdated },
+      { fn: onPostUpdatedLocal, action: EnumPostActions.OnPostUpdated },
       { fn: onPostDeleted, action: EnumPostActions.OnPostDeleted },
       { fn: onPostFlagged, action: EnumPostActions.OnPostFlagged },
       { fn: onPostUnflagged, action: EnumPostActions.OnPostUnflagged },
@@ -91,6 +96,9 @@ export class PostLiveCollectionController extends LiveCollectionController<
       { fn: onPostDeclined, action: EnumPostActions.OnPostDeclined },
       { fn: onPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
       { fn: onPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
+      { fn: onLocalPostReactionAdded, action: EnumPostActions.OnPostReactionAdded },
+      { fn: onLocalPostReactionRemoved, action: EnumPostActions.OnPostReactionRemoved },
+      { fn: onLocalPostDeleted, action: EnumPostActions.OnPostDeleted },
       {
         fn: convertEventPayload(
           (callback: Amity.Listener<Amity.InternalComment>) => {

package/src/postRepository/observers/index.ts

@@ -2,3 +2,4 @@ export * from './observePosts';
 export * from './observePost';
 export * from './getPost';
 export * from './getPosts';
+export * from './getPinnedPosts';

package/src/postRepository/utils/payload.ts

@@ -1,17 +1,41 @@
-import { convertCommunityPayload } from '~/communityRepository/utils';
+import { addPostSetting } from '~/communityRepository/utils';
+import { updateMembershipStatus } from '~/communityRepository/utils/communityWithMembership';
 
 export const preparePostPayload = (postPayload: Amity.PostPayload): Amity.ProcessedPostPayload => {
-  const { posts } = postPayload;
+  // Unpack community payload by mapping payload field to postSetting value.
+  const communitiesWithPostSetting = addPostSetting({ communities: postPayload.communities });
 
-  const { communities, communityUsers } = convertCommunityPayload({
-    communities: postPayload.communities,
-    communityUsers: postPayload.communityUsers,
+  // map users with community
+  const mappedCommunityUsers: Array<Amity.Membership<'community'>> = postPayload.communityUsers.map(
+    communityUser => {
+      const user = postPayload.users.find(user => user.userId === communityUser.userId)!;
+
+      return {
+        ...communityUser,
+        user,
+      };
+    },
+  );
+
+  const communityWithMembershipStatus = updateMembershipStatus(
+    communitiesWithPostSetting,
+    mappedCommunityUsers,
+  );
+
+  // feed type
+  const posts = postPayload.posts.map(post => {
+    const feedType = postPayload.feeds.find(feed => feed.feedId === post.feedId)?.feedType;
+
+    return {
+      ...post,
+      feedType,
+    };
   });
 
   return {
     ...postPayload,
     posts,
-    communities,
-    communityUsers,
+    communities: communityWithMembershipStatus,
+    communityUsers: mappedCommunityUsers,
   };
 };

package/src/reactionRepository/api/addReaction.ts

@@ -4,6 +4,7 @@ import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
 
 import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
 import { dispatchReactable } from '../utils';
+import { fireEvent } from '~/core/events';
 
 /* begin_public_function
   id: reaction.add
@@ -50,8 +51,32 @@ export const addReaction = async (
       referenceId,
     ]);
 
-    model?.data &&
-      pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+    if (!model) return true;
+
+    const updatedModel = {
+      ...model.data,
+      reactionsCount: model.data.reactionsCount + 1,
+      myReactions: [...(model.data.myReactions ?? []), reactionName],
+      reactions: {
+        ...model.data.reactions,
+        [reactionName]: (model.data.reactions[reactionName] ?? 0) + 1,
+      },
+    } as Amity.Models[Amity.ReactableType];
+
+    if (referenceType === 'comment') {
+      fireEvent('local.comment.addReaction', {
+        comment: updatedModel as Amity.InternalComment,
+      });
+
+      return true;
+    }
+    if (referenceType === 'post') {
+      fireEvent('local.post.addReaction', {
+        post: updatedModel as Amity.InternalPost,
+      });
+
+      return true;
+    }
   }
 
   return true;

package/src/reactionRepository/api/removeReaction.ts

@@ -5,6 +5,7 @@ import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
 import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
 
 import { dispatchReactable } from '../utils';
+import { fireEvent } from '~/core/events';
 
 /* begin_public_function
   id: reaction.remove
@@ -53,8 +54,32 @@ export const removeReaction = async (
       referenceId,
     ]);
 
-    model?.data &&
-      pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+    if (!model) return true;
+
+    const updatedModel = {
+      ...model.data,
+      reactionsCount: Math.max(0, model.data.reactionsCount - 1),
+      myReactions: (model.data.myReactions ?? []).filter(item => item !== reactionName),
+      reactions: {
+        ...model.data.reactions,
+        [reactionName]: Math.max(0, (model.data.reactions[reactionName] ?? 0) - 1),
+      },
+    } as Amity.Models[Amity.ReactableType];
+
+    if (referenceType === 'comment') {
+      fireEvent('local.comment.removeReaction', {
+        comment: updatedModel as Amity.InternalComment,
+      });
+
+      return true;
+    }
+    if (referenceType === 'post') {
+      fireEvent('local.post.removeReaction', {
+        post: updatedModel as Amity.InternalPost,
+      });
+
+      return true;
+    }
   }
 
   return true;

package/src/report/api/createReport.ts

@@ -2,10 +2,94 @@ import { getActiveClient } from '~/client/api/activeClient';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
-import { prepareMembershipPayload } from '~/group/utils';
-
 import { prepareMessagePayload } from '~/messageRepository/utils';
-import REFERENCE_TYPES from '../constants/referenceTypes';
+import { preparePostPayload } from '~/postRepository/utils/payload';
+import { prepareUserPayload } from '~/userRepository/utils/prepareUserPayload';
+import { prepareCommentPayload } from '~/commentRepository/utils/payload';
+
+const createMessageReport = async ({
+  client,
+  referenceId,
+}: {
+  client: Amity.Client;
+  referenceId: string;
+}) => {
+  const { data: payload } = await client.http.post<Amity.MessagePayload>(
+    `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`,
+  );
+
+  if (client.cache) {
+    const messagePayload = await prepareMessagePayload(payload as Amity.MessagePayload);
+    ingestInCache(messagePayload);
+  }
+
+  fireEvent(`message.flagged`, payload);
+
+  return !!payload;
+};
+
+const createPostReport = async ({
+  client,
+  referenceId,
+}: {
+  client: Amity.Client;
+  referenceId: string;
+}) => {
+  const { data: payload } = await client.http.post<Amity.PostPayload>(
+    `/api/v3/post/${encodeURIComponent(referenceId)}/flag`,
+  );
+
+  if (client.cache) {
+    const postPayload = await preparePostPayload(payload);
+    ingestInCache(postPayload);
+  }
+
+  fireEvent(`post.flagged`, payload);
+
+  return !!payload;
+};
+
+const createUserReport = async ({
+  client,
+  referenceId,
+}: {
+  client: Amity.Client;
+  referenceId: string;
+}) => {
+  const { data: payload } = await client.http.post<Amity.UserPayload>(
+    `/api/v4/me/flags/${encodeURIComponent(referenceId)}`,
+  );
+
+  if (client.cache) {
+    const userPayload = await prepareUserPayload(payload);
+    ingestInCache(userPayload);
+  }
+
+  fireEvent(`user.flagged`, payload);
+
+  return !!payload;
+};
+
+const createCommentReport = async ({
+  client,
+  referenceId,
+}: {
+  client: Amity.Client;
+  referenceId: string;
+}) => {
+  const { data: payload } = await client.http.post<Amity.CommentPayload>(
+    `/api/v3/comment/${encodeURIComponent(referenceId)}/flag`,
+  );
+
+  if (client.cache) {
+    const commentPayload = await prepareCommentPayload(payload);
+    ingestInCache(commentPayload);
+  }
+
+  fireEvent(`comment.flagged`, payload);
+
+  return !!payload;
+};
 
 /**
  * ```js
@@ -21,42 +105,27 @@ import REFERENCE_TYPES from '../constants/referenceTypes';
  * @async
  * */
 export const createReport = async (
-  referenceType: keyof typeof REFERENCE_TYPES,
+  referenceType: 'post' | 'comment' | 'message' | 'user',
   referenceId: string,
 ): Promise<boolean> => {
   const client = getActiveClient();
   client.log('report/createReport', { referenceType, referenceId });
 
-  const getAPIUrl = (): string => {
-    if (referenceType === 'user') {
-      return `/api/v4/me/flags/${encodeURIComponent(referenceId)}`;
-    }
-
-    if (referenceType === 'message') {
-      return `/api/v5/messages/${encodeURIComponent(referenceId)}/flags`;
-    }
-
-    const { domainName } = REFERENCE_TYPES[referenceType];
-
-    return `/api/v3/${domainName}/${encodeURIComponent(referenceId)}/flag`;
-  };
+  if (referenceType === 'user') {
+    return createUserReport({ client, referenceId });
+  }
 
-  const { data: payload } = await client.http.post<
-    Amity.PostPayload | Amity.CommentPayload | Amity.MessagePayload | Amity.UserPayload
-  >(getAPIUrl());
+  if (referenceType === 'message') {
+    return createMessageReport({ client, referenceId });
+  }
 
-  if (client.cache) {
-    if (referenceType === 'message') {
-      const messagePayload = await prepareMessagePayload(payload as Amity.MessagePayload);
-      ingestInCache(messagePayload);
-    } else if (referenceType === 'post') {
-      ingestInCache(prepareMembershipPayload(payload as Amity.PostPayload, 'communityUsers'));
-    } else {
-      ingestInCache(payload as Amity.CommentPayload | Amity.UserPayload);
-    }
+  if (referenceType === 'post') {
+    return createPostReport({ client, referenceId });
   }
 
-  fireEvent(`${referenceType}.flagged`, payload);
+  if (referenceType === 'comment') {
+    return createCommentReport({ client, referenceId });
+  }
 
-  return !!payload;
+  return false;
 };