@amityco/ts-sdk-react-native 6.28.2-fbfd068.0 → 6.28.3-54dff84.0

package/dist/postRepository/internalApi/getPost.d.ts

@@ -0,0 +1,5 @@
+export declare const getPost: {
+    (postId: Amity.InternalPost['postId']): Promise<Amity.Cached<Amity.InternalPost>>;
+    locally(postId: Amity.InternalPost['postId']): Amity.Cached<Amity.InternalPost> | undefined;
+};
+//# sourceMappingURL=getPost.d.ts.map

package/dist/postRepository/internalApi/getPost.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getPost.d.ts","sourceRoot":"","sources":["../../../src/postRepository/internalApi/getPost.ts"],"names":[],"mappings":"AASA,eAAO,MAAM,OAAO;aACV,MAAM,YAAY,CAAC,QAAQ,CAAC,GACnC,QAAQ,MAAM,MAAM,CAAC,MAAM,YAAY,CAAC,CAAC;oBAsClC,MAAM,YAAY,CAAC,QAAQ,CAAC,GACnC,MAAM,MAAM,CAAC,MAAM,YAAY,CAAC,GAAG,SAAS;CAJ9C,CAAC"}

package/dist/postRepository/internalApi/index.d.ts

@@ -0,0 +1,13 @@
+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';
+//# sourceMappingURL=index.d.ts.map

package/dist/postRepository/internalApi/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/postRepository/internalApi/index.ts"],"names":[],"mappings":"AAAA,cAAc,gBAAgB,CAAC;AAE/B,cAAc,cAAc,CAAC;AAC7B,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAE3B,cAAc,cAAc,CAAC;AAC7B,cAAc,kBAAkB,CAAC;AACjC,cAAc,kBAAkB,CAAC;AAEjC,cAAc,eAAe,CAAC;AAC9B,cAAc,eAAe,CAAC;AAE9B,cAAc,YAAY,CAAC;AAC3B,cAAc,cAAc,CAAC;AAC7B,cAAc,qBAAqB,CAAC"}

package/dist/postRepository/observers/getPosts/PostLiveCollectionController.d.ts

@@ -0,0 +1,14 @@
+import { PostPaginationController } from './PostPaginationController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+export declare class PostLiveCollectionController extends LiveCollectionController<'post', Amity.PostLiveCollection, Amity.Post, PostPaginationController> {
+    private queryStreamController;
+    private query;
+    constructor(query: Amity.PostLiveCollection, callback: Amity.LiveCollectionCallback<Amity.Post>);
+    protected setup(): void;
+    protected persistModel(queryPayload: Amity.PostPayload & Amity.Pagination): Promise<void>;
+    protected persistQueryStream({ response, direction, refresh, }: Amity.LiveCollectionPersistQueryStreamParams<'post'>): void;
+    startSubscription(): Amity.Unsubscriber[];
+    notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams): void;
+    applyFilter(data: Amity.InternalPost[]): Amity.InternalPost<any>[];
+}
+//# sourceMappingURL=PostLiveCollectionController.d.ts.map

package/dist/postRepository/observers/getPosts/PostLiveCollectionController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostLiveCollectionController.d.ts","sourceRoot":"","sources":["../../../../src/postRepository/observers/getPosts/PostLiveCollectionController.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,wBAAwB,EAAE,MAAM,4BAA4B,CAAC;AAEtE,OAAO,EAAE,wBAAwB,EAAE,MAAM,gDAAgD,CAAC;AA2B1F,qBAAa,4BAA6B,SAAQ,wBAAwB,CACxE,MAAM,EACN,KAAK,CAAC,kBAAkB,EACxB,KAAK,CAAC,IAAI,EACV,wBAAwB,CACzB;IACC,OAAO,CAAC,qBAAqB,CAA4B;IAEzD,OAAO,CAAC,KAAK,CAA2B;gBAE5B,KAAK,EAAE,KAAK,CAAC,kBAAkB,EAAE,QAAQ,EAAE,KAAK,CAAC,sBAAsB,CAAC,KAAK,CAAC,IAAI,CAAC;IAmB/F,SAAS,CAAC,KAAK;cAUC,YAAY,CAAC,YAAY,EAAE,KAAK,CAAC,WAAW,GAAG,KAAK,CAAC,UAAU;IAI/E,SAAS,CAAC,kBAAkB,CAAC,EAC3B,QAAQ,EACR,SAAS,EACT,OAAO,GACR,EAAE,KAAK,CAAC,sCAAsC,CAAC,MAAM,CAAC;IAIvD,iBAAiB;IAsDjB,YAAY,CAAC,EAAE,MAAM,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,KAAK,CAAC,0BAA0B;IAsBzE,WAAW,CAAC,IAAI,EAAE,KAAK,CAAC,YAAY,EAAE;CA+BvC"}

package/dist/postRepository/observers/getPosts/PostPaginationController.d.ts

@@ -0,0 +1,5 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+export declare class PostPaginationController extends PaginationController<'post', Amity.PostLiveCollection> {
+    getRequest(queryParams: Amity.PostLiveCollection, token: string | undefined): Promise<Amity.PostPayload<any> & Amity.Pagination>;
+}
+//# sourceMappingURL=PostPaginationController.d.ts.map

package/dist/postRepository/observers/getPosts/PostPaginationController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostPaginationController.d.ts","sourceRoot":"","sources":["../../../../src/postRepository/observers/getPosts/PostPaginationController.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,4CAA4C,CAAC;AAIlF,qBAAa,wBAAyB,SAAQ,oBAAoB,CAChE,MAAM,EACN,KAAK,CAAC,kBAAkB,CACzB;IACO,UAAU,CAAC,WAAW,EAAE,KAAK,CAAC,kBAAkB,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS;CAoClF"}

package/dist/postRepository/observers/getPosts/PostQueryStreamController.d.ts

@@ -0,0 +1,15 @@
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { EnumPostActions } from './enums';
+export declare class PostQueryStreamController extends QueryStreamController<Amity.PostPayload, Amity.PostLiveCollection> {
+    private notifyChange;
+    private preparePayload;
+    constructor(query: Amity.PostLiveCollection, cacheKey: string[], notifyChange: (params: Amity.LiveCollectionNotifyParams) => void, preparePayload: (response: Amity.PostPayload) => Amity.ProcessedPostPayload);
+    saveToMainDB(response: Amity.PostPayload): Promise<void>;
+    appendToQueryStream(response: Amity.PostPayload & Partial<Amity.Pagination>, direction: Amity.LiveCollectionPageDirection, refresh?: boolean): void;
+    reactor(action: EnumPostActions): (post: Amity.InternalPost) => void;
+    subscribeRTE(createSubscriber: {
+        fn: (reactor: (post: Amity.InternalPost) => void) => Amity.Unsubscriber;
+        action: EnumPostActions;
+    }[]): Amity.Unsubscriber[];
+}
+//# sourceMappingURL=PostQueryStreamController.d.ts.map

package/dist/postRepository/observers/getPosts/PostQueryStreamController.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PostQueryStreamController.d.ts","sourceRoot":"","sources":["../../../../src/postRepository/observers/getPosts/PostQueryStreamController.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,6CAA6C,CAAC;AAKpF,OAAO,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAE1C,qBAAa,yBAA0B,SAAQ,qBAAqB,CAClE,KAAK,CAAC,WAAW,EACjB,KAAK,CAAC,kBAAkB,CACzB;IACC,OAAO,CAAC,YAAY,CAAqD;IAEzE,OAAO,CAAC,cAAc,CAA8D;gBAGlF,KAAK,EAAE,KAAK,CAAC,kBAAkB,EAC/B,QAAQ,EAAE,MAAM,EAAE,EAClB,YAAY,EAAE,CAAC,MAAM,EAAE,KAAK,CAAC,0BAA0B,KAAK,IAAI,EAChE,cAAc,EAAE,CAAC,QAAQ,EAAE,KAAK,CAAC,WAAW,KAAK,KAAK,CAAC,oBAAoB;IAOvE,YAAY,CAAC,QAAQ,EAAE,KAAK,CAAC,WAAW;IAW9C,mBAAmB,CACjB,QAAQ,EAAE,KAAK,CAAC,WAAW,GAAG,OAAO,CAAC,KAAK,CAAC,UAAU,CAAC,EACvD,SAAS,EAAE,KAAK,CAAC,2BAA2B,EAC5C,OAAO,UAAQ;IAkBjB,OAAO,CAAC,MAAM,EAAE,eAAe,UACf,MAAM,YAAY;IAkClC,YAAY,CACV,gBAAgB,EAAE;QAChB,EAAE,EAAE,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC,YAAY,KAAK,IAAI,KAAK,KAAK,CAAC,YAAY,CAAC;QACxE,MAAM,EAAE,eAAe,CAAC;KACzB,EAAE;CAIN"}

package/dist/postRepository/observers/getPosts/enums.d.ts

@@ -0,0 +1,12 @@
+export declare enum EnumPostActions {
+    OnPostCreated = "onPostCreated",
+    OnPostUpdated = "onPostUpdated",
+    OnPostDeleted = "onPostDeleted",
+    OnPostFlagged = "onPostFlagged",
+    OnPostUnflagged = "onPostUnflagged",
+    OnPostReactionAdded = "onPostReactionAdded",
+    OnPostReactionRemoved = "onPostReactionRemoved",
+    OnPostApproved = "onPostApproved",
+    OnPostDeclined = "onPostDeclined"
+}
+//# sourceMappingURL=enums.d.ts.map

package/dist/postRepository/observers/getPosts/enums.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enums.d.ts","sourceRoot":"","sources":["../../../../src/postRepository/observers/getPosts/enums.ts"],"names":[],"mappings":"AAAA,oBAAY,eAAe;IACzB,aAAa,kBAAkB;IAC/B,aAAa,kBAAkB;IAC/B,aAAa,kBAAkB;IAC/B,aAAa,kBAAkB;IAC/B,eAAe,oBAAoB;IACnC,mBAAmB,wBAAwB;IAC3C,qBAAqB,0BAA0B;IAC/C,cAAc,mBAAmB;IACjC,cAAc,mBAAmB;CAClC"}

package/dist/postRepository/observers/getPosts.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getPosts.d.ts","sourceRoot":"","sources":["../../../src/postRepository/observers/getPosts.ts"],"names":[],"mappings":"AA2CA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,QAAQ,WACX,MAAM,kBAAkB,YACtB,MAAM,sBAAsB,CAAC,MAAM,IAAI,CAAC,WACzC,MAAM,oBAAoB,KAClC,MAAM,YAkLR,CAAC"}
+{"version":3,"file":"getPosts.d.ts","sourceRoot":"","sources":["../../../src/postRepository/observers/getPosts.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,QAAQ,WACX,MAAM,kBAAkB,YACtB,MAAM,sBAAsB,CAAC,MAAM,IAAI,CAAC,WACzC,MAAM,oBAAoB,KAClC,MAAM,YAqBR,CAAC"}

package/dist/postRepository/utils/payload.d.ts

@@ -0,0 +1,2 @@
+export declare const preparePostPayload: (postPayload: Amity.PostPayload) => Amity.ProcessedPostPayload;
+//# sourceMappingURL=payload.d.ts.map

package/dist/postRepository/utils/payload.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"payload.d.ts","sourceRoot":"","sources":["../../../src/postRepository/utils/payload.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,kBAAkB,gBAAiB,MAAM,WAAW,KAAG,MAAM,oBAczE,CAAC"}

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

@@ -29,21 +29,21 @@ export declare const emptyPostPayload: {
 };
 export declare const postQueryResponse: {
     data: Omit<Amity.PostPayload<any>, "communityUsers" | "communities" | "posts"> & {
-        posts: Amity.Post<any>[];
+        posts: Amity.InternalPost<any>[];
         communities: Amity.Community[];
         communityUsers: Amity.Membership<"community">[];
     } & Amity.Pagination;
 };
 export declare const postQueryResponse2: {
     data: Omit<Amity.PostPayload<any>, "communityUsers" | "communities" | "posts"> & {
-        posts: Amity.Post<any>[];
+        posts: Amity.InternalPost<any>[];
         communities: Amity.Community[];
         communityUsers: Amity.Membership<"community">[];
     } & Amity.Pagination;
 };
 export declare const postQueryResponsePage2: {
     data: Omit<Amity.PostPayload<any>, "communityUsers" | "communities" | "posts"> & {
-        posts: Amity.Post<any>[];
+        posts: Amity.InternalPost<any>[];
         communities: Amity.Community[];
         communityUsers: Amity.Membership<"community">[];
     } & Amity.Pagination;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk-react-native",
-  "version": "6.28.2-fbfd068.0",
+  "version": "6.28.3-54dff84.0",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",

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

@@ -348,7 +348,7 @@ declare global {
      * - communityUsers: `Amity.RawMembership` -> `Amity.Membership` (Add user getter prop)
      */
     type ProcessedPostPayload = Omit<PostPayload, 'communities' | 'communityUsers' | 'posts'> & {
-      posts: Amity.Post[];
+      posts: Amity.InternalPost[];
       communities: Amity.Community[];
       communityUsers: Amity.Membership<'community'>[];
     };

package/src/commentRepository/observers/getComments.ts

@@ -28,7 +28,7 @@ import { CommentLiveCollectionController } from './getComments/CommentLiveCollec
  */
 export const getComments = (
   params: Amity.CommentLiveCollection,
-  callback: Amity.LiveCollectionCallback<Amity.InternalComment>,
+  callback: Amity.LiveCollectionCallback<Amity.Comment>,
   config?: Amity.LiveCollectionConfig,
 ): Amity.Unsubscriber => {
   const { log, cache } = getActiveClient();

package/src/communityRepository/utils/payload.ts

@@ -30,9 +30,13 @@ const convertCommunityUsersToUniqueObject = (
   return result;
 };
 
-export const prepareCommunityPayload = (
-  rawPayload: Amity.CommunityPayload,
-): Amity.ProcessedCommunityPayload => {
+export const convertCommunityPayload = (rawPayload: {
+  communities: Amity.RawCommunity[];
+  communityUsers: Amity.RawMembership<'community'>[];
+}): {
+  communities: Amity.Community[];
+  communityUsers: Amity.Membership<'community'>[];
+} => {
   // Unpack community payload by mapping payload field to postSetting value.
   const communities = rawPayload.communities.map<Amity.Community>(
     ({ needApprovalOnPostCreation, onlyAdminCanPost, ...restCommunityPayload }) => ({
@@ -72,6 +76,18 @@ export const prepareCommunityPayload = (
   };
 };
 
+export const prepareCommunityPayload = (
+  rawPayload: Amity.CommunityPayload,
+): Amity.ProcessedCommunityPayload => {
+  const { communities, communityUsers } = convertCommunityPayload(rawPayload);
+
+  return {
+    ...rawPayload,
+    communities,
+    communityUsers,
+  };
+};
+
 export const prepareCommunityRequest = <
   T extends {
     postSetting?: Amity.Community['postSetting'];

package/src/postRepository/internalApi/getPost.ts

@@ -0,0 +1,65 @@
+import { getActiveClient } from '~/client/api';
+
+import { pullFromCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { prepareMembershipPayload } from '~/group/utils';
+
+export const getPost = async (
+  postId: Amity.InternalPost['postId'],
+): Promise<Amity.Cached<Amity.InternalPost>> => {
+  const client = getActiveClient();
+  client.log('post/getPost', postId);
+
+  isInTombstone('post', postId);
+
+  let payload: Amity.PostPayload;
+
+  try {
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const response = await client.http.get<Amity.PostPayload>(
+      `/api/v3/posts/${encodeURIComponent(postId)}`,
+    );
+    payload = response.data;
+  } catch (error) {
+    if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+      pushToTombstone('post', postId);
+    }
+
+    throw error;
+  }
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { posts } = data;
+
+  const result = posts.find(post => post.postId === postId)!;
+
+  return {
+    data: result,
+    cachedAt,
+  };
+};
+
+getPost.locally = (
+  postId: Amity.InternalPost['postId'],
+): Amity.Cached<Amity.InternalPost> | undefined => {
+  const client = getActiveClient();
+  client.log('post/getPost.locally', postId);
+
+  if (!client.cache) return;
+
+  const cached = pullFromCache<Amity.InternalPost>(['post', 'get', postId]);
+
+  if (!cached) return;
+
+  return {
+    data: cached.data,
+    cachedAt: cached.cachedAt,
+  };
+};

package/src/postRepository/internalApi/index.ts

@@ -0,0 +1,16 @@
+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';

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

@@ -0,0 +1,190 @@
+import hash from 'object-hash';
+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,
+  filterByPropEquality,
+  sortByFirstCreated,
+  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';
+
+export class PostLiveCollectionController extends LiveCollectionController<
+  'post',
+  Amity.PostLiveCollection,
+  Amity.Post,
+  PostPaginationController
+> {
+  private queryStreamController: PostQueryStreamController;
+
+  private query: Amity.PostLiveCollection;
+
+  constructor(query: Amity.PostLiveCollection, callback: Amity.LiveCollectionCallback<Amity.Post>) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['posts', 'collection', queryStreamId];
+    const paginationController = new PostPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new PostQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      preparePostPayload,
+    );
+
+    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.PostPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'post'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onPostCreated, action: EnumPostActions.OnPostCreated },
+      { fn: onPostUpdated, 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: 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,
+      },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.PostLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(id => pullFromCache<Amity.InternalPost>(['post', 'get', id])!)
+        .filter(isNonNullable)
+        .map(({ data }) => data) ?? [],
+    ).map(LinkedObject.post);
+
+    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.InternalPost[]) {
+    let posts = data;
+
+    if (!this.query.includeDeleted) {
+      posts = filterByPropEquality(posts, 'isDeleted', false);
+    }
+
+    if (this.query.tags) {
+      posts = posts.filter(p => p.tags?.some(t => this.query.tags?.includes(t)));
+    }
+
+    if (this.query.targetType === 'community' && this.query.feedType) {
+      posts = filterByFeedType(posts, this.query.feedType);
+    }
+
+    if (this.query.dataTypes?.length) {
+      posts = filterByPostDataTypes(posts, this.query.dataTypes);
+    }
+
+    switch (this.query.sortBy) {
+      case 'firstCreated':
+        posts = posts.sort(sortByFirstCreated);
+        break;
+      case 'lastCreated':
+      default:
+        posts = posts.sort(sortByLastCreated);
+        break;
+    }
+
+    return posts;
+  }
+}

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

@@ -0,0 +1,45 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+import { inferIsDeleted } from '~/utils/inferIsDeleted';
+
+export class PostPaginationController extends PaginationController<
+  'post',
+  Amity.PostLiveCollection
+> {
+  async getRequest(queryParams: Amity.PostLiveCollection, token: string | undefined) {
+    const {
+      limit = COLLECTION_DEFAULT_PAGINATION_LIMIT,
+      includeDeleted,
+      matchingOnlyParentPost,
+      ...params
+    } = queryParams;
+
+    const { dataTypes } = params;
+
+    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/v4/posts`,
+      {
+        params: {
+          ...params,
+          isDeleted: inferIsDeleted(includeDeleted),
+          /*
+           * 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/postRepository/observers/getPosts/PostQueryStreamController.ts

@@ -0,0 +1,102 @@
+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';
+import { EnumPostActions } from './enums';
+
+export class PostQueryStreamController extends QueryStreamController<
+  Amity.PostPayload,
+  Amity.PostLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.PostPayload) => Amity.ProcessedPostPayload;
+
+  constructor(
+    query: Amity.PostLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (response: Amity.PostPayload) => Amity.ProcessedPostPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.PostPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.PostPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.posts.map(getResolver('post')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(this.cacheKey)?.data;
+
+      const posts = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [...new Set([...posts, ...response.posts.map(getResolver('post'))])],
+      });
+    }
+  }
+
+  reactor(action: EnumPostActions) {
+    return (post: Amity.InternalPost) => {
+      const collection = pullFromCache<Amity.PostLiveCollectionCache>(this.cacheKey)?.data;
+
+      if (!collection) return;
+
+      if (post.parentPostId && post.isDeleted) {
+        const parentPost = pullFromCache<Amity.InternalPost>([
+          'post',
+          'get',
+          post.parentPostId,
+        ])?.data;
+
+        if (!parentPost || parentPost?.targetId !== this.query.targetId) return;
+
+        parentPost.children = parentPost.children.filter(childId => childId !== post.postId);
+        pushToCache(['post', 'get', parentPost.postId], parentPost);
+      } else {
+        if (this.query.targetId !== post.targetId) return;
+        if (this.query.targetType !== post.targetType) return;
+      }
+
+      if (action === EnumPostActions.OnPostDeclined) {
+        collection.data = collection.data.filter(postId => postId !== post.postId);
+      }
+
+      if (action === EnumPostActions.OnPostCreated || action === EnumPostActions.OnPostApproved) {
+        collection.data = [...new Set([post.postId, ...collection.data])];
+      }
+
+      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/enums.ts

@@ -0,0 +1,11 @@
+export enum EnumPostActions {
+  OnPostCreated = 'onPostCreated',
+  OnPostUpdated = 'onPostUpdated',
+  OnPostDeleted = 'onPostDeleted',
+  OnPostFlagged = 'onPostFlagged',
+  OnPostUnflagged = 'onPostUnflagged',
+  OnPostReactionAdded = 'onPostReactionAdded',
+  OnPostReactionRemoved = 'onPostReactionRemoved',
+  OnPostApproved = 'onPostApproved',
+  OnPostDeclined = 'onPostDeclined',
+}