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

package/src/messageRepository/api/tests/getMessage.test.ts

@@ -0,0 +1,138 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { isInTombstone } from '~/cache/api/isInTombstone';
+import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { ASCApiError } from '~/core/errors';
+import { client, convertRawMessage, generateRawMessage } from '~/utils/tests';
+
+import { getMessage } from '../getMessage';
+import { onMessageFetched } from '../../events/onMessageFetched';
+import * as getMessageMarkers from '../../../marker/api/getMessageMarkers';
+
+const rawMessageToGet = generateRawMessage();
+const messageToGet = convertRawMessage(rawMessageToGet);
+const { messageId } = messageToGet;
+
+const getResolvedMessageValue = () => ({
+  data: {
+    messages: [rawMessageToGet],
+    users: [],
+    files: [],
+  },
+});
+
+describe('getMessage', () => {
+  beforeAll(() => {
+    jest.spyOn(getMessageMarkers, 'getMessageMarkers').mockImplementation(() =>
+      Promise.resolve({
+        data: [],
+        cachedAt: undefined,
+      }),
+    );
+  });
+
+  // integration_test_id: bc048747-17ea-43fe-9f97-7b2bf008c476
+  test('should return fetched message', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    await expect(getMessage(messageId)).resolves.toEqual(
+      expect.objectContaining({ data: messageToGet }),
+    );
+  });
+
+  test('should update cache after fetching message', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(getResolvedMessageValue());
+
+    await getMessage(messageId);
+    const recieved = pullFromCache(['message', 'get', messageId])?.data;
+
+    expect(recieved).toEqual(messageToGet);
+
+    disableCache();
+  });
+
+  // integration_test_id: 81375153-2886-46e0-a164-7f3902e77b55
+  test('should return 400300 if unauthorized', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('forbidden', Amity.ServerError.FORBIDDEN, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getMessage(messageId)).rejects.toThrow('400300');
+  });
+
+  test('should fire event `onMessageFetched`', async () => {
+    let dispose;
+    client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageFetched(resolve);
+    }).finally(dispose);
+
+    await getMessage(messageId);
+
+    await expect(callbackPromise).resolves.toEqual(messageToGet);
+  });
+});
+
+describe('getMessage tombostone', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
+
+  test('should add message to tombostone if 404', async () => {
+    expect.assertions(2);
+
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getMessage(messageId)).rejects.toThrow();
+
+    expect(() => isInTombstone('message', messageId)).toThrow();
+  });
+
+  test('should throw error if message not found in tombostone', async () => {
+    pushToTombstone('message', messageId);
+
+    await expect(getMessage(messageId)).rejects.toThrow();
+  });
+});
+
+describe('getMessage.locally', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
+
+  test('should return cached message', () => {
+    pushToCache(['message', 'get', messageId], messageToGet);
+
+    expect(getMessage.locally(messageId)?.data).toBe(messageToGet);
+  });
+
+  test('it should return undefined if message not in cache', () => {
+    expect(getMessage.locally('non-existent-message')).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    disableCache();
+    pushToCache(['message', 'get', messageId], messageToGet);
+
+    expect(getMessage.locally(messageId)).toBeUndefined();
+  });
+
+  test('should return undefined if 404', async () => {
+    expect.assertions(2);
+    pushToCache(['message', 'get', messageId], messageToGet);
+
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found!', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(getMessage(messageId)).rejects.toThrow();
+    expect(getMessage.locally(messageId)).toBeUndefined();
+  });
+});

package/src/messageRepository/api/tests/getMessages.test.ts

@@ -0,0 +1,116 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { client, convertRawMessage, generateRawMessage } from '~/utils/tests';
+
+import { getMessages } from '../getMessages';
+import { onMessageFetched } from '../../events/onMessageFetched';
+import * as getMessageMarkers from '../../../marker/api/getMessageMarkers';
+
+const rawMessagesToGet = [generateRawMessage(), generateRawMessage({ messageId: 'message-id-2' })];
+const messagesToGet = rawMessagesToGet.map(convertRawMessage);
+const messageIds = messagesToGet.map(x => x.messageId);
+
+const getResolvedMessageValue = () => ({
+  data: {
+    messages: rawMessagesToGet,
+    users: [],
+    files: [],
+  },
+});
+
+describe('getMessages', () => {
+  beforeAll(() => {
+    jest.spyOn(getMessageMarkers, 'getMessageMarkers').mockImplementation(() =>
+      Promise.resolve({
+        data: [],
+        cachedAt: undefined,
+      }),
+    );
+  });
+
+  test('should return fetched messages', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    await expect(getMessages(messageIds)).resolves.toEqual(
+      expect.objectContaining({ data: messagesToGet }),
+    );
+  });
+
+  test('should update cache after fetching messages', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(getResolvedMessageValue());
+
+    await getMessages(messageIds);
+
+    const recieved = messageIds.map(
+      messageId => pullFromCache(['message', 'get', messageId])?.data,
+    );
+
+    expect(recieved).toEqual(messagesToGet);
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(getMessages(messageIds)).rejects.toThrow('error');
+  });
+
+  test('should fire event `onMessageFetched`', async () => {
+    let dispose;
+    client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageFetched(resolve);
+    }).finally(dispose);
+
+    await getMessages(messageIds);
+    await expect(callbackPromise).resolves.toEqual(messagesToGet[0]);
+  });
+});
+
+describe('getMessages tombostone', () => {
+  test.todo('should add messages to tombostone if 404');
+  test.todo('should throw error if messages not found in tombostone');
+});
+
+describe('getMessages.locally', () => {
+  beforeEach(enableCache);
+  afterEach(enableCache);
+
+  test('should return cached messages', () => {
+    messagesToGet.forEach(message => pushToCache(['message', 'get', message.messageId], message));
+
+    expect(getMessages.locally(messageIds)?.data).toEqual(messagesToGet);
+  });
+
+  test('it should return undefined if message not in cache', () => {
+    expect(getMessages.locally(['non-existent-message'])).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    disableCache();
+    messagesToGet.forEach(message => pushToCache(['message', 'get', message.messageId], message));
+
+    expect(getMessages.locally(messageIds)).toBeUndefined();
+  });
+
+  /* TODO: re-enable this once tombstone has been implemented */
+  test.skip('should return undefined if 404', async () => {
+    expect.assertions(2);
+
+    const error = new ASCApiError(
+      'not found!',
+      Amity.ServerError.ITEM_NOT_FOUND,
+      Amity.ErrorLevel.ERROR,
+    );
+
+    client.http.get = jest.fn().mockRejectedValueOnce(error);
+    messagesToGet.forEach(message => pushToCache(['message', 'get', message.messageId], message));
+
+    await expect(getMessages(messageIds)).rejects.toThrow();
+
+    expect(getMessages.locally(messageIds)).toBeUndefined();
+  });
+});

package/src/messageRepository/api/tests/markAsDelivered.test.ts

@@ -0,0 +1,90 @@
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  generateFeedMarker,
+  generateUserMarkerResponse,
+  generateChannelMarker,
+  generateSubChannelMarker,
+  activeUser,
+  generateUserMarker,
+  generateChannelMarkerResponse,
+  generateSubChannelMarkerResponse,
+} from '~/utils/tests';
+
+import { markAsDelivered } from '../markAsDelivered';
+
+const { userId } = activeUser;
+const entityId = 'feed1';
+const feedId = 'sub-ch1';
+const messageId = 'message1';
+
+const userMarkersResponse = generateUserMarkerResponse({ userId });
+const channelMarkersResponse = generateChannelMarkerResponse({ userId, entityId });
+const subChannelMarkerResponse = generateSubChannelMarkerResponse({ userId, feedId, entityId });
+
+const expectedUserMarker = generateUserMarker({ userId });
+const expectedChannelMarker = generateChannelMarker({ userId, entityId });
+const expectedSubChannelMarker = generateSubChannelMarker({ userId, feedId, entityId });
+const expectedFeedMarker = generateFeedMarker({ feedId, entityId });
+
+const resolvedPutValue = {
+  data: {
+    userMarkers: [userMarkersResponse],
+    userEntityMarkers: [channelMarkersResponse],
+    userFeedMarkers: [subChannelMarkerResponse],
+    feedMarkers: [expectedFeedMarker],
+  } as Amity.MarkDeliveredPayload,
+};
+
+describe('markAsDelivered', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should return `true`', async () => {
+    client.http.put = jest.fn().mockResolvedValueOnce(resolvedPutValue);
+
+    const recieved = await markAsDelivered(feedId, messageId);
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should update cache', async () => {
+    expect.assertions(4);
+    enableCache();
+
+    client.http.put = jest.fn().mockResolvedValueOnce(resolvedPutValue);
+
+    await markAsDelivered(feedId, messageId);
+
+    const recievedUserMarkerCache = pullFromCache(['userMarker', 'get', userId]);
+
+    const recievedChannelMarkerCache = pullFromCache([
+      'channelMarker',
+      'get',
+      getResolver('channelMarker')({ entityId, userId }),
+    ]);
+
+    const recievedSubChannelMarkerCache = pullFromCache([
+      'subChannelMarker',
+      'get',
+      getResolver('subChannelMarker')({ entityId, feedId, userId }),
+    ]);
+
+    const recievedFeedMarkerCache = pullFromCache([
+      'feedMarker',
+      'get',
+      getResolver('feedMarker')({ entityId, feedId }),
+    ]);
+
+    expect(recievedUserMarkerCache?.data).toStrictEqual(expectedUserMarker);
+    expect(recievedChannelMarkerCache?.data).toStrictEqual(expectedChannelMarker);
+    expect(recievedSubChannelMarkerCache?.data).toStrictEqual(expectedSubChannelMarker);
+    expect(recievedFeedMarkerCache?.data).toStrictEqual(expectedFeedMarker);
+
+    disableCache();
+  });
+});

package/src/messageRepository/api/tests/queryMessages.test.ts

@@ -0,0 +1,118 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, convertRawMessage, generateRawMessage } from '~/utils/tests';
+
+import { convertQueryParams } from '../../utils';
+import { queryMessages } from '../queryMessages';
+import { onMessageFetched } from '../../events/onMessageFetched';
+import * as getMessageMarkers from '../../../marker/api/getMessageMarkers';
+
+const rawMessagesToQuery = [
+  generateRawMessage(),
+  generateRawMessage({ messageId: 'message-id-2' }),
+];
+
+const messagesToQuery = rawMessagesToQuery.map(convertRawMessage);
+const messageIds = messagesToQuery.map(x => x.messageId);
+const queryCriteriaWithoutPage = { subChannelId: messagesToQuery[0].subChannelId };
+const queryCriteria = { ...queryCriteriaWithoutPage, page: { limit: 10 } };
+const paging = {
+  next: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+};
+const nextPage = { before: 63471614391111000000, limit: 2 };
+
+const getResolvedMessageValue = () => ({
+  data: {
+    messages: rawMessagesToQuery,
+    files: [],
+    users: [],
+    paging,
+  },
+});
+
+describe('queryMessages', () => {
+  beforeAll(() => {
+    jest.spyOn(getMessageMarkers, 'getMessageMarkers').mockImplementation(() =>
+      Promise.resolve({
+        data: [],
+        cachedAt: undefined,
+      }),
+    );
+  });
+
+  test('should return fetched messages with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    await expect(queryMessages(queryCriteria)).resolves.toEqual(
+      expect.objectContaining({
+        data: messagesToQuery,
+        nextPage,
+        prevPage: undefined,
+      }),
+    );
+  });
+
+  test('should update cache after fetching messages', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(getResolvedMessageValue());
+
+    await queryMessages(queryCriteria);
+
+    const recieved = pullFromCache(['message', 'query', convertQueryParams(queryCriteria)])?.data;
+
+    expect(recieved).toEqual({
+      messages: messageIds,
+      paging,
+    });
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryMessages(queryCriteria)).rejects.toThrow('error');
+  });
+
+  test('should fire event `onMessageFetched`', async () => {
+    let dispose;
+
+    client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageFetched(resolve);
+    }).finally(dispose);
+
+    await queryMessages(queryCriteria);
+    await expect(callbackPromise).resolves.toEqual(messagesToQuery[0]);
+  });
+
+  test('it should set isDeleted to undefined if includeDeleted is true', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(getResolvedMessageValue());
+
+    await queryMessages({ ...queryCriteriaWithoutPage, includeDeleted: true });
+
+    expect(mockFn.mock.lastCall).toHaveLength(2);
+    expect(mockFn.mock.lastCall[1].params.isDeleted).toBeUndefined();
+  });
+
+  test('it should set isDeleted to false if includeDeleted is false', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(getResolvedMessageValue());
+
+    await queryMessages({ ...queryCriteriaWithoutPage, includeDeleted: false });
+
+    expect(mockFn.mock.lastCall).toHaveLength(2);
+    expect(mockFn.mock.lastCall[1].params.isDeleted).toBe(false);
+  });
+
+  test('it should set isDeleted to false if includeDeleted is undefined', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(getResolvedMessageValue());
+
+    await queryMessages(queryCriteriaWithoutPage);
+
+    expect(mockFn.mock.lastCall).toHaveLength(2);
+    expect(mockFn.mock.lastCall[1].params.isDeleted).toBe(false);
+  });
+});

package/src/messageRepository/api/tests/unflagMessage.test.ts

@@ -0,0 +1,87 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { client, connectClient, disconnectClient, generateRawMessage, user11 } from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+import { fireEvent } from '~/core/events';
+
+import { unflagMessage } from '..';
+import { convertFromRaw } from '../../utils';
+
+jest.mock('~/core/events', () => ({
+  __esModule: true,
+  ...jest.requireActual('~/core/events'),
+  fireEvent: jest.fn(),
+}));
+
+const unflaggedRawMessage = generateRawMessage();
+const message = convertFromRaw(unflaggedRawMessage);
+const { messageId } = unflaggedRawMessage;
+
+const unflaggedMessageQueryResponse = {
+  data: {
+    messages: [unflaggedRawMessage],
+    users: [user11],
+  },
+};
+
+describe('unflagMessage', () => {
+  beforeEach(disableCache);
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  // integration_test_id: afb432ec-52eb-49d7-8054-c162e3b60535
+  test('it should unflag message with messageId', async () => {
+    const expected = true;
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedMessageQueryResponse);
+
+    const received = await unflagMessage(messageId);
+
+    expect(received).toBe(expected);
+  });
+
+  // integration_test_id: 5c6b5a0a-628d-4834-8453-d11df656dea8
+  test('it should throw error with 400400 when sending invalid messageId', async () => {
+    client.http.delete = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('unauthorized', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(unflagMessage(messageId)).rejects.toThrow('400400');
+  });
+
+  test('it should call fire event method', async () => {
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedMessageQueryResponse);
+
+    const recieved = await unflagMessage(messageId);
+    const [recievedMqttString] = (fireEvent as jest.Mock).mock.lastCall;
+
+    expect(recieved).toBe(true);
+    expect(recievedMqttString).toBe('message.unflagged');
+  });
+
+  test('it should call the appropriate api', async () => {
+    const apimock = jest.fn();
+    const expected = `/api/v5/messages/${encodeURIComponent('messageId')}/flags`;
+
+    client.http.delete = apimock.mockResolvedValue({ data: {} });
+
+    await unflagMessage('messageId');
+
+    const received = apimock.mock.lastCall[0];
+
+    expect(received).toBe(expected);
+  });
+
+  test('it should add data to cache', async () => {
+    enableCache();
+    const expected = message;
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedMessageQueryResponse);
+
+    await unflagMessage(messageId);
+    const recieved = pullFromCache(['message', 'get', messageId]);
+
+    expect(recieved?.data).toStrictEqual(expected);
+
+    disableCache();
+  });
+});

package/src/messageRepository/api/unflagMessage.ts

@@ -0,0 +1,40 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { fireEvent } from '~/core/events';
+import { prepareMessagePayload } from '~/messageRepository/utils';
+
+/* begin_public_function
+  id: message.unflag
+*/
+/**
+ * ```js
+ * import { MessageRepository } from '@amityco/ts-sdk'
+ * const unflagged = await MessageRepository.unflag(messageId)
+ * ```
+ *
+ * @param messageId of the message to unflag
+ * @returns boolean to indicate success
+ *
+ * @category Report API
+ * @async
+ * */
+export const unflagMessage = async (messageId: Amity.Message['messageId']): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('message/unflag', messageId);
+
+  const { data: payload } = await client.http.delete<Amity.MessagePayload>(
+    `/api/v5/messages/${encodeURIComponent(messageId)}/flags`,
+  );
+
+  if (client.cache) {
+    const messagePayload = await prepareMessagePayload(payload);
+    ingestInCache(messagePayload);
+  }
+
+  fireEvent('message.unflagged', payload);
+
+  return !!payload;
+};
+/* end_public_function */

package/src/messageRepository/api/updateMessage.ts

@@ -0,0 +1,105 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { pullFromCache, upsertInCache } from '~/cache/api';
+import { fireEvent } from '~/core/events';
+
+import { convertParams, prepareMessagePayload } from '../utils';
+import { LinkedObject } from '~/utils/linkedObject';
+
+/* begin_public_function
+  id: message.edit
+*/
+/**
+ * ```js
+ * import { updateMessage } from '@amityco/ts-sdk'
+ * const updated = await updateMessage(messageId, {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Message}
+ *
+ * @param messageId The ID of the {@link Amity.Message} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Message} object
+ *
+ * @category Message API
+ * @async
+ */
+export const updateMessage = async (
+  messageId: Amity.Message['messageId'],
+  patch: Patch<Amity.Message, 'data' | 'tags' | 'metadata' | 'mentionees'>,
+): Promise<Amity.Cached<Amity.Message>> => {
+  const client = getActiveClient();
+  client.log('message/updateMessage', patch);
+
+  console.warn(
+    'MessageRepository.updateMessage will be replaced with MessageRepository.editMessage',
+  );
+
+  const { data: payload } = await client.http.put<Amity.MessagePayload>(
+    `/api/v5/messages/${encodeURIComponent(messageId)}`,
+    convertParams(patch),
+  );
+
+  const data = await prepareMessagePayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { messages } = data;
+
+  fireEvent('local.message.updated', { messages });
+
+  return {
+    data: LinkedObject.message(messages.find(message => message.messageId === messageId)!),
+    cachedAt,
+  };
+};
+
+/**
+ * ```js
+ * import { updateMessage } from '@amityco/ts-sdk'
+ * const updated = updateMessage.optimistically('foobar', {
+ *   data: { text: 'hello world' }
+ * })
+ * ```
+ *
+ * Updates an {@link Amity.Message} in cache
+ *
+ * @param messageId The ID of the {@link Amity.Message} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Message} object
+ *
+ * @category Message API
+ */
+updateMessage.optimistically = (
+  messageId: Amity.Message['messageId'],
+  patch: Patch<Amity.Message, 'data' | 'tags' | 'metadata' | 'mentionees'>,
+): Amity.Cached<Amity.Message> | undefined => {
+  const client = getActiveClient();
+  client.log('message/updateMessage.optimistically', patch);
+
+  if (!client.cache) return;
+
+  const message = pullFromCache<Amity.InternalMessage>(['message', 'get', messageId]);
+
+  if (!message) return;
+
+  const cachedAt = -1;
+  const updated: Amity.InternalMessage = {
+    ...message.data,
+    ...patch,
+    updatedAt: new Date().toISOString(),
+  };
+
+  upsertInCache(['message', 'get', messageId], updated, { cachedAt });
+  fireEvent('local.message.updated', { messages: [updated] });
+
+  return {
+    data: LinkedObject.message(updated),
+    cachedAt,
+  };
+};
+/* end_public_function */