@amityco/ts-sdk 6.12.2-d8fe0d5.0 → 6.12.2-e1d8270.0

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

@@ -0,0 +1,162 @@
+/* eslint-disable no-use-before-define */
+
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { MessagePaginationController } from './MessagePaginationController';
+import { MessageQueryStreamController } from './MessageQueryStreamController';
+import { uuid } from '~/core/uuid';
+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';
+
+export class MessageLiveCollectionController extends LiveCollectionController<
+  MessagePaginationController,
+  Amity.LiveCollectionCallback<Amity.Message>,
+  Amity.Message
+> {
+  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, cacheKey);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new MessageQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage(true);
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.MessageLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.MessagePayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream(
+    queryPayload: Amity.MessagePayload & Amity.Pagination,
+    direction: Amity.LoadingDirection,
+    refresh?: boolean,
+  ) {
+    this.queryStreamController.appendToQueryStream(queryPayload, 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(loading: boolean, error?: any) {
+    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 (!loading && !error && !this.shouldNotify(loading, data)) return;
+
+    this.callback({
+      onNextPage: () => this.loadNextPage(),
+      onPrevPage: () => this.loadPrevPage(),
+      data,
+      hasNextPage: !!collection.params?.page?.after,
+      hasPrevPage: !!collection.params?.page?.before,
+      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,42 @@
+/* eslint-disable no-use-before-define */
+
+import { PaginationController } from '~/core/liveCollection/PaginationController';
+import { toToken } from '~/core/query';
+import { convertQueryParams } from '~/messageRepository/utils';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+/**
+ * TODO: handle cache receive cache option, and cache policy
+ * TODO: check if querybyIds is supported
+ */
+export class MessagePaginationController extends PaginationController<
+  Amity.MessagePayload & Amity.Pagination,
+  Amity.MessagesLiveCollection
+> {
+  // eslint-disable-next-line no-useless-constructor
+  constructor(queryParams: Amity.MessagesLiveCollection, cacheKey: string[]) {
+    super(queryParams, cacheKey);
+  }
+
+  async getRequest(queryParams: Amity.MessagesLiveCollection, token: string | undefined) {
+    const { limit, aroundMessageId, ...params } = queryParams;
+    const processedQueryParams = convertQueryParams(params);
+    const { data: queryResponse } = await this.http.get<Amity.MessagePayload & Amity.Pagination>(
+      `/api/v5/messages`,
+      {
+        params: {
+          ...processedQueryParams,
+          options: token
+            ? {
+                token,
+              }
+            : {
+                limit,
+                around: aroundMessageId,
+              },
+        },
+      },
+    );
+    return queryResponse;
+  }
+}

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

@@ -0,0 +1,129 @@
+/* eslint-disable no-use-before-define */
+import { QueryStreamController } from '../../../core/liveCollection/QueryStreamController';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { prepareMessagePayload } from '~/messageRepository/utils';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+import { toPage } from '~/core/query';
+import { getActiveClient } from '~/client';
+
+export class MessageQueryStreamController extends QueryStreamController<
+  Amity.MessagePayload,
+  Amity.MessagesLiveCollection
+> {
+  private notifyChange: (loading: boolean, error?: any) => void;
+
+  // private fetchMessageMarker: (response: Amity.MessagePayload) => Promise<void>;
+
+  constructor(
+    query: Amity.MessagesLiveCollection,
+    cacheKey: string[],
+    notifyChange: (loading: boolean, error?: any) => void,
+  ) {
+    super(query, cacheKey);
+    this.notifyChange = notifyChange;
+  }
+
+  // eslint-disable-next-line class-methods-use-this
+  async saveToMainDB(response: Amity.MessagePayload) {
+    const processedPayload = await prepareMessagePayload(response);
+
+    const client = getActiveClient();
+    const cachedAt = client.cache && Date.now();
+
+    if (client.cache) {
+      ingestInCache(processedPayload, { cachedAt });
+    }
+  }
+
+  appendToQueryStream(
+    response: Amity.MessagePayload & Amity.Pagination,
+    direction: Amity.LoadingDirection,
+    refresh = false,
+  ) {
+    if (refresh) {
+      pushToCache(this.cacheKey, {
+        data: response.messages.map(getResolver('message')),
+        params: {
+          page: {
+            after: toPage(response.paging?.next),
+            before: toPage(response.paging?.previous),
+          },
+        },
+      });
+    } else {
+      const collection = pullFromCache<Amity.MessageLiveCollectionCache>(this.cacheKey)?.data;
+
+      const messages = collection?.data ?? [];
+
+      pushToCache(this.cacheKey, {
+        ...collection,
+        data:
+          direction === 'next'
+            ? [...new Set([...messages, ...response.messages.map(getResolver('message'))])]
+            : [...new Set([...response.messages.map(getResolver('message')), ...messages])],
+        params: {
+          page: {
+            before: toPage(response.paging?.previous),
+            after: toPage(response.paging?.next),
+          },
+        },
+      });
+    }
+  }
+
+  reactor(action: string) {
+    return (payload: Amity.Message) => {
+      if (action === 'onCreate') {
+        const collection = pullFromCache<Amity.MessageLiveCollectionCache>(this.cacheKey)?.data;
+
+        if (!collection) return;
+        if (this.query.subChannelId !== payload?.subChannelId || !collection) return;
+
+        if (this.query.dataType && this.query.dataType !== payload.dataType) return;
+        if (
+          this.query.excludeTags &&
+          this.query.excludeTags?.some(value => payload.tags?.includes(value))
+        )
+          return;
+        if (!!this.query.hasFlags !== !!payload.flagCount) return;
+
+        if (this.query.parentId && this.query.parentId !== payload.parentId) return;
+
+        if (
+          this.query.hasOwnProperty('includeDeleted') &&
+          !this.query.includeDeleted &&
+          payload.isDeleted
+        )
+          return;
+
+        if (this.query.tags && !this.query.tags?.some(value => payload.tags?.includes(value)))
+          return;
+
+        if (
+          (!this.query.sortBy || this.query.sortBy === 'segmentDesc') &&
+          !collection.params.page?.before
+        ) {
+          collection.data = [...new Set([payload.messageId, ...collection.data])];
+        }
+
+        if (this.query.sortBy === 'segmentAsc' && !collection.params.page?.after) {
+          collection.data = [...new Set([...collection.data, payload.messageId])];
+        }
+
+        pushToCache(this.cacheKey, collection);
+      }
+
+      this.notifyChange(false);
+    };
+  }
+
+  subscribeRTE(
+    createSubscriber: {
+      fn: (reactor: Amity.Listener<Amity.Message>) => Amity.Unsubscriber;
+      action: string;
+    }[],
+  ) {
+    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
+  }
+}

package/src/messageRepository/observers/tests/getMessages.test.ts

@@ -71,11 +71,12 @@ describe('getMessages', () => {
     });
 
     getMessages({ subChannelId }, callback);
+    await pause();
 
-    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledTimes(2);
 
-    // check if cache data returned (should be empty)
-    expect(callback).toHaveBeenCalledWith(
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
       expect.objectContaining({
         data: [],
         error: undefined,
@@ -83,11 +84,8 @@ describe('getMessages', () => {
       }),
     );
 
-    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-
-    expect(callback).toHaveBeenCalledWith(
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
       expect.objectContaining({
         data: returnValue.map(convertRawMessage),
         error: undefined,
@@ -108,8 +106,9 @@ describe('getMessages', () => {
     client.http.get = jest.fn().mockRejectedValue(error);
 
     getMessages({ subChannelId }, callback);
+    await pause();
 
-    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledTimes(2);
 
     // check if cache data returned (should be empty)
     expect(callback).toHaveBeenCalledWith(
@@ -150,11 +149,16 @@ describe('getMessages', () => {
     });
 
     getMessages({ subChannelId, includeDeleted: false }, callback);
+    await pause();
 
-    expect(callback).toHaveBeenCalledTimes(1);
+    // not use queryMessages anymore
+    // await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
 
     // check if cache data returned (should be empty)
-    expect(callback).toHaveBeenCalledWith(
+    expect(callback).toHaveBeenNthCalledWith(
+      1,
       expect.objectContaining({
         data: [],
         error: undefined,
@@ -162,11 +166,8 @@ describe('getMessages', () => {
       }),
     );
 
-    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-
-    expect(callback).toHaveBeenCalledWith(
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
       expect.objectContaining({
         // @ts-ignore
         data: [returnValue[1]].map(convertRawMessage),
@@ -202,10 +203,11 @@ describe('getMessages', () => {
       });
 
     getMessages({ subChannelId, includeDeleted: true }, callback);
+    await pause();
 
     expect(callback).toHaveBeenCalled();
 
-    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+    // await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
 
     expect(callback.mock.lastCall).toHaveLength(1);
 
@@ -215,8 +217,9 @@ describe('getMessages', () => {
     expect(onNextPage).toBeTruthy();
 
     onNextPage();
+    await pause();
 
-    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+    // await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
 
     // 4 -> becuase 1 local & server call each per call (2)
     expect(callback).toHaveBeenCalledTimes(4);
@@ -232,7 +235,8 @@ describe('getMessages', () => {
     );
   });
 
-  test('it should add new message to collection onFetch', async () => {
+  // skip this test for now because onFecth should not add a new message to the collection
+  test.skip('it should add new message to collection onFetch', async () => {
     const callback = jest.fn();
     client.http.get = jest.fn().mockResolvedValue({
       data: {
@@ -242,8 +246,9 @@ describe('getMessages', () => {
     });
 
     getMessages({ subChannelId }, callback);
+    await pause();
 
-    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+    // await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
     expect(callback).toHaveBeenCalledTimes(2);
 
     client.emitter.emit('local.message.fetched', { messages: [message] });
@@ -275,8 +280,9 @@ describe('getMessages', () => {
     });
 
     getMessages({ subChannelId }, callback);
+    await pause();
 
-    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+    // await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
     expect(callback).toHaveBeenCalledTimes(2);
 
     // fire new message creation event
@@ -312,8 +318,9 @@ describe('getMessages', () => {
     });
 
     getMessages({ subChannelId }, callback);
+    await pause();
 
-    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+    // await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
     expect(callback).toHaveBeenCalledTimes(2);
 
     // fire new message creation event
@@ -345,14 +352,15 @@ describe('getMessages', () => {
       },
     });
 
-    getMessages({ subChannelId }, callback);
+    getMessages({ subChannelId, includeDeleted: true }, callback);
+    await pause();
 
-    await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
+    // await expect(queryMessages({ subChannelId })).resolves.toBeTruthy();
     expect(callback).toHaveBeenCalledTimes(2);
 
-    // fire new message creation event
+    // fire new message deletion event
     client.emitter.emit('message.deleted', {
-      messages: [rawMessage],
+      messages: [{ ...rawMessage, isDeleted: true }],
       messageFeeds: [],
       users: [],
       files: [],
@@ -364,7 +372,7 @@ describe('getMessages', () => {
     expect(callback).toHaveBeenNthCalledWith(
       3,
       expect.objectContaining({
-        data: [message],
+        data: [{ ...message, isDeleted: true }],
         error: undefined,
         loading: false,
       }),

package/src/messageRepository/utils/prepareMessagePayload.ts

@@ -137,7 +137,7 @@ type RawQueryMessages = Omit<
   /*
    * include deleted is for internal sdk use only. The server expects isDeleted
    */
-  'page' | 'sortBy' | 'subChannelId' | 'tags' | 'includeDeleted'
+  'page' | 'sortBy' | 'subChannelId' | 'tags' | 'includeDeleted' | 'aroundMessageId'
 > & {
   includeTags?: Amity.QueryMessages['tags'];
   isDeleted?: Amity.Message['isDeleted'];
@@ -178,6 +178,7 @@ export function convertQueryParams({
   includeDeleted,
   ...rest
 }: Amity.QueryMessages): RawQueryMessages {
+  console.log('convertQueryParams', page);
   const out: RawQueryMessages = {
     ...rest,
     messageFeedId: subChannelId,
@@ -192,6 +193,6 @@ export function convertQueryParams({
   if (tags) {
     out.includeTags = tags;
   }
-
+  console.log('out', out);
   return out;
 }

package/src/utils/isEqual.ts

@@ -41,6 +41,19 @@ export function isEqual(x: any, y: any): boolean {
     return false;
   }
 
+  // check each element of the array for equality
+  if (Array.isArray(x) && Array.isArray(y)) {
+    if (x.length !== y.length) return false;
+
+    // eslint-disable-next-line no-plusplus
+    for (let i = 0; i < x.length; i++) {
+      if (!isEqual(x[i], y[i])) return false;
+    }
+
+    // if all elements are equal, the arrays are equal
+    return true;
+  }
+
   // if they are dates, they must had equal valueOf
   if (x instanceof Date) {
     return false;