@amityco/ts-sdk-react-native 6.13.2 → 6.14.0

package/src/feedRepository/internalApi/test/getCustomRankingGlobalFeed.test.ts

@@ -0,0 +1,138 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+
+import { client, deepCopy, post11, post12, user11 } from '~/utils/tests';
+
+import { getCustomRankingGlobalFeed } from '../getCustomRankingGlobalFeed';
+
+const pagingToken = {
+  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+};
+
+const postsToQuery = [post11, post12];
+const postIdsToQuery = postsToQuery.map(post => post.postId);
+const pagingCriteria = { limit: 10 };
+const queryCriteriaWithoutPage = {};
+const queryCriteria = { ...queryCriteriaWithoutPage, page: pagingCriteria };
+
+const resolvedQueryFeedValue = {
+  data: {
+    posts: postsToQuery,
+    postChildren: [],
+    categories: [],
+    comments: [],
+    communityUsers: [],
+    feeds: [],
+    files: [],
+    polls: [],
+    users: [user11],
+    paging: pagingToken,
+  },
+};
+
+describe('getCustomRankingGlobalFeed', () => {
+  test('it should return fetched feed with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedQueryFeedValue);
+
+    const result = await getCustomRankingGlobalFeed(queryCriteria);
+
+    expect(deepCopy(result)).toEqual(
+      expect.objectContaining(
+        deepCopy({
+          data: postsToQuery,
+          prevPage: { before: 55, limit: 10 },
+          nextPage: { before: 55, limit: 10 },
+        }),
+      ),
+    );
+  });
+
+  test('it should update cache after fetching feed', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(resolvedQueryFeedValue);
+
+    await getCustomRankingGlobalFeed(queryCriteria);
+
+    const recieved = pullFromCache([
+      'customGlobalFeed',
+      'query',
+      { ...queryCriteriaWithoutPage, options: pagingCriteria },
+    ])?.data;
+
+    expect(recieved).toEqual({
+      posts: postIdsToQuery,
+      paging: pagingToken,
+    });
+
+    disableCache();
+  });
+
+  test('it should call the correct api', async () => {
+    const resolver = jest.fn().mockResolvedValue(resolvedQueryFeedValue);
+    client.http.get = resolver;
+
+    await getCustomRankingGlobalFeed(queryCriteria);
+
+    expect(resolver).toHaveBeenCalledWith(`/api/v5/me/global-feeds`, expect.any(Object));
+  });
+
+  test('it should throw an error if request fails', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(getCustomRankingGlobalFeed(queryCriteria)).rejects.toThrow('error');
+  });
+});
+
+describe('getCustomRankingGlobalFeed.locally', () => {
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  test('it should return cached feed', () => {
+    postsToQuery.forEach(post => pushToCache(['post', 'get', post.postId], post));
+
+    pushToCache(
+      ['customGlobalFeed', 'query', { ...queryCriteriaWithoutPage, options: pagingCriteria }],
+      {
+        posts: postIdsToQuery,
+        paging: pagingToken,
+      },
+    );
+
+    pushToCache(['user', 'get', user11.userId], user11);
+
+    expect(deepCopy(getCustomRankingGlobalFeed.locally(queryCriteria))).toEqual(
+      expect.objectContaining(
+        deepCopy({
+          data: postsToQuery,
+          prevPage: { before: 55, limit: 10 },
+          nextPage: { before: 55, limit: 10 },
+        }),
+      ),
+    );
+  });
+
+  test('it should accept undefined query param', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedQueryFeedValue);
+
+    expect(() => getCustomRankingGlobalFeed.locally()).not.toThrow();
+  });
+
+  test(`it shouldn't return if individual feed cache not exist`, () => {
+    pushToCache(['globalFeed', 'query', { ...queryCriteriaWithoutPage, options: pagingCriteria }], {
+      posts: postIdsToQuery,
+      paging: pagingToken,
+    });
+
+    expect(getCustomRankingGlobalFeed.locally(queryCriteria)).toBeUndefined();
+  });
+
+  test('it should return undefined if feed not in cache', () => {
+    expect(getCustomRankingGlobalFeed.locally({})).toBeUndefined();
+  });
+
+  test('it should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(getCustomRankingGlobalFeed.locally({})).toBeUndefined();
+  });
+});

package/src/feedRepository/internalApi/test/queryGlobalFeed.test.ts

@@ -0,0 +1,130 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+
+import { client, deepCopy, post11, post12, user11 } from '~/utils/tests';
+
+import { queryGlobalFeed } from '../queryGlobalFeed';
+
+const pagingToken = {
+  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+};
+
+const postsToQuery = [post11, post12];
+const postIdsToQuery = postsToQuery.map(post => post.postId);
+const pagingCriteria = { limit: 10 };
+const queryCriteriaWithoutPage = {};
+const queryCriteria = { ...queryCriteriaWithoutPage, page: pagingCriteria };
+
+const resolvedQueryFeedValue = {
+  data: {
+    posts: postsToQuery,
+    postChildren: [],
+    categories: [],
+    comments: [],
+    communityUsers: [],
+    feeds: [],
+    files: [],
+    polls: [],
+    users: [user11],
+    paging: pagingToken,
+  },
+};
+
+describe('queryGlobalFeed', () => {
+  test('should return fetched feed with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedQueryFeedValue);
+
+    const result = await queryGlobalFeed(queryCriteria);
+    expect(deepCopy(result)).toEqual(
+      expect.objectContaining(
+        deepCopy({
+          data: postsToQuery,
+          prevPage: { before: 55, limit: 10 },
+          nextPage: { before: 55, limit: 10 },
+        }),
+      ),
+    );
+  });
+
+  test('should accept undefined query param', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedQueryFeedValue);
+
+    await expect(queryGlobalFeed()).resolves.not.toThrow();
+  });
+
+  test('should update cache after fetching feed', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(resolvedQueryFeedValue);
+
+    await queryGlobalFeed(queryCriteria);
+
+    const recieved = pullFromCache([
+      'globalFeed',
+      'query',
+      { ...queryCriteriaWithoutPage, options: pagingCriteria },
+    ])?.data;
+
+    expect(recieved).toEqual({
+      posts: postIdsToQuery,
+      paging: pagingToken,
+    });
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryGlobalFeed(queryCriteria)).rejects.toThrow('error');
+  });
+});
+
+describe('queryGlobalFeed.locally', () => {
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  test('should return cached feed', () => {
+    postsToQuery.forEach(post => pushToCache(['post', 'get', post.postId], post));
+
+    pushToCache(['globalFeed', 'query', { ...queryCriteriaWithoutPage, options: pagingCriteria }], {
+      posts: postIdsToQuery,
+      paging: pagingToken,
+    });
+    pushToCache(['user', 'get', user11.userId], user11);
+
+    expect(deepCopy(queryGlobalFeed.locally(queryCriteria))).toEqual(
+      expect.objectContaining(
+        deepCopy({
+          data: postsToQuery,
+          prevPage: { before: 55, limit: 10 },
+          nextPage: { before: 55, limit: 10 },
+        }),
+      ),
+    );
+  });
+
+  test('should accept undefined query param', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedQueryFeedValue);
+
+    expect(() => queryGlobalFeed.locally()).not.toThrow();
+  });
+
+  test(`shouldn't return if individual feed cache not exist`, () => {
+    pushToCache(['globalFeed', 'query', { ...queryCriteriaWithoutPage, options: pagingCriteria }], {
+      posts: postIdsToQuery,
+      paging: pagingToken,
+    });
+
+    expect(queryGlobalFeed.locally(queryCriteria)).toBeUndefined();
+  });
+
+  test('it should return undefined if feed not in cache', () => {
+    expect(queryGlobalFeed.locally({})).toBeUndefined();
+  });
+
+  test('it should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(queryGlobalFeed.locally({})).toBeUndefined();
+  });
+});

package/src/index.ts

@@ -24,7 +24,7 @@ export * as ReactionRepository from './reactionRepository';
 export * from './report/api';
 
 // // asc messaging
-export * as ChannelRepository from './channelRepsitory';
+export * as ChannelRepository from './channelRepository';
 export * as MessageRepository from './messageRepository';
 export * as SubChannelRepository from './subChannelRepository';
 

package/src/messageRepository/observers/getMessages.ts

@@ -26,6 +26,7 @@ import {
 } from '../events';
 import { onMessageFetched } from '../events/onMessageFetched';
 import { queryMessages } from '../api/queryMessages';
+import { MessageLiveCollectionController } from './liveCollection/MessageLiveCollectionController';
 
 /*
  * Exported for testing
@@ -114,115 +115,14 @@ export const getMessages = (
   const timestamp = Date.now();
   log(`getMessages(tmpid: ${timestamp}) > listen`);
 
-  const { limit: queryLimit, ...queryParams } = params;
+  const messagesLiveCollection = new MessageLiveCollectionController(params, callback);
+  const disposers = messagesLiveCollection.startSubscription();
 
-  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
-  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+  const cacheKey = messagesLiveCollection.getCacheKey();
 
-  const disposers: Amity.Unsubscriber[] = [];
-  const uniqueId = uuid();
-  const cacheKey = ['message', 'collection', params, uniqueId];
-
-  const responder = (data: Amity.MessageLiveCollectionCache) => {
-    const messages: Amity.Message[] = applyFilter(
-      data.data
-        .map(messageId => pullFromCache<Amity.Message>(['message', 'get', messageId])!)
-        .filter(Boolean)
-        .map(({ data }) => data) ?? [],
-      params,
-    );
-
-    callback({
-      onNextPage: onFetch,
-      data: messages,
-      hasNextPage: !!data.params?.page,
-      loading: data.loading,
-      error: data.error,
-    });
-  };
-
-  const realtimeRouter = (action: Amity.MessageActionType) => (message: Amity.Message) => {
-    const collection = pullFromCache<Amity.MessageLiveCollectionCache>(cacheKey)?.data;
-
-    if (params.subChannelId !== message?.subChannelId || !collection) return;
-
-    // /*
-    //  * check if RTE message event payload is with the params in order to update in the colleciton cache
-    //  */
-
-    if (params.dataType && params.dataType !== message.dataType) return;
-
-    if (params.excludeTags && params.excludeTags?.some(value => message.tags?.includes(value)))
-      return;
-
-    if (!!params.hasFlags !== !!message.flagCount) return;
-
-    if (params.parentId && params.parentId !== message.parentId) return;
-
-    if (params.hasOwnProperty('includeDeleted') && !params.includeDeleted && message.isDeleted)
-      return;
-
-    if (params.tags && !params.tags?.some(value => message.tags?.includes(value))) return;
-
-    if (!collection.data.includes(message.messageId) && action === 'onCreate') {
-      collection.data = [...new Set([message.messageId, ...collection.data])];
-    }
-
-    pushToCache(cacheKey, collection);
-
-    responder(collection);
-  };
-
-  const onFetch = (initial = false) => {
-    const collection = pullFromCache<Amity.MessageLiveCollectionCache>(cacheKey)?.data;
-    const messages = collection?.data ?? [];
-
-    if (!initial && messages.length > 0 && !collection?.params?.paging?.next) return;
-
-    const query = createQuery(queryMessages, {
-      ...queryParams,
-      page: (!initial ? collection?.params.page : undefined) ?? { limit },
-      pageToken: collection?.params?.paging?.next,
-    });
-
-    runQuery(
-      query,
-      ({ data: result, error, loading, nextPage: page, paging }) => {
-        const data = {
-          loading,
-          error,
-          params: { page, paging },
-          data: messages,
-        };
-
-        if (result) {
-          data.data = [...new Set([...messages, ...result.map(getResolver('message'))])];
-        }
-
-        pushToCache(cacheKey, data);
-
-        responder(data);
-      },
-      queryOptions(policy, CACHE_SHORTEN_LIFESPAN),
-    );
-  };
-
-  disposers.push(
-    onMessageFetched(realtimeRouter('onFetch')),
-    onMessageCreated(realtimeRouter('onCreate')),
-    onMessageUpdated(realtimeRouter('onUpdate')),
-    onMessageDeleted(realtimeRouter('onDelete')),
-    onMessageFlagged(realtimeRouter('onFlagged')),
-    onMessageUnflagged(realtimeRouter('onUnflagged')),
-    onMessageFlagCleared(realtimeRouter('onFlagCleared')),
-    onMessageReactionAdded(realtimeRouter('onReactionAdded')),
-    onMessageReactionRemoved(realtimeRouter('onReactionRemoved')),
-    convertEventPayload(onMessageMarkerFetched, 'contentId', 'message')(realtimeRouter('onUpdate')),
-    convertEventPayload(onMessageMarked, 'contentId', 'message')(realtimeRouter('onUpdate')),
-  );
-
-  onFetch(true);
-  disposers.push(() => dropFromCache(cacheKey));
+  disposers.push(() => {
+    dropFromCache(cacheKey);
+  });
 
   return () => {
     log(`getMessages(tmpid: ${timestamp}) > dispose`);

package/src/messageRepository/observers/liveCollection/MessageLiveCollectionController.ts

@@ -0,0 +1,160 @@
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { MessagePaginationController } from './MessagePaginationController';
+import { MessageQueryStreamController } from './MessageQueryStreamController';
+import {
+  onMessageCreated,
+  onMessageDeleted,
+  onMessageFlagCleared,
+  onMessageFlagged,
+  onMessageReactionAdded,
+  onMessageReactionRemoved,
+  onMessageUnflagged,
+  onMessageUpdated,
+} from '~/messageRepository/events';
+import { convertEventPayload } from '~/utils/event';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import { onMessageMarked, onMessageMarkerFetched } from '~/marker/events';
+import { filterByPropEquality } from '~/core/query';
+import { prepareMessagePayload } from '~/messageRepository/utils';
+
+export class MessageLiveCollectionController extends LiveCollectionController<
+  'message',
+  Amity.MessagesLiveCollection,
+  Amity.Message,
+  MessagePaginationController
+> {
+  private queryStreamController: MessageQueryStreamController;
+
+  private query: Amity.MessagesLiveCollection;
+
+  constructor(
+    query: Amity.MessagesLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Message>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['message', 'collection', queryStreamId];
+    const paginationController = new MessagePaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new MessageQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareMessagePayload,
+      this.paginationController,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage(true);
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.MessageLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+      });
+    }
+  }
+
+  protected async persistModel(response: Amity.MessagePayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(response);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'message'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onMessageCreated, action: 'onCreate' },
+      { fn: onMessageDeleted, action: 'onDelete' },
+      { fn: onMessageUpdated, action: 'onUpdate' },
+      { fn: onMessageFlagged, action: 'onFlagged' },
+      { fn: onMessageUnflagged, action: 'onUnflagged' },
+      { fn: onMessageFlagCleared, action: 'onFlagCleared' },
+      { fn: onMessageReactionAdded, action: 'onReactionAdded' },
+      { fn: onMessageReactionRemoved, action: 'onReactionRemoved' },
+      {
+        fn: convertEventPayload(onMessageMarkerFetched, 'contentId', 'message'),
+        action: 'onUpdate',
+      },
+      { fn: convertEventPayload(onMessageMarked, 'contentId', 'message'), action: 'onUpdate' },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.MessageLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(messageId => pullFromCache<Amity.Message>(['message', 'get', messageId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [],
+    );
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      onNextPage: () => this.loadPage(false, Amity.LiveCollectionPageDirection.NEXT),
+      onPrevPage: () => this.loadPage(false, Amity.LiveCollectionPageDirection.PREV),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      hasPrevPage: !!this.paginationController.getPrevToken(),
+      loading,
+      error,
+    });
+  }
+
+  applyFilter(data: Amity.Message[]) {
+    let messages = data;
+
+    messages = messages.filter(m => {
+      if (this.query.tags) {
+        return this.query.tags.find(value => {
+          if (!m.tags) return false;
+          return m.tags.includes(value);
+        });
+      }
+      return true;
+    });
+
+    messages = messages.filter(m => {
+      if (this.query.excludeTags) {
+        return (this.query.excludeTags || []).find(value => {
+          if (!m.tags) return true;
+          return !m.tags.includes(value);
+        });
+      }
+      return true;
+    });
+
+    /*
+     * for cases when message is deleted via RTE, this flag is used to get
+     * items from cache that are !deleted
+     */
+    if (!this.query.includeDeleted) {
+      messages = filterByPropEquality(messages, 'isDeleted', false);
+    }
+
+    messages = messages.sort((message1, message2) => {
+      if (this.query.sortBy === 'segmentAsc') {
+        return message1.channelSegment - message2.channelSegment;
+      }
+      if (this.query.sortBy === 'segmentDesc') {
+        return message2.channelSegment - message1.channelSegment;
+      }
+      return 0;
+    });
+
+    return messages;
+  }
+}

package/src/messageRepository/observers/liveCollection/MessagePaginationController.ts

@@ -0,0 +1,33 @@
+/* eslint-disable no-use-before-define */
+
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { convertQueryParams } from '~/messageRepository/utils';
+
+/**
+ * TODO: handle cache receive cache option, and cache policy
+ * TODO: check if querybyIds is supported
+ */
+export class MessagePaginationController extends PaginationController<
+  'message',
+  Amity.MessagesLiveCollection
+> {
+  async getRequest(queryParams: Amity.MessagesLiveCollection, token: string | undefined) {
+    const processedQueryParams = convertQueryParams(queryParams);
+    const { data: queryResponse } = await this.http.get<Amity.MessagePayload & Amity.Pagination>(
+      `/api/v5/messages`,
+      {
+        params: {
+          ...processedQueryParams,
+          options: token
+            ? {
+                token,
+              }
+            : {
+                ...processedQueryParams.options,
+              },
+        },
+      },
+    );
+    return queryResponse;
+  }
+}