@amityco/ts-sdk 7.8.0 → 7.8.1-0c348c9.0

package/src/feedRepository/observers/getUserFeed/QueryStreamController.ts

@@ -0,0 +1,119 @@
+import { getResolver } from '~/core/model';
+import { getActiveClient } from '~/client';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { EnumPostActions } from '~/postRepository/observers/enums';
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+
+export class UserFeedQueryStreamController extends QueryStreamController<
+  Amity.PostPayload,
+  Amity.UserFeedLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.PostPayload) => Amity.ProcessedPostPayload;
+
+  constructor(
+    query: Amity.UserFeedLiveCollection,
+    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.UserFeedLiveCollectionCache>(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.UserFeedLiveCollectionCache>(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',
+          'get',
+          post.parentPostId,
+        ])?.data;
+
+        if (!parentPost) return;
+
+        parentPost.children = parentPost.children.filter(childId => childId !== post.postId);
+        pushToCache(['post', 'get', parentPost.postId], parentPost);
+      }
+
+      if (action === EnumPostActions.OnPostDeclined) {
+        collection.data = collection.data.filter(postId => postId !== post.postId);
+      }
+
+      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])];
+      }
+
+      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/feedRepository/observers/getUserFeed.ts

@@ -0,0 +1,56 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { dropFromCache } from '~/cache/api/dropFromCache';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { UserFeedLiveCollectionController } from './getUserFeed/LiveCollectionController';
+
+/* begin_public_function
+  id: feed.query.user_feed
+*/
+/**
+ * ```js
+ * import { FeedRepository } from '@amityco/ts-sdk'
+ *
+ * let posts = []
+ * const unsubscribe = FeedRepository.getUserFeed({
+ *   userId: string,
+ *   feedSources: ['user', 'community'],
+ * }, response => response => processResponse(response))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Post} for a given user and feedSources
+ *
+ * @param params.userId the ID of the user
+ * @param params.feedSources the sources of the feed
+ * @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 getUserFeed = (
+  params: Amity.UserFeedLiveCollection,
+  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(`getUserFeed(tmpid: ${timestamp}) > listen`);
+
+  const userFeedLiveCollection = new UserFeedLiveCollectionController(params, callback);
+  const disposers = userFeedLiveCollection.startSubscription();
+
+  const cacheKey = userFeedLiveCollection.getCacheKey();
+
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`getUserFeed(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};
+/* end_public_function */

package/src/feedRepository/observers/index.ts

@@ -0,0 +1,3 @@
+export { getCustomRankingGlobalFeed } from './getCustomRankingGlobalFeed';
+export { getGlobalFeed } from './getGlobalFeed';
+export { getUserFeed } from './getUserFeed';

package/src/feedRepository/observers/utils.ts

@@ -0,0 +1,85 @@
+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,
+) => {
+  return eventHandler(async (comment: Amity.InternalComment) => {
+    const currentCollection =
+      pullFromCache<Amity.CustomRankingGlobalFeedLiveCollectionCache>(cacheKey)?.data;
+
+    if (!currentCollection || !currentCollection.data.includes(comment.referenceId)) return;
+
+    await getPost(comment.referenceId);
+    callback(comment);
+  });
+};
+
+const generateCommentSubscriptions = (cacheKey: Amity.CacheKey) => {
+  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),
+      'referenceId',
+      'post',
+    ),
+    action: EnumPostActions.OnPostUpdated,
+  }));
+};
+
+export const getGlobalFeedSubscriptions = (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/pollRepository/api/createPoll.ts

@@ -11,8 +11,8 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * const created = await createPoll({
  *   question: 'question',
  *   answers: [
- *      { dataType: 'text', data: 'answer1' },
- *      { dataType: 'text', data: 'answer2' },
+ *      { dataType: 'text', data: 'answer1', fileId: 'fileId1' },
+ *      { dataType: 'text', data: 'answer2', fileId: 'fileId2' },
  *   ],
  *   closedIn: 1649136484
  * }))
@@ -27,7 +27,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * @async
  */
 export const createPoll = async (
-  bundle: Pick<Amity.Poll, 'question' | 'answerType' | 'closedIn'> & {
+  bundle: Pick<Amity.Poll, 'title' | 'question' | 'answerType' | 'closedIn'> & {
     answers: Pick<Amity.PollAnswer, 'dataType' | 'data'>[];
   },
 ): Promise<Amity.Cached<Amity.Poll>> => {

package/src/postRepository/api/createPost.ts

@@ -28,7 +28,7 @@ import { preparePostPayload } from '../utils/payload';
  */
 export const createPost = async <T extends Amity.PostContentType | string>(
   bundle: Pick<Amity.Post<T>, 'targetType' | 'targetId'> &
-    Partial<Pick<Amity.Post<T>, 'metadata' | 'mentionees' | 'tags'>> & {
+    Partial<Pick<Amity.Post<T>, 'metadata' | 'mentionees' | 'tags' | 'hashtags'>> & {
       dataType?: T;
       data?: { [k: string]: any };
       attachments?: { type: T; fileId: Amity.File['fileId'] }[];

package/src/postRepository/api/editPost.ts

@@ -27,7 +27,7 @@ import { LinkedObject } from '~/utils/linkedObject';
  */
 export const editPost = async <T extends Amity.PostContentType>(
   postId: Amity.Post['postId'],
-  patch: Patch<Amity.Post, 'data' | 'metadata' | 'mentionees' | 'tags'> & {
+  patch: Patch<Amity.Post, 'data' | 'metadata' | 'mentionees' | 'tags' | 'hashtags'> & {
     attachments?: {
       type: T;
       fileId: Amity.File['fileId'];

package/src/postRepository/api/queryPosts.ts

@@ -63,13 +63,13 @@ export const queryPosts = async (
   // const { paging, posts } = unwrapPayload(data)
   // unpacking
   const { paging, ...payload } = data;
-  const paperedPayload = prepareMembershipPayload(payload, 'communityUsers');
+  const preparedPayload = prepareMembershipPayload(payload, 'communityUsers');
   const { posts } = payload;
 
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(paperedPayload, { cachedAt });
+    ingestInCache(preparedPayload, { cachedAt });
 
     const cacheKey = ['post', 'query', { ...params, options } as Amity.Serializable];
     pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging });

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) {