@amityco/ts-sdk-react-native 6.30.2-bc5ef81.0 → 6.30.2

package/src/postRepository/observers/semanticSearch/SemanticSearchPostQueryStreamController.ts

@@ -0,0 +1,111 @@
+import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client';
+import { EnumPostActions } from '../enums';
+import { preparePostResponse } from './utils';
+
+export class SemanticSearchPostQueryStreamController extends QueryStreamController<
+  Amity.SemanticSearchPostPayload,
+  Amity.SemanticSearchPostLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (
+    response: Amity.SemanticSearchPostPayload,
+  ) => Amity.ProcessedSemanticSearchPostPayload;
+
+  constructor(
+    query: Amity.SemanticSearchPostLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (
+      response: Amity.SemanticSearchPostPayload,
+    ) => Amity.ProcessedSemanticSearchPostPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.SemanticSearchPostPayload) {
+    const processedPayload = this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.SemanticSearchPostPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: preparePostResponse(response),
+      });
+    } else {
+      const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(this.cacheKey)?.data;
+
+      const posts = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [...new Set([...posts, ...preparePostResponse(response)])],
+      });
+    }
+  }
+
+  reactor(action: EnumPostActions) {
+    return (post: Amity.InternalPost) => {
+      const collection = pullFromCache<Amity.SemanticSearchPostLiveCollectionCache>(
+        this.cacheKey,
+      )?.data;
+
+      if (!collection) return;
+
+      if (post.parentPostId && post.isDeleted) {
+        const parentSemanticSearchPost = pullFromCache<Amity.InternalPost>([
+          'post',
+          'get',
+          post.parentPostId,
+        ])?.data;
+
+        if (!parentSemanticSearchPost || parentSemanticSearchPost?.targetId !== this.query.targetId)
+          return;
+
+        parentSemanticSearchPost.children = parentSemanticSearchPost.children.filter(
+          childId => childId !== post.postId,
+        );
+        pushToCache(['post', 'get', parentSemanticSearchPost.postId], parentSemanticSearchPost);
+      } 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/semanticSearch/utils.ts

@@ -0,0 +1,12 @@
+export function preparePostResponse(response: Amity.SemanticSearchPostPayload) {
+  return response.posts.map(post => {
+    const postScore = response.searchResult.find(result => result.postId === post.postId)!;
+    return `${post.postId}:${postScore.score}`;
+  });
+}
+
+export function getPostIdsFromCache(cacheData?: string[]) {
+  return (cacheData ?? []).map(postIdWithScore => {
+    return postIdWithScore.split(':')[0];
+  });
+}

package/src/postRepository/observers/semanticSearchPosts.ts

@@ -0,0 +1,42 @@
+import { getActiveClient } from '~/client/api';
+import { dropFromCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { SemanticSearchPostLiveCollectionController } from './semanticSearch/SemanticSearchPostLiveCollectionController';
+
+/**
+ * search posts by semantic search
+ *
+ * @returns the associated pinned post(s)
+ *
+ * @category Posts Live Collection
+ *
+ */
+export const semanticSearchPosts = (
+  params: Amity.LiveCollectionParams<Amity.SemanticSearchPostLiveCollection>,
+  callback: Amity.LiveCollectionCallback<Amity.Post>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`semanticSearchPosts(tmpid: ${timestamp}) > listen`);
+
+  const semanticSearchPostLiveCollection = new SemanticSearchPostLiveCollectionController(
+    params,
+    callback,
+  );
+  const disposers = semanticSearchPostLiveCollection.startSubscription();
+
+  const cacheKey = semanticSearchPostLiveCollection.getCacheKey();
+
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`semanticSearchPosts(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/postRepository/utils/payload.ts

@@ -1,7 +1,9 @@
 import { addPostSetting } from '~/communityRepository/utils';
 import { updateMembershipStatus } from '~/communityRepository/utils/communityWithMembership';
 
-export const preparePostPayload = (postPayload: Amity.PostPayload): Amity.ProcessedPostPayload => {
+export const preparePostPayload = (payload: Amity.PostPayload): Amity.ProcessedPostPayload => {
+  const { posts: postsData, ...postPayload } = payload;
+
   // Unpack community payload by mapping payload field to postSetting value.
   const communitiesWithPostSetting = addPostSetting({ communities: postPayload.communities });
 
@@ -23,7 +25,7 @@ export const preparePostPayload = (postPayload: Amity.PostPayload): Amity.Proces
   );
 
   // feed type
-  const posts = postPayload.posts.map(post => {
+  const posts = postsData.map(post => {
     const feedType = postPayload.feeds.find(feed => feed.feedId === post.feedId)?.feedType;
 
     return {
@@ -39,3 +41,16 @@ export const preparePostPayload = (postPayload: Amity.PostPayload): Amity.Proces
     communityUsers: mappedCommunityUsers,
   };
 };
+
+export const prepareSemanticSearchPostPayload = ({
+  searchResult,
+  polls,
+  ...postPayload
+}: Amity.SemanticSearchPostPayload): Amity.ProcessedSemanticSearchPostPayload => {
+  const processedPostPayload = preparePostPayload(postPayload);
+
+  return {
+    ...processedPostPayload,
+    polls,
+  };
+};