@amityco/ts-sdk 7.7.1-b4d2931b.0 → 7.7.1-bd711609.0

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

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

package/src/postRepository/events/utils.ts

@@ -1,38 +1,10 @@
 import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { createEventSubscriber, fireEvent } from '~/core/events';
-import { dropFromCache, pullFromCache, pushToCache, queryCache, upsertInCache } from '~/cache/api';
+import { dropFromCache, pullFromCache, 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>,
@@ -64,8 +36,6 @@ export const createPostEventSubscriber = (
       if (event === 'post.deleted') {
         const { postId, postedUserId } = payload.posts[0];
 
-        processDeleteChildPost(payload);
-
         try {
           isInTombstone('post', postId);
         } catch (e) {
@@ -100,8 +70,6 @@ export const createPostEventSubscriber = (
         queries?.map(({ key, data }) => upsertInCache(key, data as any, { cachedAt: -1 }));
       }
 
-      if (event === 'post.created') processCreateChildPost(payload);
-
       callback(post.data);
     }
   };
@@ -138,8 +106,6 @@ 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,7 +8,6 @@ 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',
@@ -72,10 +71,6 @@ 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,7 +6,6 @@ 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',
@@ -64,12 +63,7 @@ export class PinnedPostLiveCollectionController extends LiveCollectionController
 
   // eslint-disable-next-line class-methods-use-this
   startSubscription() {
-    return this.queryStreamController.subscribeRTE(
-      generateCommentSubscriptions({
-        cacheKey: this.cacheKey,
-        resolveId: id => `${this.query.placement}#${id}`,
-      }),
-    );
+    return [] as Amity.Unsubscriber[];
   }
 
   notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {

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

@@ -4,7 +4,6 @@ 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,
@@ -65,30 +64,4 @@ 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,6 +3,17 @@ 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,
@@ -11,9 +22,16 @@ 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 { getPostSubscription } from '../utils';
+import { convertEventPayload } from '~/utils/event';
+import { onCommentCreated, onCommentDeleted } from '~/commentRepository';
+import { getPost } from '~/postRepository/internalApi/getPost';
+import { onPostUpdatedLocal } from '~/postRepository/events/onPostUpdatedLocal';
+import { onLocalPostReactionAdded } from '~/postRepository/events/onLocalPostReactionAdded';
+import { onLocalPostReactionRemoved } from '~/postRepository/events/onLocalPostReactionRemoved';
+import { onLocalPostDeleted } from '~/postRepository/events/onLocalPostDeleted';
 
 export class PostLiveCollectionController extends LiveCollectionController<
   'post',
@@ -67,7 +85,61 @@ export class PostLiveCollectionController extends LiveCollectionController<
   }
 
   startSubscription() {
-    return this.queryStreamController.subscribeRTE(getPostSubscription(this.cacheKey));
+    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,
+      },
+    ]);
   }
 
   notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {

package/src/reactionRepository/api/addReaction.ts

@@ -69,7 +69,6 @@ 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,7 +72,6 @@ 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 shallowClone(post, {
+  return {
+    ...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;
     },
-  });
+  };
 };