@amityco/ts-sdk 7.8.1-1d9a9fe7.0 → 7.8.1-2caef95.0

package/src/postRepository/observers/getGlobalPinnedPosts/GlobalPinnedPostLiveCollectionController.ts

@@ -8,6 +8,7 @@ import { LinkedObject } from '~/utils/linkedObject';
 import { onPostDeleted } from '~/postRepository/events';
 import { EnumPostActions } from '../enums';
 import { onLocalPostDeleted } from '~/postRepository/events/onLocalPostDeleted';
+import { generateCommentSubscriptions } from '../utils';
 
 export class GlobalPinnedPostLiveCollectionController extends LiveCollectionController<
   'pinnedPost',
@@ -71,6 +72,10 @@ export class GlobalPinnedPostLiveCollectionController extends LiveCollectionCont
         fn: onPostDeleted,
         action: EnumPostActions.OnPostDeleted,
       },
+      ...generateCommentSubscriptions({
+        cacheKey: this.cacheKey,
+        resolveId: id => `global#${id}`,
+      }),
     ]);
   }
 

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

@@ -6,6 +6,7 @@ import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionCo
 import { isNonNullable } from '~/utils';
 import { LinkedObject } from '~/utils/linkedObject';
 import { sortByLastCreated } from '~/core/query';
+import { generateCommentSubscriptions } from '../utils';
 
 export class PinnedPostLiveCollectionController extends LiveCollectionController<
   'pinnedPost',
@@ -63,7 +64,12 @@ export class PinnedPostLiveCollectionController extends LiveCollectionController
 
   // eslint-disable-next-line class-methods-use-this
   startSubscription() {
-    return [] as Amity.Unsubscriber[];
+    return this.queryStreamController.subscribeRTE(
+      generateCommentSubscriptions({
+        cacheKey: this.cacheKey,
+        resolveId: id => `${this.query.placement}#${id}`,
+      }),
+    );
   }
 
   notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {

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

@@ -4,6 +4,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 import { getActiveClient } from '~/client';
 import { convertRawUserToInternalUser } from '~/userRepository/utils/convertRawUserToInternalUser';
+import { EnumPostActions } from '../enums';
 
 export class PinnedPostQueryStreamController extends QueryStreamController<
   Amity.PinnedPostPayload,
@@ -64,4 +65,30 @@ export class PinnedPostQueryStreamController extends QueryStreamController<
       });
     }
   }
+
+  reactor(action: EnumPostActions) {
+    return (post: Amity.InternalPost) => {
+      const collection = pullFromCache<Amity.PostLiveCollectionCache>(this.cacheKey)?.data;
+
+      if (!collection) return;
+
+      if (action === EnumPostActions.OnPostDeleted) {
+        collection.data = collection.data.filter(
+          referenceId => referenceId !== `global#${post.postId}`,
+        );
+      }
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: (post: Amity.InternalPost) => void) => Amity.Unsubscriber;
+      action: EnumPostActions;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
 }

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

@@ -3,17 +3,6 @@ import { pullFromCache, pushToCache } from '~/cache/api';
 import { PostPaginationController } from './PostPaginationController';
 import { PostQueryStreamController } from './PostQueryStreamController';
 import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
-import {
-  onPostCreated,
-  onPostUpdated,
-  onPostDeleted,
-  onPostFlagged,
-  onPostUnflagged,
-  onPostReactionAdded,
-  onPostReactionRemoved,
-  onPostApproved,
-  onPostDeclined,
-} from '~/postRepository/events';
 import {
   filterByFeedType,
   filterByPostDataTypes,
@@ -22,16 +11,9 @@ import {
   sortByLastCreated,
 } from '~/core/query';
 import { isNonNullable } from '~/utils';
-import { EnumPostActions } from '../enums';
 import { LinkedObject } from '~/utils/linkedObject';
 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';
+import { getPostSubscription } from '../utils';
 
 export class PostLiveCollectionController extends LiveCollectionController<
   'post',
@@ -85,61 +67,7 @@ export class PostLiveCollectionController extends LiveCollectionController<
   }
 
   startSubscription() {
-    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 },
-      { fn: onPostApproved, action: EnumPostActions.OnPostApproved },
-      { 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>) => {
-            return onCommentCreated(async (comment: Amity.InternalComment) => {
-              const currentCollection = pullFromCache<Amity.PostLiveCollectionCache>(
-                this.cacheKey,
-              )?.data;
-
-              if (!currentCollection || currentCollection.data.includes(comment.referenceId))
-                return;
-
-              await getPost(comment.referenceId);
-              callback(comment);
-            });
-          },
-          'referenceId',
-          'post',
-        ),
-        action: EnumPostActions.OnPostUpdated,
-      },
-      {
-        fn: convertEventPayload(
-          (callback: Amity.Listener<Amity.InternalComment>) => {
-            return onCommentDeleted(async (comment: Amity.InternalComment) => {
-              const currentCollection = pullFromCache<Amity.PostLiveCollectionCache>(
-                this.cacheKey,
-              )?.data;
-
-              if (!currentCollection || currentCollection.data.includes(comment.referenceId))
-                return;
-
-              await getPost(comment.referenceId);
-              callback(comment);
-            });
-          },
-          'referenceId',
-          'post',
-        ),
-        action: EnumPostActions.OnPostUpdated,
-      },
-    ]);
+    return this.queryStreamController.subscribeRTE(getPostSubscription(this.cacheKey));
   }
 
   notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {

package/src/{feedRepository/observers/getUserFeed/LiveCollectionController.ts → postRepository/observers/getPostsByHashtag/SearchPostLiveCollectionController.ts}

@@ -1,7 +1,7 @@
 import hash from 'object-hash';
 import { pullFromCache, pushToCache } from '~/cache/api';
-import { UserFeedPaginationController } from './PaginationController';
-import { UserFeedQueryStreamController } from './QueryStreamController';
+import { SearchPostPaginationController } from './SearchPostPaginationController';
+import { SearchPostQueryStreamController } from './SearchPostQueryStreamController';
 import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
 import {
   onPostCreated,
@@ -14,14 +14,9 @@ import {
   onPostApproved,
   onPostDeclined,
 } from '~/postRepository/events';
-import {
-  filterByPostDataTypes,
-  filterByPropEquality,
-  sortByFirstCreated,
-  sortByLastCreated,
-} from '~/core/query';
+import { filterByPostDataTypes, sortByFirstCreated, sortByLastCreated } from '~/core/query';
 import { isNonNullable } from '~/utils';
-import { EnumPostActions } from '~/postRepository/observers/enums';
+import { EnumPostActions } from '../enums';
 import { LinkedObject } from '~/utils/linkedObject';
 import { preparePostPayload } from '~/postRepository/utils/payload';
 import { convertEventPayload } from '~/utils/event';
@@ -32,28 +27,28 @@ import { onLocalPostReactionAdded } from '~/postRepository/events/onLocalPostRea
 import { onLocalPostReactionRemoved } from '~/postRepository/events/onLocalPostReactionRemoved';
 import { onLocalPostDeleted } from '~/postRepository/events/onLocalPostDeleted';
 
-export class UserFeedLiveCollectionController extends LiveCollectionController<
+export class SearchPostLiveCollectionController extends LiveCollectionController<
   'post',
-  Amity.UserFeedLiveCollection,
+  Amity.SearchPostWithHashtagLiveCollection,
   Amity.Post,
-  UserFeedPaginationController
+  SearchPostPaginationController
 > {
-  private queryStreamController: UserFeedQueryStreamController;
+  private queryStreamController: SearchPostQueryStreamController;
 
-  private query: Amity.UserFeedLiveCollection;
+  private query: Amity.SearchPostWithHashtagLiveCollection;
 
   constructor(
-    query: Amity.UserFeedLiveCollection,
+    query: Amity.SearchPostWithHashtagLiveCollection,
     callback: Amity.LiveCollectionCallback<Amity.Post>,
   ) {
     const queryStreamId = hash(query);
-    const cacheKey = ['userFeed', 'collection', queryStreamId];
-    const paginationController = new UserFeedPaginationController(query);
+    const cacheKey = ['posts', 'collection', queryStreamId];
+    const paginationController = new SearchPostPaginationController(query);
 
     super(paginationController, queryStreamId, cacheKey, callback);
 
     this.query = query;
-    this.queryStreamController = new UserFeedQueryStreamController(
+    this.queryStreamController = new SearchPostQueryStreamController(
       this.query,
       this.cacheKey,
       this.notifyChange.bind(this),
@@ -65,7 +60,7 @@ export class UserFeedLiveCollectionController extends LiveCollectionController<
   }
 
   protected setup() {
-    const collection = pullFromCache<Amity.UserFeedLiveCollectionCache>(this.cacheKey)?.data;
+    const collection = pullFromCache<Amity.PostLiveCollectionCache>(this.cacheKey)?.data;
     if (!collection) {
       pushToCache(this.cacheKey, {
         data: [],
@@ -105,7 +100,7 @@ export class UserFeedLiveCollectionController extends LiveCollectionController<
         fn: convertEventPayload(
           (callback: Amity.Listener<Amity.InternalComment>) => {
             return onCommentCreated(async (comment: Amity.InternalComment) => {
-              const currentCollection = pullFromCache<Amity.UserFeedLiveCollectionCache>(
+              const currentCollection = pullFromCache<Amity.PostLiveCollectionCache>(
                 this.cacheKey,
               )?.data;
 
@@ -125,7 +120,7 @@ export class UserFeedLiveCollectionController extends LiveCollectionController<
         fn: convertEventPayload(
           (callback: Amity.Listener<Amity.InternalComment>) => {
             return onCommentDeleted(async (comment: Amity.InternalComment) => {
-              const currentCollection = pullFromCache<Amity.UserFeedLiveCollectionCache>(
+              const currentCollection = pullFromCache<Amity.PostLiveCollectionCache>(
                 this.cacheKey,
               )?.data;
 
@@ -145,7 +140,7 @@ export class UserFeedLiveCollectionController extends LiveCollectionController<
   }
 
   notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
-    const collection = pullFromCache<Amity.UserFeedLiveCollectionCache>(this.cacheKey)?.data;
+    const collection = pullFromCache<Amity.PostLiveCollectionCache>(this.cacheKey)?.data;
     if (!collection) return;
 
     const data = this.applyFilter(
@@ -169,10 +164,6 @@ export class UserFeedLiveCollectionController extends LiveCollectionController<
   applyFilter(data: Amity.InternalPost[]) {
     let posts = data;
 
-    if (!this.query.includeDeleted) {
-      posts = filterByPropEquality(posts, 'isDeleted', false);
-    }
-
     if (this.query.dataTypes?.length) {
       posts = filterByPostDataTypes(posts, this.query.dataTypes);
     }

package/src/postRepository/observers/getPostsByHashtag/SearchPostPaginationController.ts

@@ -0,0 +1,49 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+export class SearchPostPaginationController extends PaginationController<
+  'post',
+  Amity.SearchPostWithHashtagLiveCollection
+> {
+  async getRequest(
+    queryParams: Amity.SearchPostWithHashtagLiveCollection,
+    token: string | undefined,
+  ) {
+    const {
+      limit = COLLECTION_DEFAULT_PAGINATION_LIMIT,
+      matchingOnlyParentPost,
+      hashtags,
+      dataTypes,
+      targetType = 'all',
+      ...params
+    } = queryParams;
+
+    const baseOptions = {
+      type: params.sortBy || queryParams.limit ? 'pagination' : undefined,
+    };
+
+    const options = token ? { ...baseOptions, token } : { ...baseOptions, limit };
+
+    const { data: queryResponse } = await this.http.get<Amity.PostPayload & Amity.Pagination>(
+      `/api/v1/search/posts`,
+      {
+        params: {
+          ...params,
+          hashtags,
+          dataTypes,
+          targetType,
+          /*
+           * when creating post like image, file, video BE will create 2 posts
+           * 1. parent post to store text with dataType=text
+           * 2. child post to store dataTypes post data
+           *
+           * By default, BE queries only parent post
+           */
+          matchingOnlyParentPost: matchingOnlyParentPost ?? !dataTypes?.length,
+          options,
+        },
+      },
+    );
+    return queryResponse;
+  }
+}

package/src/{feedRepository/observers/getUserFeed/QueryStreamController.ts → postRepository/observers/getPostsByHashtag/SearchPostQueryStreamController.ts}

@@ -1,20 +1,20 @@
-import { getResolver } from '~/core/model';
-import { getActiveClient } from '~/client';
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { EnumPostActions } from '~/postRepository/observers/enums';
-import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client';
+import { EnumPostActions } from '../enums';
 
-export class UserFeedQueryStreamController extends QueryStreamController<
+export class SearchPostQueryStreamController extends QueryStreamController<
   Amity.PostPayload,
-  Amity.UserFeedLiveCollection
+  Amity.SearchPostWithHashtagLiveCollection
 > {
   private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
 
   private preparePayload: (response: Amity.PostPayload) => Amity.ProcessedPostPayload;
 
   constructor(
-    query: Amity.UserFeedLiveCollection,
+    query: Amity.SearchPostWithHashtagLiveCollection,
     cacheKey: string[],
     notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
     preparePayload: (response: Amity.PostPayload) => Amity.ProcessedPostPayload,
@@ -45,7 +45,7 @@ export class UserFeedQueryStreamController extends QueryStreamController<
         data: response.posts.map(getResolver('post')),
       });
     } else {
-      const collection = pullFromCache<Amity.UserFeedLiveCollectionCache>(this.cacheKey)?.data;
+      const collection = pullFromCache<Amity.PostLiveCollectionCache>(this.cacheKey)?.data;
 
       const posts = collection?.data ?? [];
 
@@ -58,22 +58,10 @@ export class UserFeedQueryStreamController extends QueryStreamController<
 
   reactor(action: EnumPostActions) {
     return (post: Amity.InternalPost) => {
-      const collection = pullFromCache<Amity.UserFeedLiveCollectionCache>(this.cacheKey)?.data;
+      const collection = pullFromCache<Amity.PostLiveCollectionCache>(this.cacheKey)?.data;
 
       if (!collection) return;
 
-      // if the collection is parent post collection and
-      // post is not included in the collection or post is child post
-      if (
-        (!this.query.dataTypes || this.query.dataTypes.length === 0) &&
-        !collection.data.includes(post.parentPostId ? post.parentPostId : post.postId)
-      )
-        return;
-
-      if (action === EnumPostActions.OnPostDeleted) {
-        collection.data = collection.data.filter(postId => postId !== post.postId);
-      }
-
       if (post.parentPostId && post.isDeleted) {
         const parentPost = pullFromCache<Amity.InternalPost>([
           'post',
@@ -92,14 +80,6 @@ export class UserFeedQueryStreamController extends QueryStreamController<
       }
 
       if (action === EnumPostActions.OnPostCreated || action === EnumPostActions.OnPostApproved) {
-        if (
-          this.query.dataTypes &&
-          this.query.dataTypes.length > 0 &&
-          !this.query.dataTypes.includes(post.dataType)
-        ) {
-          return;
-        }
-
         collection.data = [...new Set([post.postId, ...collection.data])];
       }
 

package/src/postRepository/observers/index.ts

@@ -3,3 +3,4 @@ export * from './getPosts';
 export * from './getPinnedPosts';
 export * from './getGlobalPinnedPosts';
 export * from './semanticSearchPosts';
+export * from './searchPostsByHashtag';

package/src/postRepository/observers/searchPostsByHashtag.ts

@@ -0,0 +1,56 @@
+import { getActiveClient } from '~/client/api';
+import { dropFromCache } from '~/cache/api';
+
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { SearchPostLiveCollectionController } from './getPostsByHashtag/SearchPostLiveCollectionController';
+
+/* begin_public_function
+  id: post.query
+*/
+/**
+ * ```js
+ * import { PostRepository } from '@amityco/ts-sdk'
+ *
+ * let posts = []
+ * const unsub = PostRepository.searchPostsByHashtag({
+ *   hashtags: ['amity'],
+ *   limit: 10,
+ * }, response => merge(posts, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Post} for a given target object
+ *
+ * @param params.hashtags the hashtags to search for
+ * @param callback the function to call when new data are available
+ * @param config
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the messages
+ *
+ * @category Posts Live Collection
+ */
+export const searchPostsByHashtag = (
+  params: Amity.SearchPostWithHashtagLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Post>,
+  config?: Amity.LiveCollectionConfig,
+): Amity.Unsubscriber => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`searchPostsByHashtag(tmpid: ${timestamp}) > listen`);
+
+  const postsLiveCollection = new SearchPostLiveCollectionController(params, callback);
+  const disposers = postsLiveCollection.startSubscription();
+
+  const cacheKey = postsLiveCollection.getCacheKey();
+
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`searchPostsByHashtag(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};
+/* end_public_function */

package/src/postRepository/observers/utils.ts

@@ -0,0 +1,97 @@
+import { pullFromCache } from '~/cache/api';
+import { onCommentCreated, onCommentDeleted } from '~/commentRepository';
+import { getPost } from '~/postRepository/internalApi';
+import {
+  onPostCreated,
+  onPostUpdated,
+  onPostDeleted,
+  onPostFlagged,
+  onPostUnflagged,
+  onPostReactionAdded,
+  onPostReactionRemoved,
+  onPostApproved,
+  onPostDeclined,
+} from '~/postRepository/events';
+import { onLocalPostDeleted } from '~/postRepository/events/onLocalPostDeleted';
+import { onLocalPostReactionAdded } from '~/postRepository/events/onLocalPostReactionAdded';
+import { onLocalPostReactionRemoved } from '~/postRepository/events/onLocalPostReactionRemoved';
+import { onPostUpdatedLocal } from '~/postRepository/events/onPostUpdatedLocal';
+import { EnumPostActions } from '~/postRepository/observers/enums';
+import { convertEventPayload } from '~/utils/event';
+import { onCommentCreatedLocal } from '~/commentRepository/events/onCommentCreatedLocal';
+import { onCommentDeleteLocal } from '~/commentRepository/events/onCommentDeletedLocal';
+import { onCommentReactionAdded, onCommentReactionRemoved } from '~/commentRepository/events';
+import { onLocalCommentReactionAdded } from '~/commentRepository/events/onLocalCommentReactionAdded';
+import { onLocalCommentReactionRemoved } from '~/commentRepository/events/onLocalCommentReactionRemoved';
+
+type CommentEventHandler = (callback: Amity.Listener<Amity.InternalComment>) => Amity.Unsubscriber;
+
+const commentEventHandler = (
+  callback: Amity.Listener<Amity.InternalComment>,
+  eventHandler: CommentEventHandler,
+  cacheKey: Amity.CacheKey,
+  resolveId?: (id: string) => string,
+) => {
+  return eventHandler(async (comment: Amity.InternalComment) => {
+    const currentCollection = pullFromCache<Amity.PinnedPostLiveCollectionCache>(cacheKey)?.data;
+
+    if (
+      !currentCollection ||
+      !currentCollection.data.includes(
+        resolveId ? resolveId(comment.referenceId) : comment.referenceId,
+      )
+    )
+      return;
+
+    await getPost(comment.referenceId);
+    callback(comment);
+  });
+};
+
+export const generateCommentSubscriptions = ({
+  cacheKey,
+  resolveId,
+}: {
+  cacheKey: Amity.CacheKey;
+  resolveId?: (id: string) => string;
+}) => {
+  const eventHandlers = [
+    onCommentCreated,
+    onCommentDeleted,
+    onCommentReactionAdded,
+    onCommentReactionRemoved,
+    onCommentCreatedLocal,
+    onCommentDeleteLocal,
+    onLocalCommentReactionAdded,
+    onLocalCommentReactionRemoved,
+  ];
+
+  return eventHandlers.map(handler => ({
+    fn: convertEventPayload(
+      (callback: Amity.Listener<Amity.InternalComment>) =>
+        commentEventHandler(callback, handler, cacheKey, resolveId),
+      'referenceId',
+      'post',
+    ),
+    action: EnumPostActions.OnPostUpdated,
+  }));
+};
+
+export const getPostSubscription = (cacheKey: Amity.CacheKey) => {
+  return [
+    { 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 },
+    { fn: onPostApproved, action: EnumPostActions.OnPostApproved },
+    { 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 },
+    ...generateCommentSubscriptions({ cacheKey }),
+  ];
+};

package/src/reactionRepository/api/addReaction.ts

@@ -69,6 +69,7 @@ export const addReaction = async (
         ...model.data.reactions,
         [reactionName]: (model.data.reactions[reactionName] ?? 0) + 1,
       },
+      updatedAt: new Date().toISOString(),
     } as Amity.Models[Amity.ReactableType];
 
     if (referenceType === 'comment') {

package/src/reactionRepository/api/removeReaction.ts

@@ -72,6 +72,7 @@ export const removeReaction = async (
         ...model.data.reactions,
         [reactionName]: Math.max(0, (model.data.reactions[reactionName] ?? 0) - 1),
       },
+      updatedAt: new Date().toISOString(),
     } as Amity.Models[Amity.ReactableType];
 
     if (referenceType === 'comment') {

package/src/utils/linkedObject/postLinkedObject.ts

@@ -10,12 +10,12 @@ import {
   isAmityVideoPost,
   isAmityClipPost,
 } from '../postTypePredicate';
+import { shallowClone } from '../shallowClone';
 import { streamLinkedObject } from './streamLinkedObject';
 import { isNonNullable } from '..';
 
 export const postLinkedObject = (post: Amity.InternalPost): Amity.Post => {
-  return {
-    ...post,
+  return shallowClone(post, {
     childrenPosts: post.children
       .map(childPost => pullFromCache<Amity.InternalPost>(['post', 'get', childPost])?.data)
       .filter(isNonNullable)
@@ -101,5 +101,5 @@ export const postLinkedObject = (post: Amity.InternalPost): Amity.Post => {
         ? pullFromCache<Amity.File<'clip'>>(['file', 'get', post?.data?.fileId])?.data
         : undefined;
     },
-  };
+  });
 };