@amityco/ts-sdk-react-native 6.26.1-c3b0164.0 → 6.26.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk-react-native",
-  "version": "6.26.1-c3b0164.0",
+  "version": "6.26.2",
   "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

@@ -361,6 +361,11 @@ declare global {
       communityUsers: Amity.Membership<'community'>[];
     };
 
+    type ProcessedCommentPayload<T extends Amity.CommentContentType = any> = Omit<
+      CommentPayload<T>,
+      'users' | 'files' | 'communityUsers'
+    >;
+
     type PollPayload = {
       users: Amity.InternalUser[];
       polls: Amity.Poll[];

package/src/commentRepository/observers/getComments/CommentLiveCollectionController.ts

@@ -0,0 +1,132 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { CommentPaginationController } from './CommentPaginationController';
+import { CommentQueryStreamController } from './CommentQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import {
+  onCommentCreated,
+  onCommentUpdated,
+  onCommentDeleted,
+  onCommentFlagged,
+  onCommentUnflagged,
+  onCommentReactionAdded,
+  onCommentReactionRemoved,
+} from '~/commentRepository/events';
+import { filterByPropEquality, sortByFirstCreated, sortByLastCreated } from '~/core/query';
+import { isNonNullable } from '~/utils';
+import { EnumCommentActions } from './enums';
+import { LinkedObject } from '~/utils/linkedObject';
+import { prepareCommentPayload } from '~/commentRepository/utils/payload';
+
+export class CommentLiveCollectionController extends LiveCollectionController<
+  'comment',
+  Amity.CommentLiveCollection,
+  Amity.Comment,
+  CommentPaginationController
+> {
+  private queryStreamController: CommentQueryStreamController;
+
+  private query: Amity.CommentLiveCollection;
+
+  constructor(
+    query: Amity.CommentLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Comment>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['comments', 'collection', queryStreamId];
+    const paginationController = new CommentPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new CommentQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareCommentPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.CommentLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.CommentPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'comment'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onCommentCreated, action: EnumCommentActions.OnCommentCreated },
+      { fn: onCommentUpdated, action: EnumCommentActions.OnCommentUpdated },
+      { fn: onCommentDeleted, action: EnumCommentActions.OnCommentDeleted },
+      { fn: onCommentFlagged, action: EnumCommentActions.OnCommentFlagged },
+      { fn: onCommentUnflagged, action: EnumCommentActions.OnCommentUnflagged },
+      { fn: onCommentReactionAdded, action: EnumCommentActions.OnCommentReactionAdded },
+      { fn: onCommentReactionRemoved, action: EnumCommentActions.OnCommentReactionRemoved },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.CommentLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(id => pullFromCache<Amity.InternalComment>(['comments', 'get', id])!)
+        .filter(isNonNullable)
+        .map(({ data }) => data) ?? [],
+    ).map(LinkedObject.comment);
+
+    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.InternalComment[]) {
+    let comments = data;
+
+    if (this.query.includeDeleted) {
+      comments = filterByPropEquality(comments, 'isDeleted', false);
+    }
+
+    if (this.query.parentId) {
+      comments = comments.filter(comment => comment.parentId === this.query.parentId);
+    }
+
+    switch (this.query.sortBy) {
+      case 'firstCreated':
+        comments = comments.sort(sortByFirstCreated);
+        break;
+      case 'lastCreated':
+      default:
+        comments = comments.sort(sortByLastCreated);
+        break;
+    }
+
+    return comments;
+  }
+}

package/src/commentRepository/observers/getComments/CommentPaginationController.ts

@@ -0,0 +1,30 @@
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+import { inferIsDeleted } from '~/utils/inferIsDeleted';
+
+export class CommentPaginationController extends PaginationController<
+  'comment',
+  Amity.CommentLiveCollection
+> {
+  async getRequest(queryParams: Amity.CommentLiveCollection, token: string | undefined) {
+    const { limit = COLLECTION_DEFAULT_PAGINATION_LIMIT, includeDeleted, ...params } = queryParams;
+
+    const baseOptions = {
+      type: params.sortBy || queryParams.limit ? 'pagination' : undefined,
+    };
+
+    const options = token ? { ...baseOptions, token } : { ...baseOptions, limit };
+
+    const { data: queryResponse } = await this.http.get<Amity.CommentPayload & Amity.Pagination>(
+      `/api/v3/comments`,
+      {
+        params: {
+          ...params,
+          isDeleted: inferIsDeleted(includeDeleted),
+          options,
+        },
+      },
+    );
+    return queryResponse;
+  }
+}

package/src/commentRepository/observers/getComments/CommentQueryStreamController.ts

@@ -0,0 +1,90 @@
+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 { EnumCommentActions } from './enums';
+
+export class CommentQueryStreamController extends QueryStreamController<
+  Amity.CommentPayload,
+  Amity.CommentLiveCollection
+> {
+  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
+
+  private preparePayload: (response: Amity.CommentPayload) => Amity.ProcessedCommentPayload;
+
+  constructor(
+    query: Amity.CommentLiveCollection,
+    cacheKey: string[],
+    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
+    preparePayload: (response: Amity.CommentPayload) => Amity.ProcessedCommentPayload,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+    this.preparePayload = preparePayload;
+  }
+
+  async saveToMainDB(response: Amity.CommentPayload) {
+    const processedPayload = await this.preparePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.CommentPayload & Partial<Amity.Pagination>,
+    direction: Amity.LiveCollectionPageDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.comments.map(getResolver('comment')),
+      });
+    } else {
+      const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(this.cacheKey)?.data;
+
+      const comments = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data: [...new Set([...comments, ...response.comments.map(getResolver('comment'))])],
+      });
+    }
+  }
+
+  reactor(action: EnumCommentActions) {
+    return (comment: Amity.InternalComment) => {
+      const collection = pullFromCache<Amity.CommentLiveCollectionCache>(this.cacheKey)?.data;
+
+      if (
+        this.query.referenceId !== comment.referenceId ||
+        this.query.referenceType !== comment.referenceType ||
+        !collection
+      ) {
+        return;
+      }
+
+      if (action === EnumCommentActions.OnCommentCreated) {
+        collection.data = [...new Set([comment.commentId, ...collection.data])];
+      } else if (action === EnumCommentActions.OnCommentDeleted) {
+        collection.data = collection.data.filter(p => p !== comment.commentId);
+      }
+
+      pushToCache(this.cacheKey, collection);
+      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: (comment: Amity.InternalComment) => void) => Amity.Unsubscriber;
+      action: EnumCommentActions;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/commentRepository/observers/getComments/enums.ts

@@ -0,0 +1,9 @@
+export enum EnumCommentActions {
+  OnCommentCreated = 'onCommentCreated',
+  OnCommentUpdated = 'onCommentUpdated',
+  OnCommentDeleted = 'onCommentDeleted',
+  OnCommentFlagged = 'onCommentFlagged',
+  OnCommentUnflagged = 'onCommentUnflagged',
+  OnCommentReactionAdded = 'onCommentReactionAdded',
+  OnCommentReactionRemoved = 'onCommentReactionRemoved',
+}

package/src/commentRepository/observers/getComments.ts

@@ -1,34 +1,7 @@
-/* eslint-disable no-use-before-define */
-import { getResolver } from '~/core/model';
 import { getActiveClient } from '~/client/api';
-import { dropFromCache, pullFromCache, pushToCache } from '~/cache/api';
+import { dropFromCache } from '~/cache/api';
 
-import {
-  createQuery,
-  filterByPropEquality,
-  queryOptions,
-  runQuery,
-  sortByFirstCreated,
-  sortByLastCreated,
-} from '~/core/query';
-
-import {
-  COLLECTION_DEFAULT_CACHING_POLICY,
-  COLLECTION_DEFAULT_PAGINATION_LIMIT,
-} from '~/utils/constants';
-
-import { CACHE_SHORTEN_LIFESPAN } from '~/cache/utils';
-import { LinkedObject } from '~/utils/linkedObject';
-import {
-  onCommentCreated,
-  onCommentDeleted,
-  onCommentFlagged,
-  onCommentReactionAdded,
-  onCommentReactionRemoved,
-  onCommentUnflagged,
-  onCommentUpdated,
-} from '../events';
-import { queryComments } from '../internalApi/queryComments';
+import { CommentLiveCollectionController } from './getComments/CommentLiveCollectionController';
 
 /* begin_public_function
   id: comment.query
@@ -67,120 +40,11 @@ export const getComments = (
   const timestamp = Date.now();
   log(`getComments(tmpid: ${timestamp}) > listen`);
 
-  const { limit: queryLimit, ...queryParams } = params;
-
-  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
-  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
-
-  const disposers: Amity.Unsubscriber[] = [];
-
-  const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
-  const cacheKey = [
-    'comment',
-    'collection',
-    {
-      referenceId: params.referenceType,
-      referenceType: params.referenceId,
-      parentId: params?.parentId || '',
-      sortBy,
-    },
-  ];
-
-  const responder = (data: Amity.CommentLiveCollectionCache) => {
-    let comments: Amity.InternalComment[] =
-      data.data
-        .map(commentId => pullFromCache<Amity.InternalComment>(['comment', 'get', commentId])!)
-        .filter(({ data }) => data.parentId === params?.parentId)
-        .filter(Boolean)
-        .map(({ data }) => LinkedObject.comment(data)) ?? [];
-
-    if (!params.includeDeleted) {
-      comments = filterByPropEquality(comments, 'isDeleted', false);
-    }
-
-    comments = comments.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
-
-    callback({
-      onNextPage: onFetch,
-      data: comments,
-      hasNextPage: !!data.params?.page,
-      loading: data.loading,
-      error: data.error,
-    });
-  };
-
-  const realtimeRouter = (action: Amity.CommentActionType) => (comment: Amity.InternalComment) => {
-    const collection = pullFromCache<Amity.CommentLiveCollectionCache>(cacheKey)?.data;
-
-    if (
-      params.referenceId !== comment.referenceId ||
-      params.referenceType !== comment.referenceType ||
-      !collection
-    ) {
-      return;
-    }
-
-    if (action === 'onCreate') {
-      collection.data = [...new Set([comment.commentId, ...collection.data])];
-    } else if (action === 'onDelete') {
-      collection.data = collection.data.filter(p => p !== comment.commentId);
-    }
-
-    pushToCache(cacheKey, collection);
-
-    responder(collection);
-  };
-
-  const onFetch = (initial = false) => {
-    const collection = pullFromCache<Amity.CommentLiveCollectionCache>(cacheKey)?.data;
-
-    const comments = collection?.data ?? [];
-
-    if (!initial && comments.length > 0 && !collection?.params?.page) return;
-
-    const query = createQuery(queryComments, {
-      ...queryParams,
-      limit: queryLimit,
-      page: !initial ? collection?.params.page : undefined,
-    });
-
-    runQuery(
-      query,
-      ({ data: result, error, loading, paging }) => {
-        const page = paging?.next;
-
-        const data = {
-          loading,
-          error,
-          params: { page },
-          data: comments,
-        };
-
-        if (result) {
-          data.data = initial
-            ? result.map(getResolver('comment')) // Replace a collection list with new data from BE
-            : [...new Set([...comments, ...result.map(getResolver('comment'))])];
-        }
-
-        pushToCache(cacheKey, data);
-
-        responder(data);
-      },
-      queryOptions(policy, CACHE_SHORTEN_LIFESPAN),
-    );
-  };
+  const commentsLiveCollection = new CommentLiveCollectionController(params, callback);
+  const disposers = commentsLiveCollection.startSubscription();
 
-  disposers.push(
-    onCommentCreated(realtimeRouter('onCreate')),
-    onCommentUpdated(realtimeRouter('onUpdate')),
-    onCommentDeleted(realtimeRouter('onDelete')),
-    onCommentFlagged(realtimeRouter('onFlagged')),
-    onCommentUnflagged(realtimeRouter('onUnflagged')),
-    onCommentReactionAdded(realtimeRouter('onReactionAdded')),
-    onCommentReactionRemoved(realtimeRouter('onReactionRemoved')),
-  );
+  const cacheKey = commentsLiveCollection.getCacheKey();
 
-  onFetch(true);
   disposers.push(() => dropFromCache(cacheKey));
 
   return () => {

package/src/commentRepository/utils/payload.ts

@@ -0,0 +1,19 @@
+export function prepareCommentPayload(
+  commentPayload: Amity.CommentPayload,
+): Amity.ProcessedCommentPayload {
+  const { comments } = commentPayload;
+
+  return {
+    ...commentPayload,
+    comments: comments.map(comment => {
+      if (comment.hasOwnProperty('myReactions')) return comment;
+
+      // Sometimes `myReactions` field will not come with BE response because that field is empty
+      // We need to put it with an empty array manually to make it show up in client side
+      return {
+        myReactions: [],
+        ...comment,
+      };
+    }),
+  };
+}