@amityco/ts-sdk 0.0.1-beta.42.3 → 0.0.1-beta.43

package/src/message/tests/observers/liveMessages.test.ts

@@ -7,34 +7,38 @@ import {
   disconnectClient,
   messages,
   generateRawMessage,
+  convertRawMessage,
+  pause,
 } from '~/utils/tests';
 
-import { convertFromRaw } from '../../utils';
 import { queryMessages } from '../../api';
 import { liveMessages } from '../../observers';
+import * as getMessageMarkers from '../../../marker/api/getMessageMarkers';
 
 describe('liveMessages', () => {
-  beforeAll(async () => {
-    await connectClient();
-  });
+  beforeAll(() => {
+    connectClient();
 
-  afterAll(async () => {
-    await disconnectClient();
+    jest.spyOn(getMessageMarkers, 'getMessageMarkers').mockImplementation(() =>
+      Promise.resolve({
+        data: [],
+        cachedAt: undefined,
+      }),
+    );
   });
 
-  beforeEach(async () => {
-    enableCache();
-  });
+  afterAll(disconnectClient);
 
+  beforeEach(enableCache);
   afterEach(disableCache);
 
   const { subChannelId } = messages;
-  const returnValue = [{ messageId: messages.page1[0] }];
+  const returnValue: Amity.RawMessage[] = [generateRawMessage({ messageId: messages.page1[0] })];
   const rawMessage = generateRawMessage({
     messageId: returnValue[0].messageId,
     messageFeedId: subChannelId,
   });
-  const message = convertFromRaw(rawMessage);
+  const message = convertRawMessage(rawMessage);
 
   test('it should show message if cache not enabled', () => {
     /*
@@ -85,8 +89,7 @@ describe('liveMessages', () => {
 
     expect(callback).toHaveBeenCalledWith(
       expect.objectContaining({
-        // @ts-ignore
-        data: returnValue.map(convertFromRaw),
+        data: returnValue.map(convertRawMessage),
         error: undefined,
         loading: false,
       }),
@@ -166,7 +169,7 @@ describe('liveMessages', () => {
     expect(callback).toHaveBeenCalledWith(
       expect.objectContaining({
         // @ts-ignore
-        data: [returnValue[1]].map(convertFromRaw),
+        data: [returnValue[1]].map(convertRawMessage),
         error: undefined,
         loading: false,
       }),
@@ -222,7 +225,7 @@ describe('liveMessages', () => {
       4,
       expect.objectContaining({
         // @ts-ignore
-        data: [...returnValue2, ...returnValue].map(convertFromRaw),
+        data: [...returnValue2, ...returnValue].map(convertRawMessage),
         error: undefined,
         loading: false,
       }),
@@ -260,7 +263,7 @@ describe('liveMessages', () => {
       messageId: 'new-message-id',
       messageFeedId: message.subChannelId,
     });
-    const newMessage = convertFromRaw(rawNewMessage);
+    const newMessage = convertRawMessage(rawNewMessage);
 
     // mock response of queryMessages and validate
     const callback = jest.fn();
@@ -283,6 +286,8 @@ describe('liveMessages', () => {
       files: [],
     });
 
+    await pause();
+
     expect(callback).toHaveBeenNthCalledWith(
       3,
       expect.objectContaining({
@@ -291,7 +296,7 @@ describe('liveMessages', () => {
       }),
     );
     expect(callback.mock.calls[2][0].data[0]).toMatchObject(newMessage);
-    expect(callback.mock.calls[2][0].data[1]).toMatchObject(returnValue[0]);
+    expect(callback.mock.calls[2][0].data[1]).toMatchObject(message);
   });
 
   test('it should add new message to collection onUpdate', async () => {
@@ -317,7 +322,7 @@ describe('liveMessages', () => {
     });
 
     expect(callback).toHaveBeenNthCalledWith(
-      3,
+      2,
       expect.objectContaining({
         data: [message],
         error: undefined,
@@ -348,6 +353,8 @@ describe('liveMessages', () => {
       files: [],
     });
 
+    await pause();
+
     expect(callback).toHaveBeenNthCalledWith(
       3,
       expect.objectContaining({

package/src/message/utils/index.ts

@@ -1,140 +1 @@
-import { AxiosResponse } from 'axios';
-import { toToken } from '~/core/query';
-import { pullFromCache } from '~/cache/api';
-import { prepareMessagePayloadForCache } from '~/reaction/utils/prepareMessagePayloadForCache';
-
-export function convertFromRaw({
-  channelPublicId,
-  childCount,
-  creatorPublicId,
-  mentionedUsers,
-  messageFeedId,
-  myReactions,
-  reactionCount,
-  reactions,
-  referenceId,
-  segment,
-  ...rest
-}: Amity.RawMessage): Amity.Message {
-  let cache: Amity.CacheEntry<Amity.Message> | undefined;
-
-  if (referenceId) {
-    try {
-      cache = pullFromCache(['message', 'get', referenceId]);
-      // eslint-disable-next-line no-empty
-    } catch {}
-  }
-
-  if (!cache) {
-    try {
-      cache = pullFromCache(['message', 'get', rest.messageId]);
-      // eslint-disable-next-line no-empty
-    } catch {}
-  }
-
-  const out: Amity.Message = {
-    ...rest,
-    channelId: channelPublicId,
-    channelSegment: segment,
-    childrenNumber: childCount,
-    creatorId: creatorPublicId,
-    reactions: reactions ?? {},
-    reactionsCount: reactionCount,
-    subChannelId: messageFeedId,
-    uniqueId: cache ? cache.data.uniqueId : rest.messageId,
-  };
-
-  if (mentionedUsers) {
-    out.mentionees = mentionedUsers.map(mention => {
-      if (mention.type === 'channel') {
-        return mention;
-      }
-
-      return { type: 'user', userIds: mention.userPublicIds };
-    });
-  }
-
-  if (myReactions) {
-    // http response
-    out.myReactions = myReactions;
-  } else {
-    // mqtt event
-    try {
-      prepareMessagePayloadForCache(out);
-      // eslint-disable-next-line no-empty
-    } catch {}
-  }
-
-  return out;
-}
-
-export const prepareMessagePayload = (
-  payload: Amity.MessagePayload,
-): Amity.ProcessedMessagePayload => {
-  return {
-    ...payload,
-    messages: payload.messages.map(convertFromRaw),
-  };
-};
-
-export const convertResponseFromRaw = <T extends Amity.MessagePayload>(
-  response: AxiosResponse<T>,
-): AxiosResponse<Omit<T, 'messages'> & { messages: Amity.ProcessedMessagePayload['messages'] }> => {
-  return {
-    ...response,
-    data: {
-      ...response.data,
-      messages: response.data.messages.map(convertFromRaw),
-    },
-  };
-};
-
-type RawQueryMessages = Omit<
-  Amity.QueryMessages,
-  /*
-   * include deleted is for internal sdk use only. The server expects isDeleted
-   */
-  'page' | 'sortBy' | 'subChannelId' | 'tags' | 'includeDeleted'
-> & {
-  includeTags?: Amity.QueryMessages['tags'];
-  isDeleted?: Amity.Message['isDeleted'];
-  messageFeedId: Amity.QueryMessages['subChannelId'];
-  options: {
-    sortBy?: Amity.QueryMessages['sortBy'];
-    token: string;
-  };
-};
-
-export function convertParams({
-  subChannelId,
-  mentionees,
-  ...rest
-}: Partial<Amity.Message>): Record<string, any> {
-  return { messageFeedId: subChannelId, mentionedUsers: mentionees, ...rest };
-}
-
-export function convertQueryParams({
-  page,
-  sortBy,
-  subChannelId,
-  tags,
-  includeDeleted,
-  ...rest
-}: Amity.QueryMessages): RawQueryMessages {
-  const out: RawQueryMessages = {
-    ...rest,
-    messageFeedId: subChannelId,
-    isDeleted: includeDeleted === false ? false : undefined,
-    options: { token: toToken(page || { limit: 10 }, 'afterbeforeraw')! },
-  };
-
-  if (sortBy !== undefined) {
-    out.options.sortBy = sortBy;
-  }
-
-  if (tags) {
-    out.includeTags = tags;
-  }
-
-  return out;
-}
+export * from './prepareMessagePayload';

package/src/message/utils/prepareMessagePayload.ts

@@ -0,0 +1,182 @@
+import { pullFromCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+import { toToken } from '~/core/query';
+import { getMessageMarkers } from '~/marker/api';
+import { prepareMessagePayloadForCache } from '~/reaction/utils/prepareMessagePayloadForCache';
+
+const getCachedMarker = (message: Amity.Message | Amity.RawMessage) => {
+  const key = {
+    creatorId: message.creatorId,
+    feedId: (<Amity.RawMessage>message).messageFeedId ?? (<Amity.Message>message).subChannelId,
+    contentId: message.messageId,
+  };
+
+  return pullFromCache<Amity.MessageMarker>([
+    'messageMarker',
+    'get',
+    getResolver('messageMarker')(key),
+  ])?.data;
+};
+
+const getReadCount = (message: Amity.Message | 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`
+
+export function convertFromRaw(
+  message: Amity.RawMessage,
+  marker?: Amity.MessageMarker,
+): Amity.Message {
+  const {
+    channelPublicId,
+    childCount,
+    creatorPublicId,
+    mentionedUsers,
+    messageFeedId,
+    myReactions,
+    reactionCount,
+    reactions,
+    referenceId,
+    segment,
+    messageId,
+    ...rest
+  } = message;
+
+  const { readCount, deliveredCount } = getReadCount(message, marker);
+
+  let cache: Amity.CacheEntry<Amity.Message> | undefined;
+
+  if (referenceId) {
+    cache = pullFromCache(['message', 'get', referenceId]);
+  }
+
+  if (!cache) {
+    cache = pullFromCache(['message', 'get', messageId]);
+  }
+
+  const out: Amity.Message = {
+    ...rest,
+    messageId,
+    channelId: channelPublicId,
+    channelSegment: segment,
+    childrenNumber: childCount,
+    creatorId: creatorPublicId,
+    reactions: reactions ?? {},
+    reactionsCount: reactionCount,
+    subChannelId: messageFeedId,
+    uniqueId: cache ? cache.data.uniqueId : messageId,
+    readCount,
+    deliveredCount,
+  };
+
+  if (mentionedUsers) {
+    out.mentionees = mentionedUsers.map(mention => {
+      if (mention.type === 'channel') {
+        return mention;
+      }
+
+      return { type: 'user', userIds: mention.userPublicIds };
+    });
+  }
+
+  if (myReactions) {
+    // http response
+    out.myReactions = myReactions;
+  } else {
+    // mqtt event
+    prepareMessagePayloadForCache(out);
+  }
+
+  return out;
+}
+
+export function updateMessageMarker(
+  message: Amity.Message,
+  marker?: Amity.MessageMarker,
+): Amity.Message {
+  const { readCount, deliveredCount } = getReadCount(message, marker);
+
+  return {
+    ...message,
+    readCount,
+    deliveredCount,
+    updatedAt: new Date().toISOString(),
+  };
+}
+
+export const prepareMessagePayload = async (
+  payload: Amity.MessagePayload,
+): Promise<Amity.ProcessedMessagePayload> => {
+  // make a fetch marker to prepare it for merging with the raw message payload.
+  let markers: Amity.MessageMarker[] = [];
+
+  const markerIds = payload.messages.map(({ messageId }) => messageId);
+
+  if (markerIds.length > 0)
+    // from the spec, allow marker fetch to fail
+    try {
+      ({ data: markers } = await getMessageMarkers(markerIds));
+    } catch (e) {
+      // empty block
+    }
+
+  return {
+    ...payload,
+    messages: payload.messages.map(message => {
+      const marker = markers?.find(({ contentId }) => contentId === message.messageId);
+
+      return convertFromRaw(message, marker);
+    }),
+  };
+};
+
+type RawQueryMessages = Omit<
+  Amity.QueryMessages,
+  /*
+   * include deleted is for internal sdk use only. The server expects isDeleted
+   */
+  'page' | 'sortBy' | 'subChannelId' | 'tags' | 'includeDeleted'
+> & {
+  includeTags?: Amity.QueryMessages['tags'];
+  isDeleted?: Amity.Message['isDeleted'];
+  messageFeedId: Amity.QueryMessages['subChannelId'];
+  options: {
+    sortBy?: Amity.QueryMessages['sortBy'];
+    token: string;
+  };
+};
+
+export function convertParams({
+  subChannelId,
+  mentionees,
+  ...rest
+}: Partial<Amity.Message>): Record<string, any> {
+  return { messageFeedId: subChannelId, mentionedUsers: mentionees, ...rest };
+}
+
+export function convertQueryParams({
+  page,
+  sortBy,
+  subChannelId,
+  tags,
+  includeDeleted,
+  ...rest
+}: Amity.QueryMessages): RawQueryMessages {
+  const out: RawQueryMessages = {
+    ...rest,
+    messageFeedId: subChannelId,
+    isDeleted: includeDeleted === false ? false : undefined,
+    options: { token: toToken(page || { limit: 10 }, 'afterbeforeraw')! },
+  };
+
+  if (sortBy !== undefined) {
+    out.options.sortBy = sortBy;
+  }
+
+  if (tags) {
+    out.includeTags = tags;
+  }
+
+  return out;
+}

package/src/reaction/events/onReactionAdded.ts

@@ -42,8 +42,8 @@ export const onReactionAdded = (
   if (referenceType === 'message') {
     const client = getActiveClient();
 
-    const filter = (rawPayload: Amity.MessagePayload) => {
-      const payload = prepareMessagePayload(rawPayload);
+    const filter = async (rawPayload: Amity.MessagePayload) => {
+      const payload = await prepareMessagePayload(rawPayload);
       const cached = pullFromCache<Amity.Message>([
         'message',
         'get',

package/src/reaction/events/onReactionRemoved.ts

@@ -38,8 +38,8 @@ export const onReactionRemoved = (
   if (referenceType === 'message') {
     const client = getActiveClient();
 
-    const filter = (rawPayload: Amity.MessagePayload) => {
-      const payload = prepareMessagePayload(rawPayload);
+    const filter = async (rawPayload: Amity.MessagePayload) => {
+      const payload = await prepareMessagePayload(rawPayload);
       const cached = pullFromCache<Amity.Message>([
         'message',
         'get',

package/src/reaction/events/onReactorAdded.ts

@@ -38,8 +38,8 @@ export const onReactorAdded = (
   };
 
   if (referenceType === 'message') {
-    const filter = (rawPayload: Amity.MessagePayload) => {
-      const payload = prepareMessagePayload(rawPayload);
+    const filter = async (rawPayload: Amity.MessagePayload) => {
+      const payload = await prepareMessagePayload(rawPayload);
       if (!payload.messages[0].latestReaction) return;
 
       const { eventName, referenceId, referenceType, userDisplayName, ...reactor } =

package/src/reaction/events/onReactorRemoved.ts

@@ -38,8 +38,8 @@ export const onReactorRemoved = (
   };
 
   if (referenceType === 'message') {
-    const filter = (rawPayload: Amity.MessagePayload) => {
-      const payload = prepareMessagePayload(rawPayload);
+    const filter = async (rawPayload: Amity.MessagePayload) => {
+      const payload = await prepareMessagePayload(rawPayload);
       if (!payload.messages[0].latestReaction) return;
 
       const { eventName, referenceId, referenceType, ...reactor } =

package/src/report/api/createReport.ts

@@ -50,7 +50,8 @@ export const createReport = async (
 
   if (client.cache) {
     if (referenceType === 'message') {
-      ingestInCache(prepareMessagePayload(payload as Amity.MessagePayload));
+      const messagePayload = await prepareMessagePayload(payload as Amity.MessagePayload);
+      ingestInCache(messagePayload);
     } else if (referenceType === 'post') {
       ingestInCache(prepareMembershipPayload(payload as Amity.PostPayload, 'communityUsers'));
     } else {

package/src/report/api/deleteReport.ts

@@ -50,7 +50,8 @@ export const deleteReport = async (
 
   if (client.cache) {
     if (referenceType === 'message') {
-      ingestInCache(prepareMessagePayload(payload as Amity.MessagePayload));
+      const messagePayload = await prepareMessagePayload(payload as Amity.MessagePayload);
+      ingestInCache(messagePayload);
     } else if (referenceType === 'post') {
       ingestInCache(prepareMembershipPayload(payload as Amity.PostPayload, 'communityUsers'));
     } else {

package/src/subChannel/api/createSubChannel.ts

@@ -30,7 +30,7 @@ export const createSubChannel = async <T extends Amity.ChannelType>(
     channelId: bundle.channelId,
     name: bundle.displayName,
   });
-  const data = prepareSubChannelPayload(response.data);
+  const data = await prepareSubChannelPayload(response.data);
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });

package/src/subChannel/api/getSubChannel.ts

@@ -36,7 +36,7 @@ export const getSubChannel = async (
     const response = await client.http.get<Amity.SubChannelPayload>(
       `/api/v5/message-feeds/${encodeURIComponent(subChannelId)}`,
     );
-    const data = prepareSubChannelPayload(response.data);
+    const data = await prepareSubChannelPayload(response.data);
 
     const cachedAt = client.cache && Date.now();
     if (client.cache) ingestInCache(data, { cachedAt });

package/src/subChannel/api/getSubChannels.ts

@@ -27,7 +27,8 @@ export const getSubChannels = async (
   const response = await client.http.get<Amity.SubChannelPayload>('/api/v5/message-feeds/list', {
     params: { messageFeedIds: subChannelIds.map(encodeURIComponent) },
   });
-  const data = prepareSubChannelPayload(response.data);
+
+  const data = await prepareSubChannelPayload(response.data);
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });

package/src/subChannel/api/index.ts

@@ -6,3 +6,6 @@ export * from './getSubChannel';
 export * from './createSubChannel';
 export * from './updateSubChannel';
 export * from './deleteSubChannel';
+
+export * from './startReadingAPI';
+export * from './stopReadingAPI';

package/src/subChannel/api/querySubChannels.ts

@@ -45,7 +45,7 @@ export const querySubChannels = async (
   );
 
   const { paging, ...payload } = response.data;
-  const data = prepareSubChannelPayload(payload);
+  const data = await prepareSubChannelPayload(payload);
   const subChannels = data.messageFeeds;
   const cachedAt = client.cache && Date.now();
 

package/src/subChannel/api/startReadingAPI.ts

@@ -0,0 +1,33 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+
+/**
+ * ```js
+ * import { SubChannel } from '@amityco/ts-sdk'
+ * const success = await SubChannel('foo')
+ * ```
+ *
+ * Mark all messages as read and start reading message inside channel
+ *
+ * @param messageFeedId - The sub channel ID to start reading.
+ * @return A success boolean if reading of the sub channel had begun.
+ *
+ * @category Channel API
+ * @async
+ * @private
+ */
+export const startReadingAPI = async (
+  messageFeedId: Amity.SubChannel['subChannelId'],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('channel/startReadingAPI', messageFeedId);
+
+  const { data: payload } = await client.http.post<Amity.StartReadingPayload>(
+    `/api/v1/markers/message-feeds/${messageFeedId}/start-reading`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload as Amity.StartReadingPayload, { cachedAt });
+
+  return true;
+};

package/src/subChannel/api/stopReadingAPI.ts

@@ -0,0 +1,33 @@
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getActiveClient } from '~/client/api';
+
+/**
+ * ```js
+ * import { stopReading } from '@amityco/ts-sdk'
+ * const success = await stopReading('foo')
+ * ```
+ *
+ * Mark all messages as read and stop reading message inside channel
+ *
+ * @param messageFeedId - The sub channel ID to stop reading.
+ * @return A success boolean if reading of the sub channel had begun.
+ *
+ * @category Channel API
+ * @async
+ * @private
+ */
+export const stopReadingAPI = async (
+  messageFeedId: Amity.SubChannel['subChannelId'],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('channel/stopReadingAPI', messageFeedId);
+
+  const { data: payload } = await client.http.post<Amity.StopReadingPayload>(
+    `/api/v1/markers/message-feeds/${messageFeedId}/stop-reading`,
+  );
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(payload as Amity.StopReadingPayload, { cachedAt });
+
+  return true;
+};

package/src/subChannel/api/tests/createSubChannel.test.ts

@@ -1,11 +1,12 @@
-import { createSubChannel } from '../createSubChannel';
-import { client, generateRawSubChannel } from '~/utils/tests';
+import { client, connectClient, disconnectClient, generateRawSubChannel } from '~/utils/tests';
 
 import { onSubChannelCreated } from '~/subChannel/events';
 
 import { disableCache, enableCache, pullFromCache } from '~/cache/api';
 import { ASCApiError } from '~/core/errors';
 
+import { createSubChannel } from '../createSubChannel';
+
 const subChannelId = 'channelId11--sub-channel-id';
 
 const subChannelPayload = {
@@ -14,8 +15,10 @@ const subChannelPayload = {
 };
 
 describe('createSubChannel', () => {
-  beforeEach(enableCache);
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
 
+  beforeEach(enableCache);
   afterEach(disableCache);
 
   // integration_test_id: fa72f0eb-b22b-4b9a-9e55-3a163a0ebd2a

package/src/subChannel/api/tests/deleteSubChannel.test.ts

@@ -1,16 +1,18 @@
-import { deleteSubChannel } from '../deleteSubChannel';
-import { onSubChannelDeleted } from '../../events';
-
-import { client, generateRawSubChannel } from '~/utils/tests';
+import { client, connectClient, disconnectClient, generateRawSubChannel } from '~/utils/tests';
 
 import { disableCache, enableCache, pullFromCache } from '~/cache/api';
 import { ASCApiError } from '~/core/errors';
 
+import { deleteSubChannel } from '../deleteSubChannel';
+import { onSubChannelDeleted } from '../../events';
+
 const subChannelId = 'channelId11--sub-channel-id';
 
 describe('createSubChannel', () => {
-  beforeEach(enableCache);
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
 
+  beforeEach(enableCache);
   afterEach(disableCache);
 
   // integration_test_id: 43ba1273-4560-4cea-93ce-cf5728b2a475