@amityco/ts-sdk 7.6.1-316d940a.0 → 7.6.1-63bd9d56.0

package/src/postRepository/events/utils.ts

@@ -1,10 +1,38 @@
 import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { createEventSubscriber, fireEvent } from '~/core/events';
-import { dropFromCache, pullFromCache, queryCache, upsertInCache } from '~/cache/api';
+import { dropFromCache, pullFromCache, pushToCache, queryCache, upsertInCache } from '~/cache/api';
 import { isInTombstone } from '~/cache/api/isInTombstone';
 import { preparePostPayload } from '~/postRepository/utils/payload';
 
+const processDeleteChildPost = (payload: Amity.PostPayload) => {
+  const post = payload.posts[0];
+  if (!post.parentId) return;
+
+  const parentPost = pullFromCache<Amity.InternalPost>(['post', 'get', post.parentPostId])?.data;
+
+  if (!parentPost) return;
+
+  pushToCache(['post', 'get', parentPost.postId], {
+    ...parentPost,
+    children: parentPost.children.filter(childId => childId !== post.postId),
+  });
+};
+
+const processCreateChildPost = (payload: Amity.PostPayload) => {
+  const post = payload.posts[0];
+  if (!post.parentId) return;
+
+  const parentPost = pullFromCache<Amity.InternalPost>(['post', 'get', post.parentPostId])?.data;
+
+  if (!parentPost) return;
+
+  pushToCache(['post', 'get', parentPost.postId], {
+    ...parentPost,
+    children: [...new Set([post.postId, ...parentPost.children])],
+  });
+};
+
 export const createPostEventSubscriber = (
   event: keyof Amity.MqttPostEvents,
   callback: Amity.Listener<Amity.InternalPost>,
@@ -36,6 +64,8 @@ export const createPostEventSubscriber = (
       if (event === 'post.deleted') {
         const { postId, postedUserId } = payload.posts[0];
 
+        processDeleteChildPost(payload);
+
         try {
           isInTombstone('post', postId);
         } catch (e) {
@@ -70,6 +100,8 @@ export const createPostEventSubscriber = (
         queries?.map(({ key, data }) => upsertInCache(key, data as any, { cachedAt: -1 }));
       }
 
+      if (event === 'post.created') processCreateChildPost(payload);
+
       callback(post.data);
     }
   };
@@ -106,6 +138,8 @@ export const createLocalPostEventSubscriber = (
 
       const post = pullFromCache<Amity.InternalPost>(['post', 'get', payload.posts[0].postId])!;
 
+      if (event === 'local.post.deleted') processDeleteChildPost(payload);
+
       callback(post.data);
     }
   };

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/postRepository/observers/getPosts/PostPaginationController.ts

@@ -23,7 +23,7 @@ export class PostPaginationController extends PaginationController<
     const options = token ? { ...baseOptions, token } : { ...baseOptions, limit };
 
     const { data: queryResponse } = await this.http.get<Amity.PostPayload & Amity.Pagination>(
-      `/api/v4/posts`,
+      `/api/v5/posts`,
       {
         params: {
           ...params,

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 commentEventHanlder = (
+  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>) =>
+        commentEventHanlder(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/postRepository/utils/payload.ts

@@ -1,28 +1,8 @@
 import { addPostSetting } from '~/communityRepository/utils';
 import { updateMembershipStatus } from '~/communityRepository/utils/communityWithMembership';
-import { isAmityLivestreamPost } from '~/utils/postTypePredicate';
-
-const updateStreamReferences = (
-  streams: Amity.RawStream[],
-  streamId: string | undefined,
-  postId: string,
-) => {
-  if (!streamId) return streams;
-
-  return streams.map(stream =>
-    stream.streamId === streamId
-      ? {
-          ...stream,
-          referenceType: 'post',
-          referenceId: postId,
-          postId,
-        }
-      : stream,
-  );
-};
 
 export const preparePostPayload = (payload: Amity.PostPayload): Amity.ProcessedPostPayload => {
-  const { posts: postsData, postChildren, videoStreamings, ...postPayload } = payload;
+  const { posts: postsData, ...postPayload } = payload;
 
   // Unpack community payload by mapping payload field to postSetting value.
   const communitiesWithPostSetting = addPostSetting({ communities: postPayload.communities });
@@ -44,34 +24,18 @@ export const preparePostPayload = (payload: Amity.PostPayload): Amity.ProcessedP
     mappedCommunityUsers,
   );
 
-  let mappedNewStream: Amity.RawStream[] = [];
-
   // feed type
   const posts = postsData.map(post => {
     const feedType = postPayload.feeds.find(feed => feed.feedId === post.feedId)?.feedType;
-    const childPosts = payload.postChildren.filter(
-      children => children.parentPostId === post.postId,
-    );
-
-    if (childPosts.length > 0 && isAmityLivestreamPost(childPosts[0])) {
-      mappedNewStream = updateStreamReferences(
-        videoStreamings,
-        childPosts[0].data?.streamId,
-        post.postId,
-      );
-    }
 
     return {
       ...post,
-      childPosts,
       feedType,
     };
   });
 
   return {
     ...postPayload,
-    postChildren,
-    videoStreamings: mappedNewStream,
     posts,
     communities: communityWithMembershipStatus,
     communityUsers: mappedCommunityUsers,

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/streamRepository/api/createStream.ts

@@ -21,10 +21,7 @@ import { LinkedObject } from '~/utils/linkedObject';
  * @async
  */
 export const createStream = async (
-  bundle: Pick<
-    Amity.InternalStream,
-    'title' | 'thumbnailFileId' | 'description' | 'channelEnabled'
-  > & {
+  bundle: Pick<Amity.InternalStream, 'title' | 'thumbnailFileId' | 'description'> & {
     isSecure?: boolean;
   },
 ): Promise<Amity.Cached<Amity.Stream>> => {

package/src/streamRepository/api/index.ts

@@ -2,4 +2,3 @@ export * from './createStream';
 export * from './updateStream';
 export * from './deleteStream';
 export * from './disposeStream';
-export * from './editStream';

package/src/streamRepository/api/updateStream.ts

@@ -7,9 +7,6 @@ import { LinkedObject } from '~/utils/linkedObject';
   id: stream.update
 */
 /**
- * @deprecated this function is deprecated,
- * please use {@link Amity.StreamRepository.editStream} instead.
- *
  * ```js
  * import { updateStream } from '@amityco/ts-sdk'
  * const updated = await updateStream(streamId, { title: 'foobar' })
@@ -24,13 +21,9 @@ import { LinkedObject } from '~/utils/linkedObject';
  * @category Stream API
  * @async
  */
-
 export const updateStream = async (
   streamId: Amity.Stream['streamId'],
-  patch: Patch<
-    Amity.Stream,
-    'title' | 'thumbnailFileId' | 'description' | 'metadata' | 'channelEnabled'
-  >,
+  patch: Patch<Amity.Stream, 'title' | 'thumbnailFileId' | 'description' | 'metadata'>,
 ): Promise<Amity.Cached<Amity.Stream>> => {
   const client = getActiveClient();
   client.log('stream/updateStream', streamId, patch);

package/src/streamRepository/events/index.ts

@@ -3,5 +3,3 @@ export { onStreamStopped } from './onStreamStopped';
 export { onStreamRecorded } from './onStreamRecorded';
 export { onStreamFlagged } from './onStreamFlagged';
 export { onStreamTerminated } from './onStreamTerminated';
-export { onStreamViewerBanned } from './onStreamViewerBanned';
-export { onStreamViewerUnbanned } from './onStreamViewerUnbanned';

package/src/streamRepository/internalApi/getStream.ts

@@ -22,7 +22,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  */
 export const getStream = async (
   streamId: Amity.Stream['streamId'],
-): Promise<Amity.Cached<Amity.InternalStream>> => {
+): Promise<Amity.Cached<Amity.Stream>> => {
   const client = getActiveClient();
   client.log('stream/getStream', streamId);
 
@@ -57,13 +57,13 @@ export const getStream = async (
  */
 getStream.locally = (
   streamId: Amity.Stream['streamId'],
-): Amity.Cached<Amity.InternalStream> | undefined => {
+): Amity.Cached<Amity.Stream> | undefined => {
   const client = getActiveClient();
   client.log('stream/getStream', streamId);
 
   if (!client.cache) return;
 
-  const cached = pullFromCache<Amity.InternalStream>(['stream', 'get', streamId]);
+  const cached = pullFromCache<Amity.Stream>(['stream', 'get', streamId]);
 
   if (!cached) return;
 

package/src/streamRepository/observers/getStreamById.ts

@@ -8,7 +8,6 @@ import { onStreamTerminated } from '~/streamRepository/events/onStreamTerminated
 import { LinkedObject } from '~/utils/linkedObject';
 import { getStream as _getStream } from '../internalApi/getStream';
 import { onStreamRecorded, onStreamStarted, onStreamStopped } from '../events';
-import { onStreamViewerBanned } from '../events/onStreamViewerBanned';
 
 /* begin_public_function
   id: stream.get
@@ -46,7 +45,6 @@ export const getStreamById = (
     onStreamStopped,
     onStreamFlagged,
     onStreamTerminated,
-    onStreamViewerBanned,
   ]);
 };
 /* end_public_function */

package/src/streamRepository/observers/getStreams/GetStreamsLiveCollectionController.ts

@@ -12,8 +12,6 @@ import {
 } from '~/streamRepository/events';
 import { GetStreamsPageController } from '~/streamRepository/observers/getStreams/GetStreamsPageController';
 import { GetStreamsQueryStreamController } from '~/streamRepository/observers/getStreams/GetStreamsQueryStreamController';
-import { onStreamViewerBanned } from '~/streamRepository/events/onStreamViewerBanned';
-import { onStreamViewerUnbanned } from '~/streamRepository/events/onStreamViewerUnbanned';
 
 export class GetStreamsLiveCollectionController extends LiveCollectionController<
   'stream',
@@ -79,8 +77,6 @@ export class GetStreamsLiveCollectionController extends LiveCollectionController
       { fn: onStreamStopped, action: 'onStreamStopped' },
       { fn: onStreamFlagged, action: 'onStreamFlagged' },
       { fn: onStreamTerminated, action: 'onStreamTerminated' },
-      { fn: onStreamViewerBanned, action: 'onStreamViewerBanned' },
-      { fn: onStreamViewerUnbanned, action: 'onStreamViewerUnbanned' },
     ]);
   }
 
@@ -106,7 +102,7 @@ export class GetStreamsLiveCollectionController extends LiveCollectionController
     this.queryStreamController.appendToQueryStream(response, direction, refresh);
   }
 
-  private applyFilter = (data: Amity.Stream[]): Amity.Stream[] => {
+  private applyFilter = (data: Amity.InternalStream[]): Amity.InternalStream[] => {
     let streams = filterByPropEquality(data, 'isDeleted', this.query.isDeleted);
 
     streams = streams.sort(

package/src/utils/linkedObject/channelLinkedObject.ts

@@ -2,7 +2,6 @@ import { markAsRead } from '~/channelRepository/internalApi/markAsRead';
 import { shallowClone } from '../shallowClone';
 import { queryCache } from '~/cache/api';
 import { channelMemberLinkedObject } from './channelMemberLinkedObject';
-import { getMyMembership } from '~/channelRepository/observers/getMyMembership';
 
 export const channelLinkedObject = (channel: Amity.InternalChannel): Amity.Channel => {
   let previewMembers: Amity.Membership<'channel'>[] = [];
@@ -24,7 +23,5 @@ export const channelLinkedObject = (channel: Amity.InternalChannel): Amity.Chann
   return shallowClone(channel, {
     markAsRead: () => markAsRead(channel.channelInternalId),
     previewMembers,
-    myMembership: (callback: Amity.LiveObjectCallback<Amity.Membership<'channel'> | undefined>) =>
-      getMyMembership(channel.channelId, callback),
   });
 };

package/src/utils/linkedObject/postLinkedObject.ts

@@ -3,22 +3,15 @@ import { commentLinkedObject } from '~/utils/linkedObject/commentLinkedObject';
 import AnalyticsEngine from '../../analytic/service/analytic/AnalyticsEngine';
 import { userLinkedObject } from './userLinkedObject';
 import {
+  isAmityClipPost,
   isAmityFilePost,
   isAmityImagePost,
-  isAmityLivestreamPost,
-  isAmityPollPost,
   isAmityVideoPost,
 } from '../postTypePredicate';
-import { streamLinkedObject } from './streamLinkedObject';
-import { isNonNullable } from '..';
+import { shallowClone } from '../shallowClone';
 
 export const postLinkedObject = (post: Amity.InternalPost): Amity.Post => {
-  return {
-    ...post,
-    childrenPosts: post.children
-      .map(childPost => pullFromCache<Amity.InternalPost>(['post', 'get', childPost])?.data)
-      .filter(isNonNullable)
-      .map(postLinkedObject),
+  return shallowClone(post, {
     analytics: {
       markAsViewed: () => {
         const analyticsEngineInstance = AnalyticsEngine.getInstance();
@@ -76,23 +69,10 @@ export const postLinkedObject = (post: Amity.InternalPost): Amity.Post => {
         : undefined;
     },
 
-    getLivestreamInfo(): Amity.Stream | undefined {
-      if (!isAmityLivestreamPost(post)) return;
-      const cache = pullFromCache<Amity.InternalStream>([
-        'stream',
-        'get',
-        post?.data?.streamId,
-      ])?.data;
-      if (!cache) return;
-
-      return streamLinkedObject(cache);
-    },
-
-    getPollInfo(): Amity.Poll | undefined {
-      if (!isAmityPollPost(post)) return;
-      const cache = pullFromCache<Amity.Poll>(['poll', 'get', post?.data?.pollId])?.data;
-      if (!cache) return;
-      return cache;
+    getClipInfo(): Amity.File<'clip'> | undefined {
+      return isAmityClipPost(post)
+        ? pullFromCache<Amity.File<'clip'>>(['file', 'get', post?.data?.fileId])?.data
+        : undefined;
     },
-  };
+  });
 };

package/src/utils/linkedObject/streamLinkedObject.ts

@@ -1,5 +1,4 @@
 import { pullFromCache } from '~/cache/api';
-import { getLiveChat as _getLiveChat } from '~/streamRepository/internalApi/getLiveChat';
 
 export const streamLinkedObject = (stream: Amity.InternalStream): Amity.Stream => {
   return {
@@ -19,8 +18,5 @@ export const streamLinkedObject = (stream: Amity.InternalStream): Amity.Stream =
     get user() {
       return pullFromCache<Amity.User>(['user', 'get', stream.userId])?.data;
     },
-    getLiveChat: () => _getLiveChat(stream),
-    isBanned: !stream.watcherUrl,
-    watcherUrl: null,
   };
 };