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

package/src/message/events/onMessageUpdated.ts

@@ -1,8 +1,10 @@
+import { pullFromCache, upsertInCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
 import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
-import { prepareMessagePayload } from '../utils';
+
+import { prepareMessagePayload, updateMessageMarker } from '../utils';
 
 /**
  * ```js
@@ -22,18 +24,38 @@ import { prepareMessagePayload } from '../utils';
 export const onMessageUpdated = (callback: Amity.Listener<Amity.Message>): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (rawPayload: Amity.MessagePayload) => {
-    const payload = prepareMessagePayload(rawPayload);
+  const filter = async (rawPayload: Amity.MessagePayload) => {
+    const payload = await prepareMessagePayload(rawPayload);
 
     ingestInCache(payload);
     callback(payload.messages[0]);
   };
 
+  const messageMarkerChangeHandler = async (
+    rawPayload: MakeRequired<Amity.MessageMarkerPayload, 'contentMarkers'>,
+  ) => {
+    const marker = rawPayload.contentMarkers[0];
+    const cacheKey = ['message', 'get', marker.contentId];
+    const message = pullFromCache<Amity.Message>(cacheKey)?.data;
+
+    if (!message) return;
+
+    const updated = updateMessageMarker(message, marker);
+    upsertInCache(cacheKey, updated);
+    callback(updated);
+  };
+
   const disposers = [
-    createEventSubscriber(client, 'message/onMessageUpdated', 'message.updated', filter),
-    createEventSubscriber(client, 'local.message.updated', 'local.message.updated', payload =>
+    createEventSubscriber(client, 'onMessageUpdated', 'message.updated', filter),
+    createEventSubscriber(client, 'onMessageUpdated', 'local.message.updated', payload =>
       callback(payload.messages[0]),
     ),
+    createEventSubscriber(
+      client,
+      'onMessageUpdated',
+      'local.messageMarker.fetched',
+      messageMarkerChangeHandler,
+    ),
   ];
 
   return () => {

package/src/message/tests/events.test.ts

@@ -1,4 +1,4 @@
-import { client, generateRawMessage } from '~/utils/tests';
+import { client, generateRawMessage, pause } from '~/utils/tests';
 import { convertFromRaw } from '~/message/utils';
 import {
   onMessageCreated,
@@ -29,7 +29,7 @@ describe('Message Events', () => {
   ];
 
   cases.forEach(([onEvent, event]) => {
-    test(`should call '${onEvent.name}' callback if '${event}' event is dispatched`, () => {
+    test(`should call '${onEvent.name}' callback if '${event}' event is dispatched`, async () => {
       const callback = jest.fn();
       const unsubscribe = onEvent(callback);
       client.emitter.emit(event, {
@@ -38,6 +38,8 @@ describe('Message Events', () => {
         users: [],
       });
 
+      await pause();
+
       unsubscribe();
 
       expect(callback).toHaveBeenCalled();

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

@@ -1,15 +1,22 @@
 import { ASCApiError } from '~/core/errors';
 import { disableCache, enableCache } from '~/cache/api';
 import { UNSYNCED_OBJECT_CACHED_AT_MESSAGE } from '~/utils/constants';
-import { pause, client, connectClient, disconnectClient, generateRawMessage } from '~/utils/tests';
+import {
+  pause,
+  client,
+  connectClient,
+  disconnectClient,
+  generateRawMessage,
+  convertRawMessage,
+} from '~/utils/tests';
 import { getFutureDate } from '~/core/model';
 
-import { convertFromRaw } from '../../utils';
 import { liveMessage } from '../../observers/liveMessage';
 import { createMessage } from '../../api';
+import * as getMessageMarkers from '../../../marker/api/getMessageMarkers';
 
 const rawMessage = generateRawMessage();
-const message = convertFromRaw(rawMessage);
+const message = convertRawMessage(rawMessage);
 const messageQueryResponseRaw = {
   data: { messages: [rawMessage] },
 };
@@ -23,16 +30,20 @@ const getSnapshot = () => {
 };
 
 describe('liveMessage', () => {
-  beforeAll(async () => {
-    await connectClient();
+  beforeAll(() => {
+    connectClient();
+
+    jest.spyOn(getMessageMarkers, 'getMessageMarkers').mockImplementation(() =>
+      Promise.resolve({
+        data: [],
+        cachedAt: undefined,
+      }),
+    );
   });
 
-  afterAll(async () => {
-    await disconnectClient();
-  });
+  afterAll(disconnectClient);
 
   beforeEach(enableCache);
-
   afterEach(disableCache);
 
   const events: [string, keyof Amity.Events][] = [
@@ -47,6 +58,7 @@ describe('liveMessage', () => {
   ];
 
   test.each(events)('%s', async (test, event) => {
+    await disableCache();
     const snapshot = getSnapshot();
 
     // mock response of queryMessages and validate
@@ -64,7 +76,7 @@ describe('liveMessage', () => {
       data: { text: event },
       updatedAt: getFutureDate(rawMessage.updatedAt),
     };
-    const updatedMessage = convertFromRaw(rawUpdatedMessage);
+    const updatedMessage = convertRawMessage(rawUpdatedMessage);
     if (event === 'local.message.fetched') {
       client.emitter.emit('local.message.fetched', { messages: [updatedMessage] });
     } else {

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/post/api/getPosts.ts

@@ -3,6 +3,8 @@ import { getActiveClient } from '~/client/api';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { prepareMembershipPayload } from '~/group/utils';
+import { checkIfShouldGoesToTombstone } from '~/cache/utils';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
 
 /* begin_public_function
   id: post.get_by_ids
@@ -29,10 +31,24 @@ export const getPosts = async (
 
   const encodedPostIds = postIds.map(postId => encodeURIComponent(postId));
 
-  // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data: payload } = await client.http.get<Amity.PostPayload>(`/api/v3/posts/list`, {
-    params: { postIds: encodedPostIds },
-  });
+  let payload: Amity.PostPayload;
+
+  try {
+    // API-FIX: endpoint should not be /list, parameters should be querystring.
+    const response = await client.http.get<Amity.PostPayload>(`/api/v3/posts/list`, {
+      params: { postIds: encodedPostIds },
+    });
+
+    payload = response.data;
+  } catch (error) {
+    postIds.forEach(postId => {
+      if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
+        pushToTombstone('post', postId);
+      }
+    });
+
+    throw error;
+  }
 
   const data = prepareMembershipPayload(payload, 'communityUsers');
 

package/src/post/api/tests/getPosts.test.ts

@@ -0,0 +1,18 @@
+import { getPosts } from '~/post/api';
+import { client, connectClient, disconnectClient, post11, post12 } from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+
+describe('getPosts', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('Should return Error: 400400 when getPosts from invalid postId', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getPosts([post11.postId, post12.postId])).rejects.toThrow();
+  });
+});

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 } =