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

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

@@ -0,0 +1,73 @@
+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';
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+
+const cacheKey = ['message', 'get', message.messageId];
+
+describe('addReaction', () => {
+  test('it 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);
+  });
+
+  test('it should update cache after adding reaction', async () => {
+    enableCache();
+
+    pushToCache(cacheKey, message);
+    client.http.post = jest.fn().mockResolvedValue({ data: { addedId: 'reactionId' } });
+
+    const success = await addReaction('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.cachedAt).toBeDefined();
+    expect(pullFromCache(cacheKey)?.cachedAt).not.toBe(UNSYNCED_OBJECT_CACHED_AT_VALUE);
+    expect(pullFromCache(cacheKey)?.cachedAt).not.toBe(-1);
+
+    disableCache();
+  });
+});
+
+describe('addReaction > optimistically', () => {
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('it should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(addReaction.optimistically('message', message.messageId, 'like')).toBeUndefined();
+  });
+
+  test('it should optimistically add a reaction', async () => {
+    const callback = jest.fn();
+    pushToCache(cacheKey, message);
+    onMessageUpdated(callback);
+
+    const success = 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('it should mark optimistic object as unsynced', async () => {
+    pushToCache(cacheKey, message);
+
+    const success = addReaction.optimistically('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.cachedAt).toBe(UNSYNCED_OBJECT_CACHED_AT_VALUE);
+  });
+});

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

@@ -0,0 +1,79 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+
+import { onMessageUpdated } from '~/message/events';
+import { removeReaction } from '~/reaction/api';
+
+import { UNSYNCED_OBJECT_CACHED_AT_VALUE } from '~/utils/constants';
+import { client, message11, pause } from '~/utils/tests';
+
+const message = {
+  ...message11,
+  myReactions: ['like'],
+  reactions: { like: 1 },
+  reactionsCount: 1,
+};
+const cacheKey = ['message', 'get', message.messageId];
+
+describe('removeReaction', () => {
+  test('it should remove a reaction', async () => {
+    client.http.delete = jest.fn().mockResolvedValue({ data: { removedId: 'reactionId' } });
+
+    const success = await removeReaction('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+  });
+
+  test('it should update cache after adding reaction', async () => {
+    enableCache();
+
+    pushToCache(cacheKey, message);
+    client.http.post = jest.fn().mockResolvedValue({ data: { addedId: 'reactionId' } });
+
+    const success = await removeReaction('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.cachedAt).toBeDefined();
+    expect(pullFromCache(cacheKey)?.cachedAt).not.toBe(UNSYNCED_OBJECT_CACHED_AT_VALUE);
+    expect(pullFromCache(cacheKey)?.cachedAt).not.toBe(-1);
+
+    disableCache();
+  });
+});
+
+describe('removeReaction > optimistically', () => {
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('it should return undefined if cache disabled', () => {
+    disableCache();
+
+    expect(removeReaction.optimistically('message', message.messageId, 'like')).toBeUndefined();
+  });
+
+  test('it should optimistically remove a reaction', async () => {
+    const callback = jest.fn();
+    pushToCache(cacheKey, message);
+    onMessageUpdated(callback);
+
+    const success = 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('it should mark optimistic object as unsynced', async () => {
+    pushToCache(cacheKey, message);
+
+    const success = removeReaction.optimistically('message', message.messageId, 'like');
+
+    expect(success).toEqual(true);
+    expect(pullFromCache(cacheKey)?.cachedAt).toBe(UNSYNCED_OBJECT_CACHED_AT_VALUE);
+  });
+});

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/channel.ts

@@ -1,4 +1,4 @@
-import { date, rolesAndPermissions, user11, user12, user13 } from '.';
+import { date, rolesAndPermissions, user11, user12, user13, file11 } from '.';
 
 const mockPage = {
   paging: {
@@ -177,3 +177,11 @@ export const channelUserQueryResponsePage3 = {
     ...mockPage,
   },
 };
+
+// for testing ingest in cache
+export const channelPayload = {
+  channels: [channel11],
+  channelUsers: [channelUser7, channelUser6],
+  users: [user11],
+  files: [file11],
+};

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

@@ -0,0 +1,44 @@
+import { file11, user11 } from '.';
+
+export const community11: Amity.Community = {
+  path: '',
+  isOfficial: false,
+  isPublic: true,
+  postsCount: 7,
+  membersCount: 1,
+  updatedAt: '2022-10-31T05:06:57.999Z',
+  createdAt: '2022-10-31T02:48:34.978Z',
+  isDeleted: false,
+  displayName: 'HardDelete1',
+  tags: [],
+  metadata: {},
+  hasFlaggedComment: false,
+  hasFlaggedPost: true,
+  communityId: 'community11',
+  channelId: '635f3782064bf304f786707d',
+  userId: user11.userId,
+  isJoined: false,
+  avatarFileId: undefined,
+  categoryIds: [],
+};
+
+export const communityUser11: Amity.Membership<'community'> = {
+  communityMembership: 'member',
+  lastActivity: '2022-10-25T11:10:13.048Z',
+  updatedAt: '2022-10-25T11:10:13.048Z',
+  createdAt: '2022-10-25T11:10:13.048Z',
+  muteTimeout: '2022-10-25T11:10:13.048Z',
+  isMuted: false,
+  isBanned: false,
+  userId: 'test',
+  communityId: community11.communityId,
+  roles: ['channel-moderator', 'community-moderator'],
+  permissions: [Amity.Permission.CreateRolePermission],
+};
+
+export const communityPayload: Amity.CommunityPayload = {
+  communities: [community11],
+  communityUsers: [communityUser11],
+  files: [file11],
+  users: [user11],
+};

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

@@ -0,0 +1,20 @@
+export const file11: Amity.File<'image'> = {
+  fileId: 'file-Id',
+  fileUrl: 'https://fileUrl.com/test-file',
+  type: 'image',
+  createdAt: '2022-10-28T08:01:51.996Z',
+  updatedAt: '2022-10-28T08:01:51.996Z',
+  attributes: {
+    name: 'test.png',
+    extension: 'png',
+    size: '166904',
+    mimeType: 'image/png',
+    metadata: {
+      height: 966,
+      width: 1918,
+      isFull: false,
+      exif: {},
+      gps: {},
+    },
+  },
+};

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

@@ -58,3 +58,9 @@ export const follows = {
   page1: [follow11, follow12, follow13],
   page2: [follow21, follow22, follow23],
 };
+
+export const followPayload: Amity.FollowersPayload = {
+  users: [user11, user12],
+  files: [],
+  follows: [follow11, follow12],
+};

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

@@ -2,7 +2,16 @@ export const date = new Date().toISOString();
 export const rolesAndPermissions = { roles: [], permissions: [] };
 
 export * from './user';
+export * from './role';
+export * from './file';
+
 export * from './post';
+
+export * from './poll';
 export * from './follow';
+export * from './reaction';
+
 export * from './channel';
+export * from './community';
+
 export * from './message';

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

@@ -1,4 +1,4 @@
-import { date, channel11, user11 } from '.';
+import { date, channel11, user11, file11 } from '.';
 
 export const message11: Amity.Message = {
   fileId: null,
@@ -33,3 +33,10 @@ export const messageQueryResponse = {
     },
   },
 };
+
+// for testing ingest in cache
+export const messagePayload = {
+  messages: [message11],
+  files: [file11],
+  users: [user11],
+};

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

@@ -0,0 +1,43 @@
+import { user11 } from '.';
+
+export const poll11: Amity.Poll = {
+  pollId: 'c7b7c3e52be052be3fd5b5f0b4033d501667195535489',
+  userId: 'test',
+  question: 'Yellow',
+  answers: [
+    {
+      dataType: 'text',
+      data: '1',
+      isVotedByUser: false,
+      voteCount: 0,
+      id: '635f628f651eeb361624a8b6',
+    },
+    {
+      dataType: 'text',
+      data: '2',
+      isVotedByUser: false,
+      voteCount: 0,
+      id: '635f628f651eeb619424a8b7',
+    },
+    {
+      dataType: 'text',
+      data: '3',
+      isVotedByUser: false,
+      voteCount: 0,
+      id: '635f628f651eeb391f24a8b8',
+    },
+  ],
+  answerType: 'single',
+  closedAt: '2022-11-30T05:52:15.489Z',
+  createdAt: '2022-10-31T05:52:15.493Z',
+  updatedAt: '2022-10-31T05:52:15.493Z',
+  isVoted: false,
+  status: 'open',
+  closedIn: 2592000000,
+  isDeleted: false,
+};
+
+export const pollPayload: Amity.PollPayload = {
+  polls: [poll11],
+  users: [user11],
+};

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

@@ -1,6 +1,7 @@
-import { user11, date } from '.';
+import { user11, file11, communityUser11, date } from '.';
+import { encodeJson } from '..';
 
-export const post1: Amity.Post = {
+export const post11: Amity.Post = {
   path: '',
   feedId: '',
   children: [],
@@ -15,17 +16,77 @@ 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 comment11: Amity.Comment = {
+  path: '',
+  referenceType: 'post',
+  dataType: 'text',
+  rootId: 'test',
+  data: {
+    text: 'yellow new world',
+  },
+  childrenNumber: 0,
+  isDeleted: false,
+  editedAt: '2022-10-31T05:57:45.661Z',
+  updatedAt: '2022-10-31T05:57:45.670Z',
+  createdAt: '2022-10-31T05:57:45.661Z',
+  segmentNumber: 2,
+  commentId: 'comment11',
+  userId: 'test',
+  referenceId: post11.postId,
+  flagCount: 0,
+  hashFlag: null,
+  children: [],
+  mentionees: [],
+  reactions: {},
+  reactionsCount: 0,
+};
+
+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'],
 };
+
+export const commentPayload: Amity.CommentPayload = {
+  comments: [comment11],
+  users: [user11],
+};
+
+export const postPayload: Amity.PostPayload = {
+  posts: [post11],
+  users: [user11],
+  files: [file11],
+  comments: [comment11],
+  communityUsers: [],
+};
+
+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/reaction.ts

@@ -0,0 +1,22 @@
+import { post11, user11 } from '.';
+
+export const reaction11: Amity.Reaction = {
+  reactionName: 'reaction11',
+  reactionId: 'reaction11',
+  referenceId: post11.postId,
+  referenceType: 'post',
+  userId: user11.userId,
+  createdAt: '',
+};
+
+export const reactor11: Amity.Reactor = {
+  reactionName: 'reaction11',
+  reactionId: 'reaction11',
+  userId: user11.userId,
+  createdAt: '',
+};
+
+export const reactionPayload: Amity.ReactionPayload = {
+  reactions: [{ ...reaction11, reactors: [reactor11] }],
+  users: [user11],
+};

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

@@ -0,0 +1,21 @@
+export const role11: Amity.Role = {
+  roleId: 'channel moderator',
+  displayName: 'channel moderator',
+  createdAt: '2022-10-31T04:03:56.786Z',
+  updatedAt: '2022-10-31T04:03:56.786Z',
+  permissions: [],
+  isDeleted: false,
+};
+
+export const role12: Amity.Role = {
+  roleId: 'test',
+  displayName: 'test',
+  createdAt: '2022-10-26T04:33:17.344Z',
+  updatedAt: '2022-10-26T04:33:17.344Z',
+  permissions: [],
+  isDeleted: false,
+};
+
+export const rolePayload: Amity.RolePayload = {
+  roles: [role11, role12],
+};

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=',
@@ -35,3 +35,9 @@ export const userQueryResponse = {
     },
   },
 };
+
+// user payload with file
+export const userPayload: Amity.UserPayload = {
+  users: [user11, user12],
+  files: [{ fileId: 'test-file-id' } as Amity.File<'image'>],
+};

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":""}