@amityco/ts-sdk 0.0.1-beta.31 → 0.0.1-beta.32

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

@@ -1,76 +1,99 @@
 import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
-import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
 
 import { client, message11 } from '~/utils/tests';
 
 import { onMessageCreated } from '../../events';
 import { createMessage } from '../createMessage';
 
-describe('message/api', () => {
-  const message = message11;
-  const { messageId, ...messageBundle } = message11;
+const messageToCreate = message11;
+const { messageId, ...messageWithoutId } = message11;
 
-  const getResolvedMessageValue = () => ({
-    data: {
-      messages: [message],
-      users: [],
-      files: [],
-    },
+const getResolvedMessageValue = () => ({
+  data: {
+    messages: [messageToCreate],
+    users: [],
+    files: [],
+  },
+});
+
+describe('createMessage', () => {
+  test('should return created message', async () => {
+    client.http.post = jest.fn().mockResolvedValue(getResolvedMessageValue());
+
+    const recieved = createMessage(messageWithoutId);
+
+    await expect(recieved).resolves.toEqual(expect.objectContaining({ data: messageToCreate }));
   });
 
-  describe('createMessage', () => {
-    test('should return message', async () => {
-      client.http.post = jest.fn().mockResolvedValue(getResolvedMessageValue());
-      const { data } = await createMessage(messageBundle);
-      expect(data).toStrictEqual(message);
-    });
-
-    test('should throw an error if request fails', async () => {
-      client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
-      await expect(createMessage(messageBundle)).rejects.toThrow('error');
-    });
+  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 create cache after created messages', async () => {
+    enableCache();
+    client.http.post = jest.fn().mockResolvedValue(getResolvedMessageValue());
+
+    const created = await createMessage(messageWithoutId);
+    const recieved = pullFromCache(['message', 'get', created.data.messageId])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(messageWithoutId));
+
+    disableCache();
   });
 
-  describe('createMessage.optimistically', () => {
-    beforeEach(() => enableCache());
-    afterEach(() => disableCache());
+  test('should fire event `onMessageCreated`', async () => {
+    let dispose;
+    client.http.post = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
 
-    test('should create cache after created message', () => {
-      const optimisticId = createMessage.optimistically(messageBundle)?.data?.messageId;
-      expect(pullFromCache(['message', 'get', optimisticId])?.data).toBeDefined();
-    });
+    const callbackPromise = new Promise(resolve => {
+      dispose = onMessageCreated(resolve);
+    }).finally(dispose);
 
-    test('should increase message count after created message', () => {
-      const { channelId } = messageBundle;
+    await createMessage(messageWithoutId);
 
-      const currentCount =
-        pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data?.messageCount ?? 0;
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(messageWithoutId));
+  });
+});
 
-      createMessage.optimistically(messageBundle);
+describe('createMessage.optimistically', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
 
-      expect(
-        pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data?.messageCount,
-      ).toEqual(currentCount + 1);
-    });
+  test('should create cache after created message', () => {
+    const optimisticId = createMessage.optimistically(messageWithoutId)?.data?.messageId;
+    const recieved = pullFromCache(['message', 'get', optimisticId])?.data;
 
-    test('should fire event `onMessageCreated`', () => {
-      expect.assertions(1);
-      let dispose;
+    expect(recieved).toEqual(expect.objectContaining(messageWithoutId));
+  });
 
-      const callback = new Promise(resolve => {
-        dispose = onMessageCreated(resolve);
-      }).finally(dispose);
+  test('should increase message count after created message', () => {
+    const { channelId } = messageWithoutId;
+    pushToCache(['channel', 'get', channelId], { channelId, messageCount: 2 });
 
-      createMessage.optimistically(messageBundle);
-      return expect(callback).resolves.not.toThrow();
-    });
+    createMessage.optimistically(messageWithoutId);
+    const recieved = pullFromCache<Amity.Channel>(['channel', 'get', channelId])?.data;
 
-    test('should define object as unsynced object', async () => {
-      const data = { channelId: 'test', data: { text: 'text' } };
+    expect(recieved?.messageCount).toBe(3);
+  });
 
-      const message = createMessage.optimistically(data);
+  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.toEqual(expect.objectContaining(messageWithoutId));
+  });
 
-      expect(message?.cachedAt).toEqual(UNSYNCED_OBJECT_CACHED_AT_VALUE);
-    });
+  test('should define object as unsynced object', async () => {
+    expect(createMessage.optimistically(messageWithoutId)?.cachedAt).toEqual(
+      UNSYNCED_OBJECT_CACHED_AT_VALUE,
+    );
   });
 });

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

@@ -0,0 +1,110 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, message11 } from '~/utils/tests';
+
+import { deleteMessage } from '../deleteMessage';
+import { onMessageDeleted } from '../../events';
+
+const messageToDelete = { ...message11, isDeleted: false };
+const { messageId: deleteId } = messageToDelete;
+const deletedMessage = { ...messageToDelete, isDeleted: true };
+const { updatedAt, ...deletedMessageWithoutTS } = deletedMessage;
+
+const getResolvedMessageValue = () => ({
+  data: {
+    messages: [deletedMessage],
+    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(deletedMessageWithoutTS);
+  });
+
+  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(deletedMessageWithoutTS);
+
+    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(deletedMessageWithoutTS);
+  });
+});
+
+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(expect.objectContaining(deletedMessageWithoutTS));
+  });
+
+  /* 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(
+      expect.objectContaining(deletedMessageWithoutTS),
+    );
+  });
+
+  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,121 @@
+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, message11 } from '~/utils/tests';
+
+import { getMessage } from '../getMessage';
+import { onMessageFetched } from '../../events';
+
+const messageToGet = message11;
+const { messageId } = messageToGet;
+
+const getResolvedMessageValue = () => ({
+  data: {
+    messages: [messageToGet],
+    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,108 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { ASCApiError } from '~/core/errors';
+import { client, message11 } from '~/utils/tests';
+
+import { getMessages } from '../getMessages';
+import { onMessageFetched } from '../../events';
+
+const messagesToGet = [
+  { ...message11, messageId: 'message11' },
+  { ...message11, messageId: 'message12' },
+];
+const messageIds = ['message11', 'message12'];
+
+const getResolvedMessageValue = () => ({
+  data: {
+    messages: messagesToGet,
+    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,115 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, message11 } from '~/utils/tests';
+
+import { queryMessages } from '../queryMessages';
+import { onMessageFetched } from '../../events';
+
+const messagesToQuery = [
+  { ...message11, messageId: 'message11' },
+  { ...message11, messageId: 'message12' },
+];
+const messageIds = ['message11', 'message12'];
+const queryCriteriaWithoutPage = { channelId: messagesToQuery[0].channelId };
+const pagingCriteria = { limit: 10 };
+const queryCriteria = { ...queryCriteriaWithoutPage, page: pagingCriteria };
+const pagingToken = {
+  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+};
+
+const getResolvedMessageValue = () => ({
+  data: {
+    messages: messagesToQuery,
+    files: [],
+    users: [],
+    paging: pagingToken,
+  },
+});
+
+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,
+        prevPage: { before: 55, limit: 10 },
+        nextPage: { before: 55, limit: 10 },
+      }),
+    );
+  });
+
+  test('should update cache after fetching messages', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(getResolvedMessageValue());
+
+    await queryMessages(queryCriteria);
+
+    const recieved = pullFromCache([
+      'message',
+      'query',
+      { ...queryCriteriaWithoutPage, options: pagingCriteria },
+    ])?.data;
+
+    expect(recieved).toEqual({
+      messages: messageIds,
+      paging: pagingToken,
+    });
+
+    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]);
+  });
+});
+
+describe('queryMessages.locally', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
+
+  test('should return cached messages', () => {
+    messagesToQuery.forEach(message => pushToCache(['message', 'get', message.messageId], message));
+
+    pushToCache(['message', 'query', { ...queryCriteriaWithoutPage, options: pagingCriteria }], {
+      messages: messageIds,
+      paging: pagingToken,
+    });
+
+    expect(queryMessages.locally(queryCriteria)).toEqual(
+      expect.objectContaining({
+        data: messagesToQuery,
+        prevPage: { before: 55, limit: 10 },
+        nextPage: { before: 55, limit: 10 },
+      }),
+    );
+  });
+
+  test(`shouldn't return if individual message cache not exist`, () => {
+    pushToCache(['message', 'query', { ...queryCriteriaWithoutPage, options: pagingCriteria }], {
+      messages: messageIds,
+      paging: pagingToken,
+    });
+
+    expect(queryMessages.locally(queryCriteria)).toBeUndefined();
+  });
+
+  test('it should return undefined if message not in cache', () => {
+    expect(queryMessages.locally({ channelId: 'non-existent' })).toBeUndefined();
+  });
+});