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

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

@@ -0,0 +1,257 @@
+import { ASCApiError } from '~/core/errors';
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+
+import { client, convertRawMessage, generateRawMessage, pause } from '~/utils/tests';
+import { createQuery, runQuery } from '~/core/query';
+
+import { onMessageCreatedMqtt } from '../../events';
+import { createMessage } from '../createMessage';
+import * as getMessageMarkers from '../../../marker/api/getMessageMarkers';
+
+const rawMessageToCreate = generateRawMessage();
+const messageToCreate = convertRawMessage(rawMessageToCreate);
+const { messageId, uniqueId, ...messageWithoutId } = messageToCreate;
+
+describe('createMessage', () => {
+  beforeAll(() => {
+    jest.spyOn(getMessageMarkers, 'getMessageMarkers').mockImplementation(() =>
+      Promise.resolve({
+        data: [],
+        cachedAt: undefined,
+      }),
+    );
+  });
+
+  const bundle = {
+    data: messageToCreate.data,
+    dataType: messageToCreate.dataType,
+    referenceId: 'LOCAL_xxx',
+    subChannelId: messageToCreate.subChannelId,
+  };
+
+  const response = {
+    data: { messages: [rawMessageToCreate] },
+  };
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  // integration_test_id: 9691969d-6ba8-4af6-93d6-dfe9134e9796
+  test('should return created message', async () => {
+    client.http.post = jest.fn().mockResolvedValue(response);
+
+    const { data: created } = await createMessage(bundle);
+
+    expect(created).toMatchObject(messageToCreate);
+    expect(created.uniqueId).toBeDefined();
+  });
+
+  // integration_test_id: acc3be84-9234-4af1-88a1-cbb517fa247f
+  test('should throw an 404300 if user has no permission', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('forbidden', Amity.ServerError.FORBIDDEN, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(createMessage(messageWithoutId)).rejects.toThrow('400300');
+  });
+
+  test('should put message into cache', async () => {
+    client.http.post = jest.fn().mockResolvedValue(response);
+
+    const { data: created } = await createMessage(bundle);
+
+    const cache = pullFromCache(['message', 'get', created.messageId]);
+    expect(cache).toMatchObject({ data: messageWithoutId });
+  });
+
+  test('should fire event `onMessageCreated`', async () => {
+    let dispose;
+    client.http.post = jest.fn().mockResolvedValueOnce(response);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageCreatedMqtt(resolve);
+    }).finally(dispose);
+
+    await createMessage(messageWithoutId);
+
+    await expect(callbackPromise).resolves.toMatchObject(messageWithoutId);
+  });
+});
+
+// TODO: fix this test, because createMessage.optimistically is not exist anymore
+describe('createMessage.optimistically', () => {
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('should create cache after created message', () => {
+    const optimisticId = createMessage.optimistically(messageWithoutId)?.data?.messageId;
+    const received = pullFromCache(['message', 'get', optimisticId])?.data;
+
+    expect(received).toMatchObject(messageWithoutId);
+  });
+
+  describe('should increase message count after create message', () => {
+    test('in sub channel', () => {
+      const { channelId, subChannelId } = messageWithoutId;
+      pushToCache(['channel', 'get', channelId], { channelId, messageCount: 2 });
+      pushToCache(['subChannel', 'get', subChannelId], {
+        channelId,
+        subChannelId,
+        messageCount: 2,
+      });
+
+      createMessage.optimistically(messageWithoutId);
+
+      const cacheSubChannel = pullFromCache<Amity.SubChannel>([
+        'subChannel',
+        'get',
+        subChannelId,
+      ])?.data;
+
+      expect(cacheSubChannel?.messageCount).toBe(3);
+    });
+
+    test('in channel if message created in main sub channel', () => {
+      const { subChannelId } = messageWithoutId;
+      pushToCache(['channel', 'get', subChannelId], { channelId: subChannelId, messageCount: 2 });
+      pushToCache(['subChannel', 'get', subChannelId], {
+        channelId: subChannelId,
+        subChannelId,
+        messageCount: 2,
+      });
+
+      createMessage.optimistically(messageWithoutId);
+
+      const cacheChannel = pullFromCache<Amity.StaticInternalChannel>([
+        'channel',
+        'get',
+        subChannelId,
+      ])?.data;
+      expect(cacheChannel?.messageCount).toBe(3);
+    });
+  });
+
+  test('should fire event `onMessageCreated`', async () => {
+    let dispose;
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageCreatedMqtt(resolve);
+    }).finally(dispose);
+
+    createMessage.optimistically(messageWithoutId);
+
+    await expect(callbackPromise).resolves.toMatchObject(messageWithoutId);
+  });
+
+  test('should define object as unsynced object', async () => {
+    expect(createMessage.optimistically(messageWithoutId)?.cachedAt).toEqual(
+      UNSYNCED_OBJECT_CACHED_AT_VALUE,
+    );
+  });
+});
+
+describe('uniqueId / referenceId', () => {
+  const bundle = {
+    data: messageToCreate.data,
+    dataType: messageToCreate.dataType,
+    subChannelId: messageToCreate.subChannelId,
+  };
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  it('should optimistically create message with uniqueId', () => {
+    const { data: message } = createMessage.optimistically(bundle)!;
+
+    expect(message.uniqueId).toBeDefined();
+    expect(message.uniqueId).toEqual(message.messageId);
+  });
+
+  it('should update messageId, retain uniqueId if optimistic message is in cache', async () => {
+    const { data: optimisticMessage } = createMessage.optimistically(bundle)!;
+    client.http.post = jest.fn().mockResolvedValue({
+      data: { messages: [{ ...rawMessageToCreate, referenceId: optimisticMessage.uniqueId }] },
+    });
+
+    const { data: message } = await createMessage(bundle);
+
+    expect(client.http.post as jest.Mock).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ referenceId: optimisticMessage.uniqueId }),
+    );
+    expect(message.uniqueId).toEqual(optimisticMessage.uniqueId);
+    expect(message.uniqueId).not.toEqual(message.messageId);
+    expect(pullFromCache(['message', 'get', optimisticMessage.uniqueId])).toBeUndefined();
+    expect(pullFromCache(['message', 'get', message.messageId])).toMatchObject({ data: message });
+  });
+
+  it('should set uniqueId to messageId if optimistic message is not in cache', async () => {
+    const rawNewMessage = {
+      ...rawMessageToCreate,
+      messageId: 'new-message-id',
+      referenceId: 'LOCAL_new-message-id',
+    };
+    const callback = jest.fn();
+
+    onMessageCreatedMqtt(callback);
+    client.emitter.emit('message.created', {
+      messages: [rawNewMessage],
+      messageFeeds: [],
+      files: [],
+      users: [],
+      reactions: [],
+    });
+    await pause();
+
+    expect(callback).toHaveBeenCalledWith(
+      expect.objectContaining({
+        messageId: rawNewMessage.messageId,
+        uniqueId: rawNewMessage.messageId,
+      }),
+    );
+  });
+
+  it('should pass referenceId if cache is turned off', async () => {
+    disableCache();
+    client.http.post = jest.fn().mockResolvedValue({ data: { messages: [rawMessageToCreate] } });
+
+    runQuery(createQuery(createMessage, bundle));
+    await pause();
+
+    expect(client.http.post).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({
+        referenceId: expect.stringMatching(/LOCAL_/),
+      }),
+    );
+  });
+
+  describe('custom referenceId', () => {
+    it('should handle custom referenceId for optimistic message', () => {
+      const referenceId = 'custom-reference-id';
+
+      const { data: message } = createMessage.optimistically({ ...bundle, referenceId })!;
+
+      expect(message.uniqueId).toEqual(referenceId);
+    });
+
+    it('should handle custom referenceId if cache is turned off', async () => {
+      disableCache();
+      const referenceId = 'custom-reference-id';
+      client.http.post = jest.fn().mockResolvedValue({ data: { messages: [rawMessageToCreate] } });
+
+      runQuery(createQuery(createMessage, { ...bundle, referenceId }));
+      await pause();
+
+      expect(client.http.post).toHaveBeenCalledWith(
+        expect.anything(),
+        expect.objectContaining({ referenceId }),
+      );
+    });
+  });
+});

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

@@ -0,0 +1,127 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, generateRawMessage } from '~/utils/tests';
+
+import { softDeleteMessage } from '../softDeleteMessage';
+import { onMessageDeleted } from '../../events';
+import { convertFromRaw } from '../../utils';
+
+const rawMessageToDelete = generateRawMessage();
+const messageToDelete = convertFromRaw(rawMessageToDelete);
+const { messageId: deleteId } = messageToDelete;
+const rawDeletedMessage = { ...rawMessageToDelete, isDeleted: true };
+const deletedMessage = convertFromRaw(rawDeletedMessage);
+
+const getResolvedMessageValue = () => ({
+  data: {
+    messages: [rawDeletedMessage],
+    users: [],
+    files: [],
+  },
+});
+
+describe('softDeleteMessage', () => {
+  // integration_test_id: 16106137-0e4a-4d2f-b8cf-1a6c571bf0c7
+  test('should return deleted message', async () => {
+    client.http.delete = jest.fn();
+    client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    await expect(softDeleteMessage(deleteId)).resolves.toEqual(deletedMessage);
+  });
+
+  // integration_test_id: 27d393d9-480e-4eec-bfdb-f04738801b04
+  test('should return 400400 if message not found', async () => {
+    client.http.delete = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(softDeleteMessage(deleteId)).rejects.toThrow('400400');
+  });
+
+  test('should update cache after deleted messages', async () => {
+    enableCache();
+    client.http.delete = jest.fn();
+    client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+    pushToCache(['message', 'get', deleteId], messageToDelete);
+
+    await softDeleteMessage(deleteId);
+    const recieved = pullFromCache<Amity.Message>(['message', 'get', deleteId])?.data;
+
+    expect(recieved).toEqual(deletedMessage);
+
+    disableCache();
+  });
+
+  test('should fire event `onMessageDeleted`', async () => {
+    let dispose;
+    client.http.delete = jest.fn();
+    client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageDeleted(resolve);
+    }).finally(dispose);
+
+    await softDeleteMessage(deleteId);
+
+    await expect(callbackPromise).resolves.toEqual(deletedMessage);
+  });
+});
+
+describe('softDeleteMessage.optimistically', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
+
+  test('should update `isDeleted` in cache after deleted message', () => {
+    pushToCache(['message', 'get', deleteId], messageToDelete);
+
+    softDeleteMessage.optimistically(deleteId);
+    const recieved = pullFromCache<Amity.Message>(['message', 'get', deleteId])?.data;
+
+    expect(recieved).toEqual({
+      ...deletedMessage,
+      updatedAt: expect.anything(),
+    });
+  });
+
+  /* TODO: re-enable this after fixed channel message count calculation */
+  test.skip('should decrease message count after deleted message', () => {
+    const { channelId } = messageToDelete;
+    pushToCache(['channel', 'get', channelId], { channelId, messageCount: 2 });
+    pushToCache(['message', 'get', deleteId], { ...messageToDelete, channelId });
+
+    softDeleteMessage.optimistically(deleteId);
+    const recieved = pullFromCache<Amity.StaticInternalChannel>([
+      'channel',
+      'get',
+      channelId,
+    ])?.data;
+
+    expect(recieved?.messageCount).toBe(1);
+  });
+
+  test('should fire event `onMessageDeleted`', async () => {
+    pushToCache(['message', 'get', deleteId], messageToDelete);
+    let dispose;
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageDeleted(data => {
+        resolve(data);
+      });
+    }).finally(dispose);
+
+    softDeleteMessage.optimistically(deleteId);
+
+    await expect(callbackPromise).resolves.toEqual({
+      ...deletedMessage,
+      updatedAt: expect.anything(),
+    });
+  });
+
+  test('should define object as unsynced object', () => {
+    pushToCache(['message', 'get', deleteId], messageToDelete);
+
+    expect(softDeleteMessage.optimistically(deleteId)?.cachedAt).toBe(-1);
+  });
+});

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

@@ -0,0 +1,108 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, generateRawMessage } from '~/utils/tests';
+
+import { editMessage } from '../editMessage';
+import { onMessageUpdated } from '../../events';
+import { convertFromRaw } from '../../utils';
+
+const rawMessageToUpdate = generateRawMessage();
+const messageToUpdate = convertFromRaw(rawMessageToUpdate);
+const { messageId } = messageToUpdate;
+const patch = { data: { text: 'hello world' } };
+const rawUpdatedMessage = { ...rawMessageToUpdate, ...patch };
+const updatedMessage = convertFromRaw(rawUpdatedMessage);
+
+const getResolvedMessageValue = () => ({
+  data: {
+    messages: [rawUpdatedMessage],
+    users: [],
+    files: [],
+  },
+});
+
+describe('editMessage', () => {
+  // integration_test_id: 3ae17ea2-dee5-4418-88af-fe809ee48a52
+  test('should return updated message', async () => {
+    client.http.put = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    const recieved = editMessage(messageId, patch);
+
+    await expect(recieved).resolves.toEqual(expect.objectContaining({ data: updatedMessage }));
+  });
+
+  // integration_test_id: 3ae17ea2-dee5-4418-88af-fe809ee48a52
+  test('should throw an error if request fails', async () => {
+    client.http.put = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('not found', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(editMessage(messageId, patch)).rejects.toThrow('400400');
+  });
+
+  test('should update cache after updated messages', async () => {
+    enableCache();
+    client.http.put = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    await editMessage(messageId, patch);
+    const recieved = pullFromCache<Amity.Message>(['message', 'get', messageId])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(patch));
+
+    disableCache();
+  });
+
+  test('should fire event `onMessageUpdated`', async () => {
+    let dispose;
+    client.http.put = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageUpdated(resolve);
+    }).finally(dispose);
+
+    await editMessage(messageId, patch);
+
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(updatedMessage));
+  });
+});
+
+describe('editMessage.optimistically', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
+
+  test('should update cache after updated message', () => {
+    pushToCache(['message', 'get', messageId], messageToUpdate);
+
+    editMessage.optimistically(messageId, patch);
+    const recieved = pullFromCache<Amity.Message>(['message', 'get', messageId])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(patch));
+  });
+
+  test('should fire event `onMessageUpdated`', async () => {
+    let dispose;
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageUpdated(data => {
+        resolve(data);
+      });
+    }).finally(dispose);
+
+    editMessage.optimistically(messageId, patch);
+
+    await expect(callbackPromise).resolves.toEqual(
+      expect.objectContaining({
+        ...updatedMessage,
+        updatedAt: expect.anything(),
+      }),
+    );
+  });
+
+  test('should define object as unsynced object', () => {
+    pushToCache(['message', 'get', messageId], messageToUpdate);
+
+    expect(editMessage.optimistically(messageId, patch)?.cachedAt).toBe(-1);
+  });
+});

package/src/messageRepository/api/tests/flagMessage.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 { flagMessage } from '..';
+import { convertFromRaw } from '../../utils';
+
+jest.mock('~/core/events', () => ({
+  __esModule: true,
+  ...jest.requireActual('~/core/events'),
+  fireEvent: jest.fn(),
+}));
+
+const flaggedRawMessage = generateRawMessage({ flagCount: 1 });
+const message = convertFromRaw(flaggedRawMessage);
+const { messageId } = flaggedRawMessage;
+
+const flaggedMessageQueryResponse = {
+  data: {
+    messages: [flaggedRawMessage],
+    users: [user11],
+  },
+};
+
+describe('flagMessage', () => {
+  beforeEach(disableCache);
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  // integration_test_id: fd507b43-99e7-4aed-816d-d51d357d303b
+  test('it should flag message with messageId', async () => {
+    const expected = true;
+    client.http.post = jest.fn().mockResolvedValue(flaggedMessageQueryResponse);
+
+    const received = await flagMessage(messageId);
+
+    expect(received).toBe(expected);
+  });
+
+  // integration_test_id: 0c78c9fd-1d4e-4af7-ad6b-e76372addb2f
+  test('it should throw error with 400400 when sending invalid messageId', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('unauthorized', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(flagMessage(messageId)).rejects.toThrow('400400');
+  });
+
+  test('it should call fire event method', async () => {
+    client.http.post = jest.fn().mockResolvedValue(flaggedMessageQueryResponse);
+
+    const recieved = await flagMessage(messageId);
+    const [recievedMqttString] = (fireEvent as jest.Mock).mock.lastCall;
+
+    expect(recieved).toBe(true);
+    expect(recievedMqttString).toBe('message.flagged');
+  });
+
+  test('it should call the appropriate api', async () => {
+    const apimock = jest.fn();
+    const expected = `/api/v5/messages/${encodeURIComponent('messageId')}/flags`;
+
+    client.http.post = apimock.mockResolvedValue({ data: {} });
+
+    await flagMessage('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.post = jest.fn().mockResolvedValue(flaggedMessageQueryResponse);
+
+    await flagMessage(messageId);
+    const recieved = pullFromCache(['message', 'get', messageId]);
+
+    expect(recieved?.data).toStrictEqual(expected);
+
+    disableCache();
+  });
+});