@amityco/ts-sdk 7.10.1-86aa7706.0 → 7.10.1-9fe9d33d.0

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/messageRepository/utils/addReactionToMessage.ts

@@ -0,0 +1,12 @@
+import { addReaction as _addReaction } from '~/reactionRepository/internalApi';
+
+export const addReactionToMessage = (reactionName: string, message: Amity.InternalMessage) => {
+  const isMessageV3 = message.publicId !== message.messageId;
+
+  return _addReaction(
+    'message',
+    isMessageV3 ? message.publicId : message.messageId,
+    reactionName,
+    isMessageV3 ? 3 : 5,
+  );
+};

package/src/messageRepository/utils/getMessageFromMainDB.ts

@@ -0,0 +1,10 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { queryCache } from '~/cache/api/queryCache';
+
+export const getMessageFromMainDB = (messageId: string): Amity.InternalMessage | undefined => {
+  const message = pullFromCache<Amity.InternalMessage>(['message', 'get', messageId])?.data;
+  if (message) return message;
+
+  const messages = queryCache<Amity.InternalMessage>(['message', 'get']);
+  return messages?.find(({ data }) => data.messageId === messageId)?.data;
+};

package/src/messageRepository/utils/getMessageReadCount.ts

@@ -0,0 +1,26 @@
+import { pullFromCache } from '~/cache/api/pullFromCache';
+import { getResolver } from '~/core/model';
+
+const getCachedMarker = (message: Amity.InternalMessage | Amity.RawMessage) => {
+  const key = {
+    creatorId: 'creatorPrivateId' in message ? message.creatorPrivateId : message.creatorId,
+    feedId:
+      (<Amity.RawMessage>message).messageFeedId ?? (<Amity.InternalMessage>message).subChannelId,
+    contentId: message.messageId,
+  };
+
+  return pullFromCache<Amity.MessageMarker>([
+    'messageMarker',
+    'get',
+    getResolver('messageMarker')(key),
+  ])?.data;
+};
+
+export const getMessageReadCount = (
+  message: Amity.InternalMessage | Amity.RawMessage,
+  marker?: Amity.MessageMarker,
+) =>
+  // Look in the marker param first
+  marker ??
+  // If the marker param is not set, look in the cache
+  getCachedMarker(message) ?? { readCount: 0, deliveredCount: 0 }; // and if not found in cache use default value `0`

package/src/messageRepository/utils/index.ts

@@ -0,0 +1 @@
+export * from './prepareMessagePayload';

package/src/messageRepository/utils/markReadMessage.ts

@@ -0,0 +1,15 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import ReadReceiptSyncEngine from '~/client/utils/ReadReceiptSync/readReceiptSyncEngine';
+import LegacyReadReceiptSyncEngine from '~/client/utils/ReadReceiptSync/legacyReadReceiptSyncEngine';
+
+export const markReadMessage = (message: Amity.InternalMessage) => {
+  const client = getActiveClient();
+
+  if (client.useLegacyUnreadCount) {
+    const markReadReceiptEngine = ReadReceiptSyncEngine.getInstance();
+    markReadReceiptEngine.markRead(message.channelId, message.channelSegment);
+  } else {
+    const markReadReceiptEngine = LegacyReadReceiptSyncEngine.getInstance();
+    markReadReceiptEngine.markRead(message.subChannelId, message.channelSegment);
+  }
+};

package/src/messageRepository/utils/prepareMessagePayload.ts

@@ -0,0 +1,244 @@
+import { pullFromCache, queryCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getMessageMarkers } from '~/marker/api/getMessageMarkers';
+import { prepareMessagePayloadForCache } from '~/reactionRepository/utils/prepareMessagePayloadForCache';
+import { inferIsDeleted } from '~/utils/inferIsDeleted';
+
+import { MessageContentType } from '~/@types';
+import { convertFromRaw as convertSubChannelFromRaw } from '~/subChannelRepository/utils/convertSubChannelFromRaw';
+import { updateSubChannelCache } from '~/subChannelRepository/utils/updateSubChannelCache';
+import { COLLECTION_DEFAULT_PAGINATION_LIMIT } from '~/utils/constants';
+
+const mergePayloadWithLocal = (payload: Amity.RawMessage) => {
+  const localMessage = queryCache<Amity.InternalMessage>(['message', 'get'])?.find(
+    ({ data }) => data.messageId === payload.messageId,
+  )?.data;
+
+  if (localMessage) {
+    return {
+      ...localMessage,
+      ...payload,
+      // NOTE: referenceId is missing in the some payload event. If we have local message data with referenceId, use it instead.
+      referenceId: localMessage.referenceId ?? payload.referenceId,
+    };
+  }
+
+  return payload;
+};
+
+export function convertFromRaw(
+  message: Amity.RawMessage,
+  reactors?: Amity.InternalReactor[],
+  event?: keyof Amity.MqttMessageEvents,
+): Amity.InternalMessage {
+  const mergeMessage = mergePayloadWithLocal(message);
+
+  const {
+    channelPublicId,
+    childCount,
+    creatorPublicId,
+    mentionedUsers,
+    messageFeedId,
+    myReactions,
+    reactionCount,
+    reactions,
+    referenceId,
+    segment,
+    messageId,
+    creatorId,
+    ...rest
+  } = mergeMessage;
+
+  let cache: Amity.CacheEntry<Amity.Message> | undefined;
+
+  if (referenceId) {
+    cache = pullFromCache(['message', 'get', referenceId]);
+  }
+
+  if (!cache) {
+    cache = pullFromCache(['message', 'get', messageId]);
+  }
+
+  const out: Amity.InternalMessage = {
+    ...rest,
+    messageId,
+    channelId: channelPublicId,
+    channelSegment: segment,
+    childrenNumber: childCount,
+    creatorId: creatorPublicId,
+    creatorPrivateId: message.creatorId,
+    reactions: reactions ?? {},
+    /*
+     * Previously, myReactions were added only if it was part of the payload.
+     * So empty myReactions were not present. So I've edited the payload to add
+     * a default for those cases.
+     *
+     * Check git blame for previous iteration
+     */
+    myReactions: myReactions || (cache?.data.myReactions ?? []),
+    reactionsCount: reactionCount,
+    subChannelId: messageFeedId,
+    uniqueId: cache ? cache.data.uniqueId : messageId,
+    referenceId,
+    syncState: Amity.SyncState.Synced,
+  };
+
+  if (mentionedUsers) {
+    out.mentionees = mentionedUsers.map(mention => {
+      if (mention.type === 'channel') {
+        return mention;
+      }
+
+      return { type: 'user', userIds: mention.userPublicIds };
+    });
+  }
+
+  if (reactors && reactors.length && event) {
+    // mqtt event
+    prepareMessagePayloadForCache(out, reactors, event);
+  }
+
+  return out;
+}
+
+const preUpdateMessageCache = (rawPayload: Amity.MessagePayload) => {
+  ingestInCache({
+    messages: rawPayload.messages.map(message => convertFromRaw(message, rawPayload.reactions)),
+  });
+};
+
+const DEBOUNCE_TIME = 2000;
+const currentDebounceMap: Record<string, NodeJS.Timeout | undefined> = {};
+
+export const prepareMessagePayload = async (
+  payload: Amity.MessagePayload,
+  event?: keyof Amity.MqttMessageEvents,
+): Promise<Amity.ProcessedMessagePayload> => {
+  const markerIds = payload.messages.map(({ messageId }) => messageId);
+
+  if (markerIds.length > 0) {
+    // since the get markers method requires a channel cache to function with the reducer.
+    preUpdateMessageCache(payload);
+
+    const markerIdsKey = markerIds.join('');
+
+    if (currentDebounceMap[markerIdsKey]) {
+      clearTimeout(currentDebounceMap[markerIdsKey]);
+    }
+    currentDebounceMap[markerIdsKey] = setTimeout(() => {
+      try {
+        getMessageMarkers(markerIds);
+      } catch (_error) {
+        // do nothing
+      }
+    }, DEBOUNCE_TIME);
+  }
+
+  const { messageFeeds, ...restPayload } = payload;
+
+  // upsert messageFeeds to subchannel cache because messageFeeds from event payload not include messagePreviewId
+  if (messageFeeds && messageFeeds.length > 0) {
+    messageFeeds?.forEach(messageFeed => {
+      const subChannelCache =
+        pullFromCache<Amity.SubChannel>(['subChannel', 'get', messageFeed.messageFeedId])?.data ??
+        {};
+
+      // exclude getter properties from existing subChannel cache, update only other properties to existing subChannel cache
+      const { unreadCount, isMentioned, ...restSubChannel } = convertSubChannelFromRaw(messageFeed);
+
+      updateSubChannelCache(messageFeed.messageFeedId, subChannelCache, restSubChannel);
+    });
+  }
+
+  return {
+    ...restPayload,
+    messages: payload.messages.map(m => convertFromRaw(m, payload.reactions, event)),
+  };
+};
+
+type RawQueryMessages = Omit<
+  Amity.QueryMessages,
+  /*
+   * include deleted is for internal sdk use only. The server expects isDeleted
+   */
+  | 'page'
+  | 'sortBy'
+  | 'subChannelId'
+  | 'tags'
+  | 'includeDeleted'
+  | 'aroundMessageId'
+  | 'dataType'
+  | 'includingTags'
+  | 'excludingTags'
+> & {
+  includeTags?: Amity.QueryMessages['includingTags'];
+  excludeTags?: Amity.QueryMessages['excludingTags'];
+  isDeleted?: Amity.Message['isDeleted'];
+  messageFeedId: Amity.QueryMessages['subChannelId'];
+  dataType?: Amity.MessageContentType;
+  options: {
+    sortBy?: Amity.QueryMessages['sortBy'];
+    token?: string;
+    limit?: number;
+    around?: Amity.Message['messageId'];
+  };
+};
+
+export function convertParams({
+  subChannelId,
+  mentionees,
+  dataType,
+  data,
+  ...rest
+}: Partial<Amity.Message>): Record<string, any> {
+  if (dataType === MessageContentType.IMAGE || dataType === MessageContentType.FILE) {
+    return {
+      messageFeedId: subChannelId,
+      mentionedUsers: mentionees,
+      dataType,
+      data: {
+        caption: '',
+        ...(data as Record<string, any>),
+      },
+      ...rest,
+    };
+  }
+  return { messageFeedId: subChannelId, mentionedUsers: mentionees, dataType, data, ...rest };
+}
+
+export function convertQueryParams({
+  sortBy,
+  subChannelId,
+  includingTags,
+  excludingTags,
+  includeDeleted,
+  aroundMessageId,
+  limit,
+  type,
+  ...rest
+}: Amity.MessagesLiveCollection): RawQueryMessages {
+  const out: RawQueryMessages = {
+    ...rest,
+    messageFeedId: subChannelId,
+    isDeleted: inferIsDeleted(includeDeleted),
+    options: {
+      sortBy,
+      limit: limit || COLLECTION_DEFAULT_PAGINATION_LIMIT,
+      around: aroundMessageId,
+    },
+  };
+
+  if (includingTags) {
+    out.includeTags = includingTags;
+  }
+
+  if (type) {
+    out.dataType = type;
+  }
+
+  if (excludingTags) {
+    out.excludeTags = excludingTags;
+  }
+
+  return out;
+}

package/src/messageRepository/utils/removeReactionToMessage.ts

@@ -0,0 +1,12 @@
+import { removeReaction as _removeReaction } from '~/reactionRepository/internalApi';
+
+export const removeReactionToMessage = (reactionName: string, message: Amity.InternalMessage) => {
+  const isMessageV3 = message.publicId !== message.messageId;
+
+  return _removeReaction(
+    'message',
+    isMessageV3 ? message.publicId : message.messageId,
+    reactionName,
+    isMessageV3 ? 3 : 5,
+  );
+};

package/src/notificationTray/api/index.ts

@@ -0,0 +1,2 @@
+export * from './markItemsSeen';
+export * from './markTraySeen';

package/src/notificationTray/api/markItemsSeen.ts

@@ -0,0 +1,62 @@
+import { getActiveClient } from '~/client/api/activeClient';
+import { fireEvent } from '~/core/events';
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+/* begin_public_function
+  id: notificationTrayItem.markSeen
+*/
+/**
+ * ```js
+ * import { notificationTray } from '@amityco/ts-sdk'
+ * const updated = await notificationTray.markItemsSeen()
+ * ```
+ *
+ * Updates an {@link Amity.NotificationItemSeen}
+ *
+ * @param trayItems[] that include id and lastTraySeenAt, The ID of the {@link Amity.NotificationItemSeen} to edit
+ * @returns the updated {@link Amity.NotificationItemSeen} object
+ *
+ * @category NotificationItemSeen API
+ * @async
+ */
+export const markItemsSeen = async (trayItems: Amity.QueryNotificationItemSeen[]) => {
+  const client = getActiveClient();
+  client.log('notificationTray/markItemsSeen', {});
+
+  const { data: payload } = await client.http.post<Amity.NotificationItemSeenPayload>(
+    `api/v1/notification-tray/items/seen`,
+    {
+      trayItems: trayItems.map(item => ({
+        id: item.id,
+        lastSeenAt: item.lastSeenAt,
+      })),
+    },
+  );
+
+  const updatedData = payload.trayItems
+    .map(patchItem => {
+      const cacheData = pullFromCache<Amity.InternalNotificationTrayItem>([
+        'notificationTrayItem',
+        'get',
+        patchItem.id,
+      ])?.data;
+
+      if (!cacheData) return;
+
+      const data = {
+        ...cacheData,
+        lastSeenAt: patchItem.lastSeenAt,
+      };
+
+      if (client.cache) {
+        const cachedAt = Date.now();
+        pushToCache(['notificationTrayItem', 'get'], data, { cachedAt });
+      }
+
+      return data;
+    })
+    .filter(Boolean) as Amity.InternalNotificationTrayItem[];
+
+  fireEvent('local.notificationTrayItem.updated', { notificationTrayItems: updatedData });
+};
+/* end_public_function */

package/src/notificationTray/api/markTraySeen.ts

@@ -0,0 +1,65 @@
+import { getActiveClient } from '~/client/api';
+import { fireEvent } from '~/core/events';
+import { pullFromCache, pushToCache } from '~/cache/api';
+
+/* begin_public_function
+  id: notificationTray.markSeen
+*/
+/**
+ * ```js
+ * import { notificationTray } from '@amityco/ts-sdk'
+ * const updated = await notificationTray.markTraySeen({
+ *   lastSeenAt: Amity.timestamp,
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.NotificationTraySeen}
+ *
+ * @param userId The ID of the {@link Amity.NotificationTraySeen} to edit
+ * @param lastSeenAt The patch data to apply
+ * @returns the updated {@link Amity.NotificationTraySeen} object
+ *
+ * @category Post API
+ * @async
+ */
+export const markTraySeen = async (
+  lastSeenAt: Amity.timestamp,
+): Promise<Amity.Cached<Amity.NotificationTraySeenUpdatedPayload>> => {
+  const client = getActiveClient();
+  client.log('notificationTray/markTraySeen', {});
+
+  const { data: payload } = await client.http.post<Amity.NotificationTraySeenUpdatedPayload>(
+    `api/v1/notification-tray/tray/seen`,
+    {
+      lastSeenAt,
+    },
+  );
+
+  const cacheData = pullFromCache<Amity.InternalNotificationTraySeen>([
+    'notificationTraySeen',
+    'get',
+  ])?.data;
+
+  const data = {
+    userId: client.userId!,
+    lastTraySeenAt: payload.lastSeenAt,
+  } as Amity.InternalNotificationTraySeen;
+
+  const updateCacheData = {
+    ...cacheData,
+    ...data,
+  };
+
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache)
+    pushToCache(['notificationTraySeen', 'get', client.userId!], updateCacheData, { cachedAt });
+
+  fireEvent('local.notificationTraySeen.updated', data);
+
+  return {
+    data: payload,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/notificationTray/events/index.ts

@@ -0,0 +1 @@
+export * from './onNotificationTraySeenUpdated';