@amityco/ts-sdk 7.8.1-1b0200c.0 → 7.8.1-2caef95.0

package/src/postRepository/observers/getPostsByHashtag/SearchPostQueryStreamController.ts

@@ -0,0 +1,99 @@
+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 SearchPostQueryStreamController extends QueryStreamController<
+  Amity.PostPayload,
+  Amity.SearchPostWithHashtagLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.PostPayload) => Amity.ProcessedPostPayload;
+
+  constructor(
+    query: Amity.SearchPostWithHashtagLiveCollection,
+    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.PostLiveCollectionCache>(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) 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) {
+        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/index.ts

@@ -3,3 +3,4 @@ export * from './getPosts';
 export * from './getPinnedPosts';
 export * from './getGlobalPinnedPosts';
 export * from './semanticSearchPosts';
+export * from './searchPostsByHashtag';

package/src/postRepository/observers/searchPostsByHashtag.ts

@@ -0,0 +1,56 @@
+import { getActiveClient } from '~/client/api';
+import { dropFromCache } from '~/cache/api';
+
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+import { SearchPostLiveCollectionController } from './getPostsByHashtag/SearchPostLiveCollectionController';
+
+/* begin_public_function
+  id: post.query
+*/
+/**
+ * ```js
+ * import { PostRepository } from '@amityco/ts-sdk'
+ *
+ * let posts = []
+ * const unsub = PostRepository.searchPostsByHashtag({
+ *   hashtags: ['amity'],
+ *   limit: 10,
+ * }, response => merge(posts, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Post} for a given target object
+ *
+ * @param params.hashtags the hashtags to search for
+ * @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 searchPostsByHashtag = (
+  params: Amity.SearchPostWithHashtagLiveCollection,
+  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(`searchPostsByHashtag(tmpid: ${timestamp}) > listen`);
+
+  const postsLiveCollection = new SearchPostLiveCollectionController(params, callback);
+  const disposers = postsLiveCollection.startSubscription();
+
+  const cacheKey = postsLiveCollection.getCacheKey();
+
+  disposers.push(() => dropFromCache(cacheKey));
+
+  return () => {
+    log(`searchPostsByHashtag(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};
+/* end_public_function */