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

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

@@ -38,10 +38,7 @@ export const addReaction = async (
     reactionName,
   });
 
-  const model = await fetchReference(referenceType, referenceId);
-  dispatchReactable(referenceType, model.data);
-
-  return model.data.myReactions?.includes(reactionName) ?? false;
+  return true;
 };
 
 /**

package/src/reaction/api/removeReaction.ts

@@ -36,10 +36,7 @@ export const removeReaction = async (
     data: { referenceId, referenceType, reactionName },
   });
 
-  const model = await fetchReference(referenceType, referenceId);
-  dispatchReactable(referenceType, model.data);
-
-  return !model.data.myReactions?.includes(reactionName) ?? false;
+  return true;
 };
 
 /**

package/src/reaction/api/tests/addReaction.test.ts

@@ -0,0 +1,37 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { onMessageUpdated } from '~/message/events';
+import { addReaction } from '~/reaction/api';
+import { client, message11 as message, pause } from '~/utils/tests';
+
+describe('addReaction', () => {
+  const cacheKey = ['message', 'get', message.messageId];
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('should optimistically add a reaction', async () => {
+    const callback = jest.fn();
+    pushToCache(cacheKey, message);
+    onMessageUpdated(callback);
+
+    const success = await addReaction.optimistically('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.data).toMatchObject({
+      myReactions: ['like'],
+      reactions: { like: 1 },
+      reactionsCount: 1,
+    });
+    await pause();
+    expect(callback).toBeCalledTimes(1);
+  });
+
+  test('should add a reaction', async () => {
+    client.http.post = jest.fn().mockResolvedValue({ data: { addedId: 'reactionId' } });
+
+    const success = await addReaction('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+  });
+});

package/src/reaction/api/tests/removeReaction.test.ts

@@ -0,0 +1,43 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { onMessageUpdated } from '~/message/events';
+import { removeReaction } from '~/reaction/api';
+import { client, message11 as message, message11, pause } from '~/utils/tests';
+
+describe('removeReaction', () => {
+  const message = {
+    ...message11,
+    myReactions: ['like'],
+    reactions: { like: 1 },
+    reactionsCount: 1,
+  };
+  const cacheKey = ['message', 'get', message.messageId];
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('should optimistically add a reaction', async () => {
+    const callback = jest.fn();
+    pushToCache(cacheKey, message);
+    onMessageUpdated(callback);
+
+    const success = await removeReaction.optimistically('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.data).toMatchObject({
+      myReactions: [],
+      reactions: { like: 0 },
+      reactionsCount: 0,
+    });
+    await pause();
+    expect(callback).toBeCalledTimes(1);
+  });
+
+  test('should add a reaction', async () => {
+    client.http.delete = jest.fn().mockResolvedValue({ data: { removedId: 'reactionId' } });
+
+    const success = await removeReaction('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+  });
+});

package/src/user/api/getUser.ts

@@ -1,6 +1,6 @@
 import { getActiveClient } from '~/client/api';
 
-import { pullFromCache, dropFromCache } from '~/cache/api';
+import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 
@@ -38,7 +38,6 @@ export const getUser = async (
   let data: Amity.UserPayload;
 
   try {
-    // API-FIX: endpoint should not be /list, parameters should be querystring.
     const response = await client.http.get<Amity.UserPayload>(
       `/api/v3/users/${encodeURIComponent(userId)}`,
     );

package/src/user/api/queryUsers.ts

@@ -33,9 +33,14 @@ export const queryUsers = async (
   const client = getActiveClient();
   client.log('user/queryUsers', query);
 
-  const { page, displayName, filter = 'all', sortBy = 'displayName', ...params } = query;
+  const {
+    page = { limit: 10 },
+    displayName,
+    filter = 'all',
+    sortBy = 'displayName',
+    ...params
+  } = query;
 
-  // API-FIX: parameters should be querystring.
   const { data } = await client.http.get<Amity.UserPayload & Amity.Pagination>(`/api/v3/users`, {
     params: {
       ...params,
@@ -57,7 +62,11 @@ export const queryUsers = async (
   if (client.cache) {
     ingestInCache(payload as Amity.UserPayload, { cachedAt });
 
-    const cacheKey = ['user', 'query', query as Amity.Serializable];
+    /*
+     * using query as cache key over params because if the keyword, filter, sort
+     * change the API will NOT cache results, when it should
+     */
+    const cacheKey = ['user', 'query', { ...query, options: { ...page } } as Amity.Serializable];
     pushToCache(cacheKey, { users: users.map(getResolver('user')), paging });
   }
 
@@ -91,9 +100,19 @@ queryUsers.locally = (
 
   if (!client.cache) return;
 
-  const queryKey = ['user', 'query', query as Amity.Serializable];
+  const { page = { limit: 10 } } = query ?? {};
+
+  const cacheKey = [
+    'user',
+    'query',
+    {
+      ...query,
+      options: { ...page },
+    } as Amity.Serializable,
+  ];
+
   const { data, cachedAt } =
-    pullFromCache<{ users: Pick<Amity.User, 'userId'>[] } & Amity.Pagination>(queryKey) ?? {};
+    pullFromCache<{ users: Pick<Amity.User, 'userId'>[] } & Amity.Pagination>(cacheKey) ?? {};
 
   const users: Amity.User[] =
     data?.users

package/src/user/api/tests/queryUsers.test.ts

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

package/src/utils/tests/dummy/post.ts

@@ -1,6 +1,7 @@
+import { encodeJson } from '..';
 import { user11, date } from '.';
 
-export const post1: Amity.Post = {
+export const post11: Amity.Post = {
   path: '',
   feedId: '',
   children: [],
@@ -15,17 +16,39 @@ export const post1: Amity.Post = {
   postId: 'postId11',
   targetType: 'user',
   parentId: 'postId12',
-  data: { text: 'post1' },
+  data: { text: 'post11' },
   targetId: user11.userId,
   hasFlaggedComment: false,
   hasFlaggedChildren: false,
   postedUserId: user11.userId,
 };
 
+export const post12: Amity.Post = {
+  ...post11,
+  postId: 'post12',
+};
+
+export const post13: Amity.Post = {
+  ...post11,
+  postId: 'post13',
+};
+
 export const posts = {
   targetId: user11.userId,
   targetType: 'user' as Amity.PostTargetType,
-  page1: [post1.postId, 'postId12', 'postId13'],
+  page1: [post11.postId, post12.postId, post13.postId],
   page2: ['postId21', 'postId22', 'postId23'],
   page3: ['postId31', 'postId32', 'postId33'],
 };
+
+const nextPage = encodeJson({ before: post13.postId, limit: 10 });
+
+export const postQueryResponse = {
+  data: {
+    posts: [post11, post12, post13],
+    files: [],
+    paging: {
+      next: nextPage,
+    },
+  },
+};

package/src/utils/tests/dummy/user.ts

@@ -27,7 +27,7 @@ export const user14: Amity.User = {
 
 export const userQueryResponse = {
   data: {
-    users: [user11],
+    users: [user11, user12],
     files: [],
     paging: {
       previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',

package/dist/message/tests/api/getMessage.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getMessage.test.d.ts","sourceRoot":"","sources":["../../../../src/message/tests/api/getMessage.test.ts"],"names":[],"mappings":""}