@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

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

@@ -0,0 +1,211 @@
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+
+import { client, generateRawMessage, pause } from '~/utils/tests';
+
+import { createQuery, runQuery } from '~/core/query';
+import { convertFromRaw } from '../../utils';
+import { onMessageCreated } from '../../events';
+import { createMessage } from '../createMessage';
+
+const rawMessageToCreate = generateRawMessage();
+const messageToCreate = convertFromRaw(rawMessageToCreate);
+const { messageId, uniqueId, ...messageWithoutId } = messageToCreate;
+
+describe('createMessage', () => {
+  const bundle = {
+    data: messageToCreate.data,
+    dataType: messageToCreate.dataType,
+    referenceId: 'LOCAL_xxx',
+    subChannelId: messageToCreate.subChannelId,
+  };
+
+  const response = {
+    data: { messages: [rawMessageToCreate] },
+  };
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  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();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(createMessage(messageWithoutId)).rejects.toThrow('error');
+  });
+
+  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 = onMessageCreated(resolve);
+    }).finally(dispose);
+
+    await createMessage(messageWithoutId);
+
+    await expect(callbackPromise).resolves.toMatchObject(messageWithoutId);
+  });
+});
+
+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.Channel>(['channel', 'get', subChannelId])?.data;
+      expect(cacheChannel?.messageCount).toBe(3);
+    });
+  });
+
+  test('should fire event `onMessageCreated`', async () => {
+    let dispose;
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageCreated(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,
+  };
+
+  beforeAll(enableCache);
+
+  afterAll(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: [{ ...messageToCreate, 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();
+
+    onMessageCreated(callback);
+    client.emitter.emit('message.created', {
+      messages: [rawNewMessage],
+      files: [],
+      users: [],
+    });
+    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_/),
+      }),
+    );
+  });
+});

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

@@ -0,0 +1,116 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, generateRawMessage } from '~/utils/tests';
+
+import { deleteMessage } from '../deleteMessage';
+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('deleteMessage', () => {
+  test('should return deleted message', async () => {
+    client.http.delete = jest.fn();
+    client.http.get = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    await expect(deleteMessage(deleteId)).resolves.toEqual(deletedMessage);
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.delete = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(deleteMessage(deleteId)).rejects.toThrow('error');
+  });
+
+  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 deleteMessage(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 deleteMessage(deleteId);
+
+    await expect(callbackPromise).resolves.toEqual(deletedMessage);
+  });
+});
+
+describe('deleteMessage.optimistically', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
+
+  test('should update `isDeleted` in cache after deleted message', () => {
+    pushToCache(['message', 'get', deleteId], messageToDelete);
+
+    deleteMessage.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 });
+
+    deleteMessage.optimistically(deleteId);
+    const recieved = pullFromCache<Amity.Channel>(['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);
+
+    await deleteMessage.optimistically(deleteId);
+
+    await expect(callbackPromise).resolves.toEqual({
+      ...deletedMessage,
+      updatedAt: expect.anything(),
+    });
+  });
+
+  test('should define object as unsynced object', () => {
+    pushToCache(['message', 'get', deleteId], messageToDelete);
+
+    expect(deleteMessage.optimistically(deleteId)?.cachedAt).toBe(-1);
+  });
+});

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

@@ -0,0 +1,123 @@
+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, generateRawMessage } from '~/utils/tests';
+
+import { getMessage } from '../getMessage';
+import { onMessageFetched } from '../../events/onMessageFetched';
+import { convertFromRaw } from '../../utils';
+
+const rawMessageToGet = generateRawMessage();
+const messageToGet = convertFromRaw(rawMessageToGet);
+const { messageId } = messageToGet;
+
+const getResolvedMessageValue = () => ({
+  data: {
+    messages: [rawMessageToGet],
+    users: [],
+    files: [],
+  },
+});
+
+describe('getMessage', () => {
+  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();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(getMessage(messageId)).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 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/message/api/tests/getMessages.test.ts

@@ -0,0 +1,107 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { client, generateRawMessage } from '~/utils/tests';
+
+import { getMessages } from '../getMessages';
+import { onMessageFetched } from '../../events/onMessageFetched';
+import { convertFromRaw } from '../../utils';
+
+const rawMessagesToGet = [generateRawMessage(), generateRawMessage({ messageId: 'message-id-2' })];
+const messagesToGet = rawMessagesToGet.map(convertFromRaw);
+const messageIds = messagesToGet.map(x => x.messageId);
+
+const getResolvedMessageValue = () => ({
+  data: {
+    messages: rawMessagesToGet,
+    users: [],
+    files: [],
+  },
+});
+
+describe('getMessages', () => {
+  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(() => disableCache());
+
+  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/message/api/tests/queryMessages.test.ts

@@ -0,0 +1,142 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, generateRawMessage } from '~/utils/tests';
+
+import { convertFromRaw, convertQueryParams } from '../../utils';
+import { queryMessages } from '../queryMessages';
+import { onMessageFetched } from '../../events/onMessageFetched';
+
+const rawMessagesToQuery = [
+  generateRawMessage(),
+  generateRawMessage({ messageId: 'message-id-2' }),
+];
+const messagesToQuery = rawMessagesToQuery.map(convertFromRaw);
+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', () => {
+  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 undefined 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).toBeUndefined();
+  });
+});
+
+describe('queryMessages.locally', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
+
+  test('should return cached messages', () => {
+    messagesToQuery.forEach(message => pushToCache(['message', 'get', message.messageId], message));
+
+    pushToCache(['message', 'query', convertQueryParams(queryCriteria)], {
+      messages: messageIds,
+      paging,
+    });
+
+    expect(queryMessages.locally(queryCriteria)).toEqual(
+      expect.objectContaining({
+        data: messagesToQuery,
+        prevPage: undefined,
+        nextPage,
+      }),
+    );
+  });
+
+  test(`shouldn't return if individual message cache not exist`, () => {
+    pushToCache(['message', 'query', convertQueryParams(queryCriteria)], {
+      messages: messageIds,
+      paging,
+    });
+
+    expect(queryMessages.locally(queryCriteria)).toBeUndefined();
+  });
+
+  test('it should return undefined if message not in cache', () => {
+    expect(queryMessages.locally({ subChannelId: 'non-existent' })).toBeUndefined();
+  });
+});