@amityco/ts-sdk 6.18.1-c018952.0 → 6.19.0

package/src/channelRepository/observers/observeChannel.ts

@@ -56,25 +56,38 @@ export const observeChannel = <Events extends [Exclude<Amity.ChannelActionType,
   const disposers: Amity.Unsubscriber[] = [];
 
   disposers.push(
-    onChannelUpdated(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
-    onChannelDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')),
-    onChannelJoined(data => router({ data, loading: false, origin: 'event' }, 'onJoin')),
-    onChannelLeft(data => router({ data, loading: false, origin: 'event' }, 'onLeft')),
-    onChannelMuted(data => router({ data, loading: false, origin: 'event' }, 'onMute')),
+    onChannelUpdated(data =>
+      router({ data, loading: false, origin: 'event' }, Amity.ChannelActionType.OnUpdate),
+    ),
+    onChannelDeleted(data =>
+      router({ data, loading: false, origin: 'event' }, Amity.ChannelActionType.OnDelete),
+    ),
+    onChannelJoined(data =>
+      router({ data, loading: false, origin: 'event' }, Amity.ChannelActionType.OnJoin),
+    ),
+    onChannelLeft(data =>
+      router({ data, loading: false, origin: 'event' }, Amity.ChannelActionType.OnLeft),
+    ),
+    onChannelMuted(data =>
+      router({ data, loading: false, origin: 'event' }, Amity.ChannelActionType.OnMute),
+    ),
     onChannelMemberAdded(data =>
-      router({ data, loading: false, origin: 'event' }, 'onMemberAdded'),
+      router({ data, loading: false, origin: 'event' }, Amity.ChannelActionType.OnMemberAdded),
     ),
     onChannelMemberRemoved(data =>
-      router({ data, loading: false, origin: 'event' }, 'onMemberRemoved'),
+      router({ data, loading: false, origin: 'event' }, Amity.ChannelActionType.OnMemberRemoved),
     ),
     convertEventPayload(
       onChannelMarkerFetched,
       'entityId',
       'channel',
-    )(data => router({ data, loading: false, origin: 'event' }, 'onUpdate')),
+    )(data => router({ data, loading: false, origin: 'event' }, Amity.ChannelActionType.OnUpdate)),
   );
 
-  runQuery(createQuery(getChannel, channelId), result => result.data && router(result, 'onFetch'));
+  runQuery(
+    createQuery(getChannel, channelId),
+    result => result.data && router(result, Amity.ChannelActionType.OnFetch),
+  );
 
   return () => {
     log(`observeChannel(tmpid: ${timestamp}) > dispose`);

package/src/channelRepository/observers/observeChannels.ts

@@ -46,19 +46,19 @@ export const observeChannels = (
   };
 
   disposers.push(
-    onChannelCreated(data => router(data, 'onCreate')),
-    onChannelUpdated(data => router(data, 'onUpdate')),
-    onChannelDeleted(data => router(data, 'onDelete')),
-    onChannelJoined(data => router(data, 'onJoin')),
-    onChannelLeft(data => router(data, 'onLeft')),
-    onChannelMuted(data => router(data, 'onMute')),
-    onChannelMemberAdded(data => router(data, 'onMemberAdded')),
-    onChannelMemberRemoved(data => router(data, 'onMemberRemoved')),
+    onChannelCreated(data => router(data, Amity.ChannelActionType.OnCreate)),
+    onChannelUpdated(data => router(data, Amity.ChannelActionType.OnUpdate)),
+    onChannelDeleted(data => router(data, Amity.ChannelActionType.OnDelete)),
+    onChannelJoined(data => router(data, Amity.ChannelActionType.OnJoin)),
+    onChannelLeft(data => router(data, Amity.ChannelActionType.OnLeft)),
+    onChannelMuted(data => router(data, Amity.ChannelActionType.OnMute)),
+    onChannelMemberAdded(data => router(data, Amity.ChannelActionType.OnMemberAdded)),
+    onChannelMemberRemoved(data => router(data, Amity.ChannelActionType.OnMemberRemoved)),
     convertEventPayload(
       onChannelMarkerFetched,
       'entityId',
       'channel',
-    )(data => router(data, 'onUpdate')),
+    )(data => router(data, Amity.ChannelActionType.OnUpdate)),
   );
 
   return () => {

package/src/channelRepository/utils/prepareChannelPayload.ts

@@ -68,19 +68,6 @@ export const prepareChannelPayload = async (
   const client = getActiveClient();
   const networkPreviewSetting = await client.getMessagePreviewSetting(false);
 
-  // if consistent mode is enabled, persist the unread count info to the cache
-  if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
-    const queryPayload = await getUserMessageFeedMakers(
-      rawPayload.channels.map(({ channelId }) => channelId),
-    );
-
-    const { feedMarkers, userFeedMarkers } = queryPayload;
-    persistUnreadCountInfo({
-      feedMarkers,
-      userFeedMarkers,
-    });
-  }
-
   if (
     options.isMessagePreviewUpdated &&
     networkPreviewSetting !== Amity.MessagePreviewSetting.NO_MESSAGE_PREVIEW &&

package/src/channelRepository/utils/prepateUnreadCountInfo.ts

@@ -0,0 +1,20 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { getUserMessageFeedMakers } from '~/marker/api/getUserMessageFeedMarkers';
+import { persistUnreadCountInfo } from '~/marker/utils/persistUnreadCountInfo';
+
+export const prepareUnreadCountInfo = async (rawPayload: Amity.ChannelPayload) => {
+  const client = getActiveClient();
+  // if consistent mode is enabled, persist the unread count info to the cache
+
+  const queryPayload = await getUserMessageFeedMakers(
+    rawPayload.channels.map(({ channelId }) => channelId),
+  );
+
+  const { feedMarkers, userFeedMarkers } = queryPayload;
+  persistUnreadCountInfo({
+    feedMarkers,
+    userFeedMarkers,
+  });
+
+  client.log('channel/prepareUnreadCountInfo', rawPayload.channels);
+};

package/src/channelRepository/utils/resolveUnreadInfoOnChannelEvent.ts

@@ -0,0 +1,15 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import ObjectResolverEngine from '~/client/utils/ObjectResolver/objectResolverEngine';
+
+export const resolveUnreadInfoOnChannelEvent = (
+  channel: Amity.InternalChannel,
+  callback: Amity.Listener<Amity.InternalChannel>,
+) => {
+  const client = getActiveClient();
+
+  if (client.isUnreadCountEnabled && client.getMarkerSyncConsistentMode()) {
+    const objectResolverEngine = ObjectResolverEngine.getInstance();
+
+    objectResolverEngine.resolve(channel.channelId, Amity.ReferenceType.USER_MESSAGE_FEED_MARKER);
+  } else callback(channel);
+};

package/src/channelRepository/utils/tests/prepareChannelPayload.test.ts

@@ -60,9 +60,9 @@ const convertedChannelPayload: Amity.ProcessedChannelPayload = {
       isUnreadCountSupport: true,
       unreadCount: channelMarker1.unreadCount,
       hasMentioned: channelMarker1.hasMentioned,
+      isMentioned: channelMarker1.hasMentioned,
       messagePreviewId: undefined,
       subChannelsUnreadCount: channelMarker1.unreadCount,
-      isMentioned: channelMarker1.hasMentioned,
     },
     {
       ...liveChannel,
@@ -70,9 +70,9 @@ const convertedChannelPayload: Amity.ProcessedChannelPayload = {
       isUnreadCountSupport: false,
       unreadCount: 0,
       hasMentioned: false,
+      isMentioned: false,
       messagePreviewId: undefined,
       subChannelsUnreadCount: 0,
-      isMentioned: false,
     },
     {
       ...conversationChannel,

package/src/client/api/login.ts

@@ -10,7 +10,8 @@ import { markReadEngineOnLoginHandler } from '~/subChannelRepository/utils/markR
 import { onUserDeleted } from '~/userRepository/events/onUserDeleted';
 
 import analyticsEngineOnLoginHandler from '~/analytic/utils/analyticsEngineOnLoginHandler';
-import readReceiptSyncEngineOnLoginHandler from '../utils/ReadReceiptSync/readReceiptSyncEngineOnLoginHandler';
+import readReceiptSyncEngineOnLoginHandler from '~/client/utils/ReadReceiptSync/readReceiptSyncEngineOnLoginHandler';
+import objectResolverEngineOnLoginHandler from '~/client/utils/ObjectResolver/objectResolverEngineOnLoginHandler';
 import { logout } from './logout';
 
 import { getActiveClient } from './activeClient';
@@ -198,6 +199,7 @@ export const login = async (
       markReadEngineOnLoginHandler(),
       analyticsEngineOnLoginHandler(),
       readReceiptSyncEngineOnLoginHandler(),
+      objectResolverEngineOnLoginHandler(),
     );
 
     const markerSyncUnsubscriber = await startMarkerSync();

package/src/client/utils/ObjectResolver/objectResolverEngine.ts

@@ -0,0 +1,143 @@
+import { onOnline } from '../onOnline';
+import { getChannelByIds } from '~/channelRepository/api/getChannelByIds';
+
+import { onOffline } from '../onOffline';
+import { getUserMessageFeedMakers } from '~/marker/api/getUserMessageFeedMarkers';
+import { SECOND } from '~/utils/constants';
+
+class ObjectResolverEngine {
+  private readonly TIMER_INTERVAL_MS = SECOND;
+
+  private readonly BUFFER_ID_LIMIT = 100;
+
+  private buffer: Amity.ObjectIdBuffer = {
+    [Amity.ReferenceType.CHANNEL]: [],
+    [Amity.ReferenceType.USER_MESSAGE_FEED_MARKER]: [],
+  };
+
+  private timer: NodeJS.Timer | undefined;
+
+  private isResolvingTask = false;
+
+  private connectionListener: (() => void)[] = [];
+
+  private isConnected = true;
+
+  constructor() {
+    this.addConnectionListener();
+  }
+
+  startResolver() {
+    if (!this.timer) {
+      this.timer = setInterval(() => {
+        if (this.isConnected) this.resolveObjects();
+      }, this.TIMER_INTERVAL_MS);
+    }
+  }
+
+  stopResolver() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = undefined;
+    }
+  }
+
+  resolve(id: string, referenceType: Amity.ReferenceType) {
+    const objectIdList = this.getBuffer(referenceType);
+
+    if (objectIdList.includes(id)) return;
+
+    if (objectIdList.length >= this.BUFFER_ID_LIMIT) {
+      objectIdList.shift(); // Remove first element of the array
+    }
+
+    objectIdList.push(id);
+  }
+
+  private addConnectionListener() {
+    if (this.connectionListener.length > 0) return;
+    this.connectionListener.push(
+      onOnline(() => {
+        this.isConnected = true;
+      }),
+    );
+
+    this.connectionListener.push(
+      onOffline(() => {
+        this.isConnected = false;
+      }),
+    );
+  }
+
+  private removeConnectionListener() {
+    if (this.connectionListener.length > 0) this.connectionListener.forEach(listener => listener());
+  }
+
+  private resolveObjects() {
+    if (this.isResolvingTask) {
+      return;
+    }
+
+    this.isResolvingTask = true;
+
+    // Get first 100 ids for all reference type supported.
+    const channelIds = this.getBuffer(Amity.ReferenceType.CHANNEL);
+    const userMessageFeedMarkerIds = this.getBuffer(Amity.ReferenceType.USER_MESSAGE_FEED_MARKER);
+
+    // Clear buffer
+    this.clearBuffer();
+
+    // Send Requests.
+    // Incase of failure: Ignore
+    // Incase of success: Persist in Domain DB & Notify Live collection
+    if (channelIds.length > 0) getChannelByIds(channelIds);
+    if (userMessageFeedMarkerIds.length > 0) getUserMessageFeedMakers(userMessageFeedMarkerIds);
+
+    // After sending request
+    this.isResolvingTask = false;
+  }
+
+  private clearBuffer() {
+    this.buffer = {
+      [Amity.ReferenceType.CHANNEL]: [],
+      [Amity.ReferenceType.USER_MESSAGE_FEED_MARKER]: [],
+    };
+  }
+
+  private getBuffer(referenceType: Amity.ReferenceType) {
+    return this.buffer[referenceType];
+  }
+
+  // Session Management : SessionComponent
+  onSessionEstablished() {
+    this.startResolver();
+    this.addConnectionListener();
+  }
+
+  onSessionDestroyed() {
+    // Stop timer
+    this.stopResolver();
+
+    // Clear buffer
+    this.clearBuffer();
+
+    // Reset state
+    this.isResolvingTask = false;
+
+    // remove connection listener
+    this.removeConnectionListener();
+  }
+
+  onTokenExpired() {
+    this.stopResolver();
+  }
+}
+
+let instance: ObjectResolverEngine | null = null;
+
+export default {
+  getInstance: () => {
+    if (!instance) instance = new ObjectResolverEngine();
+    return instance;
+  },
+};

package/src/client/utils/ObjectResolver/objectResolverEngineOnLoginHandler.ts

@@ -0,0 +1,21 @@
+import { onSessionStateChange } from '~/client/events/onSessionStateChange';
+import ObjectResolverEngine from './objectResolverEngine';
+
+export default () => {
+  const objectResolverEngine = ObjectResolverEngine.getInstance();
+  objectResolverEngine.startResolver();
+
+  onSessionStateChange(state => {
+    if (state === Amity.SessionStates.ESTABLISHED) {
+      objectResolverEngine.onSessionEstablished();
+    } else if (state === Amity.SessionStates.TOKEN_EXPIRED) {
+      objectResolverEngine.onTokenExpired();
+    } else {
+      objectResolverEngine.onSessionDestroyed();
+    }
+  });
+
+  return () => {
+    objectResolverEngine.onSessionDestroyed();
+  };
+};

package/src/client/utils/onOffline.ts

@@ -0,0 +1,15 @@
+export const onOffline = (callback: () => void) => {
+  if (typeof window !== 'undefined' && window.addEventListener) {
+    window.addEventListener('offline', callback);
+    return () => window.removeEventListener('offline', callback);
+  }
+
+  if (typeof document !== 'undefined' && document.addEventListener) {
+    document.addEventListener('offline', callback);
+    return () => document.removeEventListener('offline', callback);
+  }
+
+  // Handle unsupported environment
+  console.error('Unsupported environment');
+  return () => console.error('Unsupported environment');
+};

package/src/marker/api/getUserMessageFeedMarkers.ts

@@ -1,4 +1,5 @@
 import { getActiveClient } from '~/client/api/activeClient';
+import { fireEvent } from '~/core/events';
 
 /**
  * ```js
@@ -31,5 +32,7 @@ export const getUserMessageFeedMakers = async (
     },
   );
 
+  fireEvent('local.userMessageFeedMarker.fetched', { userMessageFeedMarker: data });
+
   return data;
 };

package/src/marker/events/onUserFeedMarkerFetched.ts

@@ -0,0 +1,37 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { createEventSubscriber } from '~/core/events';
+import { persistUnreadCountInfo } from '../utils/persistUnreadCountInfo';
+
+/**
+ * ```js
+ * import { onFeedMarkerUpdated } from '@amityco/ts-sdk'
+ * const dispose = onFeedMarkerUpdated(feedMarker => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when an {@link Amity.UserMessageFeedMarkerPayload} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category FeedMarker Events
+ */
+export const onUserFeedMarkerFetched = (
+  callback: Amity.Listener<Amity.UserMessageFeedMarkerPayload>,
+): Amity.Unsubscriber => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.Events['local.userMessageFeedMarker.fetched']) => {
+    // update sub channel unread info and channel unread info in cache
+    persistUnreadCountInfo(payload.userMessageFeedMarker);
+    callback(payload.userMessageFeedMarker);
+  };
+
+  return createEventSubscriber(
+    client,
+    'feedMarker/onUserFeedMarkerFetched',
+    'local.userMessageFeedMarker.fetched',
+    filter,
+  );
+};

package/src/marker/utils/addFlagSubChannelUnreadByChannelId.ts

@@ -0,0 +1,19 @@
+import { dropFromCache, pushToCache, queryCache } from '~/cache/api';
+
+export const addFlagSubChannelUnreadByChannelId = (channelId: string) => {
+  const cacheKey = ['subChannelUnreadInfo', 'get'];
+  const cachedSubChannelUnread = queryCache<Amity.SubChannelUnreadInfo>(cacheKey);
+
+  if (cachedSubChannelUnread) {
+    const cachedTargetSubChannelUnread = cachedSubChannelUnread?.filter(
+      ({ data }) => data.channelId === channelId,
+    );
+
+    cachedTargetSubChannelUnread.forEach(({ key, data }) => {
+      pushToCache(key, {
+        ...data,
+        isDeleted: true,
+      });
+    });
+  }
+};

package/src/marker/utils/addFlagSubChannelUnreadBySubChannelId.ts

@@ -0,0 +1,13 @@
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+export const addFlagSubChannelUnreadBySubChannelId = (subChannelId: string) => {
+  const cacheKey = ['subChannelUnreadInfo', 'get', subChannelId];
+  const cachedSubChannelUnread = pullFromCache<Amity.SubChannelUnreadInfo>(cacheKey)?.data;
+
+  if (cachedSubChannelUnread) {
+    pushToCache(cacheKey, {
+      ...cachedSubChannelUnread,
+      isDeleted: true,
+    });
+  }
+};

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

@@ -0,0 +1,225 @@
+import {
+  client,
+  generateMessageMarker,
+  generateRawChannel,
+  generateRawMessage,
+  messages,
+  pause,
+  generateRawSubChannel,
+} from '~/utils/tests';
+import { getMessages } from '../getMessages';
+import { getChannels } from '~/channelRepository/observers/getChannels';
+
+import { enableUnreadCount } from '~/client';
+
+import ReadReceiptSyncEngine from '~/client/utils/ReadReceiptSync/readReceiptSyncEngine';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { pushToCache } from '~/cache/api';
+
+describe('readReceiptSyncEngine', () => {
+  const channelsReturn: Amity.ChannelPayload = {
+    channels: [generateRawChannel({ channelId: 'channel-id' })],
+    channelUsers: [],
+    messagePreviews: [],
+    messageFeedsInfo: [],
+    users: [],
+    files: [],
+  };
+
+  const channelMarkerReturn: Amity.ChannelMarkerPayload = {
+    userEntityMarkers: [],
+    userMarkers: [],
+  };
+
+  const messageReturn: Amity.MessagePayload = {
+    messages: [
+      generateRawMessage({
+        messageId: messages.page1[0],
+        messageFeedId: 'channel-id',
+        channelId: 'channel-id',
+      }),
+    ],
+    messageFeeds: [],
+    reactions: [],
+    users: [],
+    files: [],
+  };
+
+  const messasgeMarkersReturn: Amity.MessageMarkerPayload = {
+    contentMarkers: [
+      generateMessageMarker({
+        contentId: messages.page1[0],
+        feedId: messageReturn.messages[0].messageFeedId,
+        creatorId: messageReturn.messages[0].creatorId,
+      }),
+    ],
+    feedMarkers: [],
+    userMarkers: [],
+  };
+
+  const userMessageFeedMarkersReturn: Amity.UserMessageFeedMarkerPayload = {
+    feedMarkers: [
+      {
+        feedId: 'channel-id',
+        entityId: 'channel-id',
+        lastSegment: 0,
+        isDeleted: false,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      },
+    ],
+    userFeedMarkers: [
+      {
+        userId: 'user-id',
+        entityId: 'channel-id',
+        feedId: 'channel-id',
+        readToSegment: 0,
+        deliveredToSegment: 0,
+        unreadCount: 0,
+        oldUnreadCount: 0,
+        lastMentionSegment: 0,
+        isMentioned: false,
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+      },
+    ],
+  };
+  const { subChannelId } = messages;
+
+  const rawNewMessage = generateRawMessage({
+    messageId: 'new-message-id',
+    messageFeedId: 'channel-id',
+    channelPublicId: 'channel-id',
+    channelId: 'channel-id',
+  });
+
+  client.use();
+  client.http.get = jest.fn().mockImplementation(params => {
+    if (params.includes('/api/v5/messages')) return { data: { ...messageReturn } };
+    if (params.includes('/api/v3/channels')) return { data: { ...channelsReturn } };
+    if (params.includes('/api/v1/markers/user-message-feed'))
+      return { data: { ...userMessageFeedMarkersReturn } };
+    if (params.includes('/api/v1/markers/channels'))
+      return {
+        data: { ...channelMarkerReturn },
+      };
+    if (params.includes('/api/v1/markers/messages'))
+      return {
+        data: { ...messasgeMarkersReturn },
+      };
+    return { data: {} };
+  });
+
+  it('should increase unreadCount when a message is received', async () => {
+    enableUnreadCount();
+
+    const callbackChannels = jest.fn();
+
+    getChannels({}, callbackChannels);
+
+    await pause();
+
+    client.emitter.emit('message.created', {
+      messages: [rawNewMessage],
+      messageFeeds: [
+        {
+          ...generateRawSubChannel({
+            channelId: channelsReturn.channels[0].channelId,
+            messageFeedId: channelsReturn.channels[0].channelId,
+            name: 'general',
+          }),
+        },
+      ],
+      users: [],
+      files: [],
+      reactions: [],
+    });
+
+    await pause();
+
+    expect(callbackChannels.mock.calls[2][0].data[0].unreadCount).toBe(1);
+    expect(callbackChannels.mock.calls[2][0].data[0].subChannelsUnreadCount).toBe(1);
+  });
+
+  it('should mark a message as read', async () => {
+    const readReceiptSyncEngine = ReadReceiptSyncEngine.getInstance();
+
+    readReceiptSyncEngine.startSyncReadReceipt();
+
+    const spyPut = jest.spyOn(client.http, 'put').mockResolvedValue({});
+    const callback = jest.fn();
+
+    getMessages({ subChannelId }, callback);
+
+    callback.mock.calls[1][0].data[0].markRead();
+
+    await pause(2000);
+
+    expect(spyPut).toHaveBeenCalledWith(`/api/v1/markers/message-feeds/${subChannelId}/mark-read`, {
+      readToSegment: 1,
+    });
+
+    readReceiptSyncEngine.onSessionDestroyed();
+
+    client.emitter.emit('message.created', {
+      messages: [rawNewMessage],
+      messageFeeds: [
+        {
+          ...generateRawSubChannel({
+            channelId: channelsReturn.channels[0].channelId,
+            messageFeedId: channelsReturn.channels[0].channelId,
+            name: 'general',
+          }),
+        },
+      ],
+      users: [],
+      files: [],
+      reactions: [],
+    });
+  });
+
+  it.only('should increase message readCount when a message is marked as read', async () => {
+    const callback = jest.fn();
+    getMessages({ subChannelId: 'channel-id' }, callback);
+
+    pushToCache(['messageMarker', 'get', 'channel-id#message11#user-id'], {
+      feedId: 'channel-id',
+      contentId: 'message11',
+      creatorId: 'user-id',
+      readCount: 0,
+      deliveredCount: 0,
+      createdAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString(),
+    });
+
+    await pause();
+
+    client.emitter.emit('marker.marked-message', {
+      contentMarkers: [
+        {
+          feedId: 'channel-id',
+          contentId: 'message11',
+          creatorId: 'user-id',
+          readCount: 1,
+          deliveredCount: 0,
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+        },
+      ],
+      feedMarkers: [
+        {
+          feedId: 'channel-id',
+          entityId: 'channel-id',
+          lastSegment: 1,
+          isDeleted: false,
+          createdAt: new Date().toISOString(),
+          updatedAt: new Date().toISOString(),
+        },
+      ],
+    });
+
+    await pause();
+
+    expect(callback.mock.calls[2][0].data[0].readCount).toBe(1);
+  });
+});

package/src/reactionRepository/events/onReactionAdded.ts

@@ -40,6 +40,7 @@ export const onReactionAdded = (
    * Important: Want to point out that reference type will never be 'message'
    * for onReactionAdded
    */
+
   if (referenceType === 'message') {
     const client = getActiveClient();