@amityco/ts-sdk-react-native 6.8.2-d546836.0 → 6.8.3-6df654f.0

package/dist/marker/events/onMessageMarked.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"onMessageMarked.d.ts","sourceRoot":"","sources":["../../../src/marker/events/onMessageMarked.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,aAChB,MAAM,QAAQ,CAAC,MAAM,aAAa,CAAC,KAC5C,MAAM,YAiDR,CAAC"}
+{"version":3,"file":"onMessageMarked.d.ts","sourceRoot":"","sources":["../../../src/marker/events/onMessageMarked.ts"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,eAAe,aAChB,MAAM,QAAQ,CAAC,MAAM,aAAa,CAAC,KAC5C,MAAM,YAwDR,CAAC"}

package/dist/messageRepository/observers/getMessages.d.ts

@@ -1,3 +1,4 @@
+export declare const applyFilter: <T extends Amity.Message<any>>(data: T[], params: Amity.MessagesLiveCollection) => T[];
 /**
  * ```js
  * import { getMessages } from '@amityco/ts-sdk-react-native';

package/dist/messageRepository/observers/getMessages.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getMessages.d.ts","sourceRoot":"","sources":["../../../src/messageRepository/observers/getMessages.ts"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,WAAW,WACd,MAAM,sBAAsB,YAC1B,MAAM,sBAAsB,CAAC,MAAM,OAAO,CAAC,WAC5C,MAAM,oBAAoB,KAClC,MAAM,YAkHR,CAAC"}
+{"version":3,"file":"getMessages.d.ts","sourceRoot":"","sources":["../../../src/messageRepository/observers/getMessages.ts"],"names":[],"mappings":"AAiCA,eAAO,MAAM,WAAW,oDAEd,MAAM,sBAAsB,QA2CrC,CAAC;AAKF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,WAAW,WACd,MAAM,sBAAsB,YAC1B,MAAM,sBAAsB,CAAC,MAAM,OAAO,CAAC,WAC5C,MAAM,oBAAoB,KAClC,MAAM,YA2HR,CAAC"}

package/dist/userRepository/observers/getUsers.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"getUsers.d.ts","sourceRoot":"","sources":["../../../src/userRepository/observers/getUsers.ts"],"names":[],"mappings":"AAkCA,eAAO,MAAM,WAAW,4CAEd,MAAM,kBAAkB,QAsBjC,CAAC;AAKF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,QAAQ,WACX,MAAM,kBAAkB,YACtB,MAAM,sBAAsB,CAAC,MAAM,IAAI,CAAC,WACzC,MAAM,oBAAoB,eAiGpC,CAAC"}
+{"version":3,"file":"getUsers.d.ts","sourceRoot":"","sources":["../../../src/userRepository/observers/getUsers.ts"],"names":[],"mappings":"AAmCA,eAAO,MAAM,WAAW,4CAEd,MAAM,kBAAkB,QAsBjC,CAAC;AAKF;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,QAAQ,WACX,MAAM,kBAAkB,YACtB,MAAM,sBAAsB,CAAC,MAAM,IAAI,CAAC,WACzC,MAAM,oBAAoB,eAiGpC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk-react-native",
-  "version": "6.8.2-d546836.0",
+  "version": "6.8.3-6df654f.0",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",

package/src/@types/domains/message.ts

@@ -66,6 +66,7 @@ declare global {
       deliveredCount: number;
       referenceId?: string;
     } & Amity.Content<T> &
+      Amity.Flaggable &
       Amity.Mentionable<'user' | 'channel'> &
       Amity.Metadata &
       Amity.Reactable &

package/src/client/api/login.ts

@@ -29,7 +29,11 @@ import { removeChannelMarkerCache } from '../utils/removeChannelMarkerCache';
  * than the one already connected, in which case the existing subscriptions need
  * to be cleared
  */
-const subscriptions: Amity.Unsubscriber[] = [];
+let subscriptions: Amity.Unsubscriber[] = [];
+
+async function runMqtt() {
+  await modifyMqttConnection();
+}
 
 /* begin_public_function
   id: client.login
@@ -74,6 +78,7 @@ export const login = async (
 
     // Remove subscription to ban and delete
     subscriptions.forEach(fn => fn());
+    subscriptions = [];
   }
 
   // default values
@@ -88,10 +93,7 @@ export const login = async (
     // wire websocket events to our event emitter
     proxyWebsocketEvents(client.ws, client.emitter);
 
-    // TODO: in phase 2, this should not be necessary. we should have WS
-    // to be connected "on demand" rather than "by default"
-    await new Promise(resolve => {
-      client.ws.once('connect', resolve);
+    client.ws.once('connect', () => {
       client.ws.open();
     });
 
@@ -122,54 +124,56 @@ export const login = async (
   }
 
   if (config?.disableRTE !== true) {
-    await modifyMqttConnection();
+    runMqtt();
   }
 
-  subscriptions.push(
-    // GLOBAL_BAN
-    onClientBanned((_: Amity.UserPayload) => {
-      terminateClient(Amity.TokenTerminationReason.GLOBAL_BAN);
+  if (subscriptions.length === 0) {
+    subscriptions.push(
+      // GLOBAL_BAN
+      onClientBanned((_: Amity.UserPayload) => {
+        terminateClient(Amity.TokenTerminationReason.GLOBAL_BAN);
 
-      subscriptions.forEach(fn => fn());
+        subscriptions.forEach(fn => fn());
 
-      unsubWatcher();
-    }),
+        unsubWatcher();
+      }),
 
-    onTokenTerminated(_ => {
-      terminateClient();
+      onTokenTerminated(_ => {
+        terminateClient();
 
-      subscriptions.forEach(fn => fn());
+        subscriptions.forEach(fn => fn());
 
-      unsubWatcher();
-    }),
+        unsubWatcher();
+      }),
 
-    onUserDeleted((user: Amity.User) => {
-      if (user.userId === client.userId) {
-        terminateClient(Amity.TokenTerminationReason.USER_DELETED);
+      onUserDeleted((user: Amity.User) => {
+        if (user.userId === client.userId) {
+          terminateClient(Amity.TokenTerminationReason.USER_DELETED);
 
-        subscriptions.forEach(fn => fn());
+          subscriptions.forEach(fn => fn());
 
-        unsubWatcher();
-      }
-    }),
+          unsubWatcher();
+        }
+      }),
 
-    onTokenExpired(state => {
-      setSessionState(state);
+      onTokenExpired(state => {
+        setSessionState(state);
 
-      logout();
+        logout();
 
-      subscriptions.forEach(fn => fn());
-    }),
+        subscriptions.forEach(fn => fn());
+      }),
 
-    // NOTE: This is a temporary solution to handle the channel marker when the user is forced to leave
-    // the channel because currently backend can't handle this, so every time a user is banned from
-    // a channel or the channel is deleted the channel's unread count will not be reset to zero
-    onChannelDeleted(removeChannelMarkerCache),
-    onChannelMemberBanned(removeChannelMarkerCache),
+      // NOTE: This is a temporary solution to handle the channel marker when the user is forced to leave
+      // the channel because currently backend can't handle this, so every time a user is banned from
+      // a channel or the channel is deleted the channel's unread count will not be reset to zero
+      onChannelDeleted(removeChannelMarkerCache),
+      onChannelMemberBanned(removeChannelMarkerCache),
 
-    markReadEngineOnLoginHandler(),
-  );
+      markReadEngineOnLoginHandler(),
+    );
+  }
 
-  return client.ws.connected;
+  return true;
 };
 /* end_public_function */

package/src/commentRepository/observers/getComments.ts

@@ -109,9 +109,11 @@ export const getComments = (
     if (
       params.referenceId !== comment.referenceId ||
       params.referenceType !== comment.referenceType ||
+      params.parentId !== comment.parentId ||
       !collection
-    )
+    ) {
       return;
+    }
 
     if (action === 'onCreate') {
       collection.data = [...new Set([comment.commentId, ...collection.data])];

package/src/index.ts

@@ -43,6 +43,3 @@ export * as PollRepository from './pollRepository';
 
 // // external apis
 export * from './external/api';
-
-// Token and MQTTClientID
-export * from './core/device';

package/src/marker/events/onMessageMarked.ts

@@ -28,32 +28,39 @@ export const onMessageMarked = (
     ingestInCache(payload);
 
     const cacheCollection = queryCache<Amity.MessageLiveCollectionCache>(['message', 'collection']);
+    const { contentMarkers, feedMarkers } = payload;
 
-    if (cacheCollection && cacheCollection?.length > 0) {
-      const contentMarker = payload.contentMarkers[0];
+    if (cacheCollection && cacheCollection?.length > 0 && feedMarkers?.length > 0) {
+      /**
+       * in case of read the message collection,
+       * use feedId of the feedMarkers to check if it equal to subChannelId.
+       */
       const currentMessageCollection = cacheCollection.filter(currentMessage => {
-        if (!isObject(currentMessage.key[2])) return false;
-        return currentMessage.key[2].subChannelId === contentMarker.feedId;
+        const cacheKey = currentMessage.key;
+        if (!isObject(cacheKey[2])) return false;
+
+        const queryParams = cacheKey[2] as Amity.MessagesLiveCollection;
+        return queryParams.subChannelId === feedMarkers[0].feedId;
       });
 
-      if (currentMessageCollection.length > 0) {
+      if (currentMessageCollection.length > 0 && contentMarkers?.length > 0) {
         const currentMessages =
           currentMessageCollection[0].data?.data?.map(messageId => {
             return pullFromCache<Amity.Message>(['message', 'get', messageId]);
           }) || [];
 
         currentMessages.forEach(message => {
-          const isSameSubChannelId = contentMarker.feedId === message?.data.subChannelId;
-          const isReadCountLatest = contentMarker.readCount > message?.data.readCount!;
+          const isSameSubChannelId = contentMarkers[0].feedId === message?.data.subChannelId;
+          const isReadCountLatest = contentMarkers[0].readCount > message?.data.readCount!;
           const isDeliveredCountLatest =
-            contentMarker.deliveredCount > message?.data.deliveredCount!;
+            contentMarkers[0]?.deliveredCount > message?.data.deliveredCount!;
 
           if (isSameSubChannelId) {
             pushToCache(['message', 'get', message.data.messageId], {
               ...message.data,
-              readCount: isReadCountLatest ? contentMarker.readCount : message?.data.readCount!,
+              readCount: isReadCountLatest ? contentMarkers[0].readCount : message?.data.readCount!,
               deliveredCount: isDeliveredCountLatest
-                ? contentMarker.deliveredCount
+                ? contentMarkers[0].deliveredCount
                 : message?.data.deliveredCount!,
             });
           }

package/src/messageRepository/observers/getMessages.ts

@@ -27,6 +27,57 @@ import {
 import { onMessageFetched } from '../events/onMessageFetched';
 import { queryMessages } from '../api/queryMessages';
 
+/*
+ * Exported for testing
+ * @hidden
+ */
+export const applyFilter = <T extends Amity.Message>(
+  data: T[],
+  params: Amity.MessagesLiveCollection,
+): T[] => {
+  let messages = data;
+
+  messages = messages.filter(m => {
+    if (params.tags) {
+      return params.tags.find(value => {
+        if (!m.tags) return false;
+        return m.tags.includes(value);
+      });
+    }
+    return true;
+  });
+
+  messages = messages.filter(m => {
+    if (params.excludeTags) {
+      return (params.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 (!params.includeDeleted) {
+    messages = filterByPropEquality(messages, 'isDeleted', false);
+  }
+
+  messages = messages.sort((message1, message2) => {
+    if (params.sortBy === 'segmentAsc') {
+      return message1.channelSegment - message2.channelSegment;
+    }
+    if (params.sortBy === 'segmentDesc') {
+      return message2.channelSegment - message1.channelSegment;
+    }
+    return 0;
+  });
+
+  return messages;
+};
+
 /* begin_public_function
   id: message.query
 */
@@ -69,29 +120,17 @@ export const getMessages = (
   const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
 
   const disposers: Amity.Unsubscriber[] = [];
-  const cacheKey = ['message', 'collection', params, uuid()];
+  const uniqueId = uuid();
+  const cacheKey = ['message', 'collection', params, uniqueId];
 
   const responder = (data: Amity.MessageLiveCollectionCache) => {
-    let messages: Amity.Message[] =
+    const messages: Amity.Message[] = applyFilter(
       data.data
         .map(messageId => pullFromCache<Amity.Message>(['message', 'get', messageId])!)
         .filter(Boolean)
-        .filter(item => {
-          if (!params.tags) return true;
-          return params.tags.find(value => {
-            if (!item.data?.tags) return false;
-            return item.data.tags.includes(value);
-          });
-        })
-        .map(({ data }) => data) ?? [];
-
-    /*
-     * for cases when message is deleted via RTE, this flag is used to get
-     * items from cache that are !deleted
-     */
-    if (!params.includeDeleted) {
-      messages = filterByPropEquality(messages, 'isDeleted', false);
-    }
+        .map(({ data }) => data) ?? [],
+      params,
+    );
 
     callback({
       onNextPage: onFetch,
@@ -107,6 +146,28 @@ export const getMessages = (
 
     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);
@@ -114,7 +175,6 @@ export const getMessages = (
 
   const onFetch = (initial = false) => {
     const collection = pullFromCache<Amity.MessageLiveCollectionCache>(cacheKey)?.data;
-
     const messages = collection?.data ?? [];
 
     if (!initial && messages.length > 0 && !collection?.params?.page) return;

package/src/userRepository/observers/getUsers.ts

@@ -2,6 +2,7 @@
 import { getResolver } from '~/core/model';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
+import { uuid } from '~/core/uuid';
 
 import {
   createQuery,
@@ -98,7 +99,7 @@ export const getUsers = (
   const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
 
   const disposers: Amity.Unsubscriber[] = [];
-  const cacheKey = ['user', 'collection', queryParams as Amity.Serializable];
+  const cacheKey = ['user', 'collection', uuid()];
 
   const responder = (data: Amity.UserLiveCollectionCache, isEventModel = false) => {
     const users: Amity.User[] =

package/src/userRepository/observers/tests/getUsers.test.ts

@@ -59,7 +59,11 @@ describe('getUsers', () => {
     );
   });
 
-  test('it should return data from cache', async () => {
+  test.skip('it should return data from cache', async () => {
+    /**
+     * skip this unit test because the behaviour is changed.
+     * when calling getUsers(), it will create a new instance of the user collection.
+     */
     const callback = jest.fn();
     client.http.get = jest.fn().mockResolvedValue(userQueryResponse);