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

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();
+  });
+});

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

@@ -0,0 +1,100 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, message11 } from '~/utils/tests';
+
+import { updateMessage } from '../updateMessage';
+import { onMessageUpdated } from '../../events';
+
+const messageToUpdate = message11;
+const { messageId } = messageToUpdate;
+const patch = { data: { text: 'hello world' } };
+const updatedMessage = { ...messageToUpdate, ...patch };
+const { updatedAt, ...updatedMessageWithoutTS } = updatedMessage;
+
+const getResolvedMessageValue = () => ({
+  data: {
+    messages: [updatedMessage],
+    users: [],
+    files: [],
+  },
+});
+
+describe('updateMessage', () => {
+  test('should return updated message', async () => {
+    client.http.put = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    const recieved = updateMessage(messageId, patch);
+
+    await expect(recieved).resolves.toEqual(
+      expect.objectContaining({ data: updatedMessageWithoutTS }),
+    );
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.put = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(updateMessage(messageId, patch)).rejects.toThrow('error');
+  });
+
+  test('should update cache after updated messages', async () => {
+    enableCache();
+    client.http.put = jest.fn().mockResolvedValueOnce(getResolvedMessageValue());
+
+    await updateMessage(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 updateMessage(messageId, patch);
+
+    await expect(callbackPromise).resolves.toEqual(
+      expect.objectContaining(updatedMessageWithoutTS),
+    );
+  });
+});
+
+describe('updateMessage.optimistically', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
+
+  test('should update cache after updated message', () => {
+    pushToCache(['message', 'get', messageId], messageToUpdate);
+
+    updateMessage.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);
+
+    updateMessage.optimistically(messageId, patch);
+
+    await expect(callbackPromise).resolves.toEqual(
+      expect.objectContaining(updatedMessageWithoutTS),
+    );
+  });
+
+  test('should define object as unsynced object', () => {
+    pushToCache(['message', 'get', messageId], messageToUpdate);
+
+    expect(updateMessage.optimistically(messageId, patch)?.cachedAt).toBe(-1);
+  });
+});

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

@@ -1,23 +1,122 @@
-import { queryPosts } from '~/post/api';
-import { client, posts } from '~/utils/tests';
-
-describe('post/api', () => {
-  test('should return a post query', async () => {
-    const returnValue = [{ postId: posts.page1[0] }];
-
-    client.http.get = jest.fn().mockResolvedValue({
-      data: {
-        posts: returnValue,
-        paging: {},
-      },
-    });
+import { getResolver } from '~/core/model';
+
+import { disableCache, enableCache, pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { client, postQueryResponse } from '~/utils/tests';
+
+import { queryPosts } from '../../api/queryPosts';
+
+const params = { targetType: 'user', targetId: 'test' } as Amity.QueryPosts;
+
+describe('queryPosts', () => {
+  test('it should return posts', async () => {
+    const { posts: expected } = postQueryResponse.data;
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponse);
+
+    const { data } = await queryPosts(params);
+
+    expect(data).toEqual(expected);
+  });
+
+  test('it should throw error', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryPosts(params)).rejects.toThrow('error');
+  });
+
+  test('it should update cache upon fetching data from server', async () => {
+    enableCache();
+
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponse);
+
+    const { data: expected } = await queryPosts(params);
+    const { data: received } = queryPosts.locally(params)!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+
+    disableCache();
+  });
+});
+
+describe('queryPosts.locally', () => {
+  const cacheKey = ['post', 'query', { ...params, options: { limit: 10 } } as Amity.Serializable];
+
+  test('it should fetch query locally if present in cache', () => {
+    enableCache();
+
+    const { data } = postQueryResponse;
+    const { posts: expected, paging } = data;
+
+    ingestInCache(data as Amity.PostPayload);
+
+    pushToCache(cacheKey, { posts: expected.map(getResolver('post')), paging });
 
-    const data = await queryPosts({
-      targetId: posts.targetId,
-      targetType: posts.targetType,
+    const { data: received } = queryPosts.locally(params)!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+
+    disableCache();
+  });
+
+  test('it should return undefined if only partial data in cache', () => {
+    enableCache();
+
+    const { data } = postQueryResponse;
+    const { posts, paging } = data;
+
+    // ingest incomplete data
+    ingestInCache({
+      ...data,
+      posts: [data.posts[0]],
+    } as Amity.PostPayload);
+
+    pushToCache(cacheKey, {
+      posts: posts.map(getResolver('post')),
+      paging,
     });
 
-    expect(data).toBeDefined();
-    expect(data?.data).toEqual(returnValue);
+    const received = queryPosts.locally(params)!;
+
+    expect(received).toBeUndefined();
+
+    disableCache();
+  });
+
+  // added because of comment above cache key in queryPosts
+  test('it should return undefined if params do not match', () => {
+    enableCache();
+
+    const { data } = postQueryResponse;
+    const { posts: expected, paging } = data;
+
+    ingestInCache(data as Amity.PostPayload);
+
+    pushToCache(cacheKey, { posts: expected.map(getResolver('post')), paging });
+
+    const { data: received } = queryPosts.locally(params)!;
+    const received2 = queryPosts.locally({ ...params, tags: ['tag1'] })!;
+
+    expect(received).toBeDefined();
+    expect(received).toEqual(expected);
+    expect(received2).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if data not in cache', () => {
+    enableCache();
+
+    const received = queryPosts.locally(params);
+
+    expect(received).toBeUndefined();
+
+    disableCache();
+  });
+
+  test('it should return undefined if cache disabled', () => {
+    expect(queryPosts.locally(params)).toBeUndefined();
   });
 });

package/src/reaction/api/addReaction.ts

@@ -1,8 +1,9 @@
 import { getActiveClient } from '~/client/api';
 
-import { upsertInCache, pullFromCache } from '~/cache/api';
+import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
 
-import { dispatchReactable, fetchReference } from '../utils';
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { dispatchReactable } from '../utils';
 
 /**
  * ```js
@@ -38,10 +39,18 @@ export const addReaction = async (
     reactionName,
   });
 
-  const model = await fetchReference(referenceType, referenceId);
-  dispatchReactable(referenceType, model.data);
+  if (client.cache) {
+    const model = pullFromCache<Amity.Model[Amity.ReactableType]>([
+      referenceType,
+      'get',
+      referenceId,
+    ]);
 
-  return model.data.myReactions?.includes(reactionName) ?? false;
+    model?.data &&
+      pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+  }
+
+  return true;
 };
 
 /**
@@ -91,7 +100,9 @@ addReaction.optimistically = (
     },
   } as Amity.Model[Amity.ReactableType];
 
-  upsertInCache([referenceType, 'get', referenceId], reaction, { cachedAt: -1 });
+  upsertInCache([referenceType, 'get', referenceId], reaction, {
+    cachedAt: UNSYNCED_OBJECT_CACHED_AT_VALUE,
+  });
 
   dispatchReactable(referenceType, reaction);
 

package/src/reaction/api/removeReaction.ts

@@ -1,8 +1,9 @@
 import { getActiveClient } from '~/client/api';
 
-import { upsertInCache, pullFromCache } from '~/cache/api';
+import { upsertInCache, pullFromCache, pushToCache } from '~/cache/api';
 
-import { dispatchReactable, fetchReference } from '../utils';
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { dispatchReactable } from '../utils';
 
 /**
  * ```js
@@ -36,10 +37,18 @@ export const removeReaction = async (
     data: { referenceId, referenceType, reactionName },
   });
 
-  const model = await fetchReference(referenceType, referenceId);
-  dispatchReactable(referenceType, model.data);
+  if (client.cache) {
+    const model = pullFromCache<Amity.Model[Amity.ReactableType]>([
+      referenceType,
+      'get',
+      referenceId,
+    ]);
 
-  return !model.data.myReactions?.includes(reactionName) ?? false;
+    model?.data &&
+      pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+  }
+
+  return true;
 };
 
 /**
@@ -89,7 +98,9 @@ removeReaction.optimistically = (
     },
   } as Amity.Model[Amity.ReactableType];
 
-  upsertInCache([referenceType, 'get', referenceId], reaction, { cachedAt: -1 });
+  upsertInCache([referenceType, 'get', referenceId], reaction, {
+    cachedAt: UNSYNCED_OBJECT_CACHED_AT_VALUE,
+  });
 
   dispatchReactable(referenceType, reaction);