@amityco/ts-sdk 0.0.1-beta.39 → 0.0.1-beta.40

package/src/poll/api/tests/createPoll.test.ts

@@ -0,0 +1,70 @@
+import { client, poll11 } from '~/utils/tests';
+import { ASCError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { createPoll } from '../createPoll';
+import { getPoll } from '../getPoll';
+
+describe('createPoll', () => {
+  beforeAll(enableCache);
+  afterAll(disableCache);
+
+  const bundle: Parameters<typeof createPoll>[0] = {
+    answerType: 'single',
+    answers: [
+      {
+        data: 'answer1',
+        dataType: 'text',
+      },
+      {
+        data: 'answer1',
+        dataType: 'text',
+      },
+    ],
+    question: 'question',
+  };
+
+  // integration_test_id: 5dc099fd-8e89-4f78-bf6c-fda6dbd06b66
+  it('should create a poll with a single answer', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce({ data: { polls: [poll11] } });
+
+    const { data: poll } = await createPoll(bundle);
+    const { data: cachedPoll } = getPoll.locally(poll.pollId)!;
+
+    expect(poll.pollId).toBeDefined();
+    expect(cachedPoll).toMatchObject(poll);
+  });
+
+  // integration_test_id: d18d4f13-6ac5-42f1-822b-a22fc0a7cf90
+  it('should create a poll with multiple answers', async () => {
+    client.http.post = jest.fn().mockResolvedValueOnce({ data: { polls: [poll11] } });
+
+    const { data: poll } = await createPoll({
+      ...bundle,
+      answerType: 'multiple',
+    });
+
+    expect(poll.pollId).toBeDefined();
+  });
+
+  // integration_test_id: 4cda145c-0bc8-4aaf-9ec0-02676bbde8a6
+  it('should fail if question exceeds 500 characters', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCError('error message', Amity.ServerError.BUSINESS_ERROR, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(() => createPoll(bundle)).rejects.toThrow();
+  });
+
+  // integration_test_id: a96780e1-758e-4de7-9c18-fdb34c4cacc7
+  it('should fail if question exceeds 200 characters', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCError('error message', Amity.ServerError.BUSINESS_ERROR, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(() => createPoll(bundle)).rejects.toThrow();
+  });
+});

package/src/poll/api/tests/getPoll.test.ts

@@ -0,0 +1,31 @@
+import { client, poll11 } from '~/utils/tests';
+import { ASCError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { getPoll } from '../getPoll';
+
+describe('getPoll', () => {
+  beforeAll(enableCache);
+  afterAll(disableCache);
+
+  // integration_test_id: 0d096a75-2f42-489e-8435-e3022eafb1a3
+  it('should fetch the poll', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce({ data: { polls: [poll11] } });
+
+    const { data: poll } = await getPoll(poll11.pollId);
+    const { data: cachedPoll } = getPoll.locally(poll11.pollId)!;
+
+    expect(poll.pollId).toEqual(poll11.pollId);
+    expect(cachedPoll).toMatchObject(poll);
+  });
+
+  // integration_test_id: 074fdf85-bbb6-4957-a89e-26aa10871dc4
+  it('should fail to fetch if the poll does not exist', async () => {
+    client.http.get = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCError('error message', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(() => getPoll('non-existent-poll-id')).rejects.toThrow();
+  });
+});

package/src/poll/api/tests/votePoll.test.ts

@@ -0,0 +1,41 @@
+import { client, pause, poll11 } from '~/utils/tests';
+import { ASCError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { onPollUpdated } from '~/poll/events';
+import { votePoll } from '../votePoll';
+import { getPoll } from '../getPoll';
+
+describe('votePoll', () => {
+  beforeAll(enableCache);
+  afterAll(disableCache);
+
+  // integration_test_id: 2abcbca5-f845-4e96-9405-23781013738e
+  it('should vote', async () => {
+    client.http.post = jest
+      .fn()
+      .mockResolvedValueOnce({ data: { polls: [{ ...poll11, isVoted: true }] } });
+    const callback = jest.fn();
+    onPollUpdated(callback);
+
+    const { data: poll } = await votePoll(poll11.pollId, [poll11.answers[0].id]);
+    const { data: cachedPoll } = getPoll.locally(poll.pollId)!;
+    await pause();
+
+    expect(poll.isVoted).toEqual(true);
+    expect(cachedPoll).toMatchObject(poll);
+    expect(callback).toHaveBeenCalledWith(poll);
+  });
+
+  // integration_test_id: b6ab2681-7f25-47a0-bc14-f4f542a3cf80
+  it('should fail to vote for in an invalid poll', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCError('error message', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.FATAL),
+      );
+
+    await expect(() =>
+      votePoll('non-existent-poll-id', ['non-existent-answer-id']),
+    ).rejects.toThrow();
+  });
+});

package/src/poll/events/onPollDeleted.ts

@@ -21,7 +21,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 export const onPollDeleted = (callback: Amity.Listener<Amity.Poll>): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.PollPayload) => {
+  const filter = (payload: Amity.Events['poll.deleted']) => {
     if (client.cache) ingestInCache(payload);
 
     callback(payload.polls[0]);

package/src/poll/events/onPollUpdated.ts

@@ -21,7 +21,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 export const onPollUpdated = (callback: Amity.Listener<Amity.Poll>): Amity.Unsubscriber => {
   const client = getActiveClient();
 
-  const filter = (payload: Amity.PollPayload) => {
+  const filter = (payload: Amity.Events['poll.updated']) => {
     if (client.cache) ingestInCache(payload);
 
     callback(payload.polls[0]);

package/src/post/api/approvePost.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
 
 /**
  * ```js
@@ -24,25 +25,24 @@ export const approvePost = async (
   const client = getActiveClient();
   client.log('post/approvePost', postId);
 
-  const { data: approved } = await client.http.post<Amity.PostPayload>(
+  const { data: payload } = await client.http.post<Amity.PostPayload>(
     `/api/v3/posts/${encodeURIComponent(postId)}/approve`,
   );
 
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(approved, { cachedAt });
+  fireEvent('post.approved', payload);
 
   // fire virtual event for community update
-  if (approved.posts[0].targetType === 'community') {
-    const community = approved.communities?.[0];
-
-    // @ts-ignore as communities is optional currently in PostPayload
-    fireEvent('community.updated', { communities: [community] });
+  if (payload.posts[0].targetType === 'community') {
+    fireEvent('community.updated', payload);
   }
 
-  fireEvent('post.approved', { posts: [approved.posts[0]] });
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) ingestInCache(data, { cachedAt });
 
   return {
-    data: approved.posts.find(post => post.postId === postId)!,
+    data: data.posts.find(post => post.postId === postId)!,
     cachedAt,
   };
 };

package/src/post/api/createPost.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
 
 /**
  * ```js
@@ -37,12 +38,14 @@ export const createPost = async <T extends Amity.PostContentType | string>(
     delete bundle.dataType;
   }
 
-  const { data } = await client.http.post<Amity.PostPayload>('/api/v4/posts', bundle);
+  const { data: payload } = await client.http.post<Amity.PostPayload>('/api/v4/posts', bundle);
 
+  fireEvent('post.created', payload);
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
   const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
 
-  fireEvent('post.created', data);
+  if (client.cache) ingestInCache(data, { cachedAt });
 
   const { posts } = data;
 

package/src/post/api/declinePost.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
 
 /**
  * ```js
@@ -24,25 +25,24 @@ export const declinePost = async (
   const client = getActiveClient();
   client.log('post/declinePost', postId);
 
-  const { data: declined } = await client.http.post<Amity.PostPayload>(
+  const { data: payload } = await client.http.post<Amity.PostPayload>(
     `/api/v3/posts/${encodeURIComponent(postId)}/decline`,
   );
 
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(declined, { cachedAt });
-
   // fire virtual event
-  if (declined.posts[0].targetType === 'community') {
-    const community = declined.communities?.[0];
-
-    // @ts-ignore as communities is optional currently in PostPayload
-    fireEvent('community.updated', { communities: [community] });
+  if (payload.posts[0].targetType === 'community') {
+    fireEvent('community.updated', payload);
   }
 
-  fireEvent('post.declined', { posts: [declined.posts[0]] });
+  fireEvent('post.declined', payload);
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+  const cachedAt = client.cache && Date.now();
+
+  if (client.cache) ingestInCache(data, { cachedAt });
 
   return {
-    data: declined.posts.find(post => post.postId === postId)!,
+    data: payload.posts.find(post => post.postId === postId)!,
     cachedAt,
   };
 };

package/src/post/api/deletePost.ts

@@ -44,13 +44,30 @@ export const deletePost = async (
   // later when realtime events covers that for us.
   if (post.data.targetType === 'community') {
     const community = await getCommunity(post.data.targetId);
-    fireEvent('community.updated', { communities: [community.data] });
+    fireEvent('community.updated', {
+      communities: [community.data],
+      categories: [],
+      communityUsers: [],
+      feeds: [],
+      files: [],
+      users: [],
+    });
   }
 
   // to support hard deletion
   const deleted = { ...post.data, isDeleted: true };
 
-  fireEvent('post.deleted', { posts: [deleted] });
+  fireEvent('post.deleted', {
+    posts: [deleted],
+    categories: [],
+    comments: [],
+    communities: [],
+    communityUsers: [],
+    feeds: [],
+    files: [],
+    postChildren: [],
+    users: [],
+  });
 
   if (permanent) {
     setTimeout(() => {

package/src/post/api/getPost.ts

@@ -5,6 +5,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
 import { isInTombstone } from '~/cache/api/isInTombstone';
 import { checkIfShouldGoesToTombstone } from '~/cache/utils';
 import { pushToTombstone } from '~/cache/api/pushToTombstone';
+import { prepareMembershipPayload } from '~/group/utils';
 
 /**
  * ```js
@@ -26,14 +27,14 @@ export const getPost = async (postId: Amity.Post['postId']): Promise<Amity.Cache
 
   isInTombstone('post', postId);
 
-  let data: Amity.PostPayload;
+  let payload: Amity.PostPayload;
 
   try {
     // API-FIX: endpoint should not be /list, parameters should be querystring.
     const response = await client.http.get<Amity.PostPayload>(
       `/api/v3/posts/${encodeURIComponent(postId)}`,
     );
-    data = response.data;
+    payload = response.data;
   } catch (error) {
     if (checkIfShouldGoesToTombstone((error as Amity.ErrorResponse)?.code)) {
       pushToTombstone('post', postId);
@@ -42,6 +43,8 @@ export const getPost = async (postId: Amity.Post['postId']): Promise<Amity.Cache
     throw error;
   }
 
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 

package/src/post/api/getPosts.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api';
 
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
 
 /**
  * ```js
@@ -26,10 +27,12 @@ export const getPosts = async (
   const encodedPostIds = postIds.map(postId => encodeURIComponent(postId));
 
   // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.PostPayload>(`/api/v3/posts/list`, {
+  const { data: payload } = await client.http.get<Amity.PostPayload>(`/api/v3/posts/list`, {
     params: { postIds: encodedPostIds },
   });
 
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 

package/src/post/api/queryPosts.ts

@@ -5,6 +5,7 @@ import { toToken, toPageRaw } from '~/core/query';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
+import { prepareMembershipPayload } from '~/group/utils';
 
 /**
  * ```js
@@ -53,12 +54,13 @@ export const queryPosts = async (
   // const { paging, posts } = unwrapPayload(data)
   // unpacking
   const { paging, ...payload } = data;
+  const paperedPayload = prepareMembershipPayload(payload, 'communityUsers');
   const { posts } = payload;
 
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(payload as Amity.PostPayload, { cachedAt });
+    ingestInCache(paperedPayload, { cachedAt });
 
     const cacheKey = ['post', 'query', { ...params, options: { ...page } } as Amity.Serializable];
     pushToCache(cacheKey, { posts: posts.map(getResolver('post')), paging });

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

@@ -74,9 +74,10 @@ describe('queryPosts.locally', () => {
     enableCache();
 
     const { data } = postQueryResponse;
-    const { posts: expected, paging } = data;
+    const { paging, ...payload } = data;
+    const { posts: expected } = payload;
 
-    ingestInCache(data as Amity.PostPayload);
+    ingestInCache(payload as Amity.ProcessedPostPayload);
 
     pushToCache(cacheKey, { posts: expected.map(getResolver('post')), paging });
 
@@ -98,7 +99,7 @@ describe('queryPosts.locally', () => {
     ingestInCache({
       ...data,
       posts: [data.posts[0]],
-    } as Amity.PostPayload);
+    } as Amity.ProcessedPostPayload);
 
     pushToCache(cacheKey, {
       posts: posts.map(getResolver('post')),
@@ -119,7 +120,7 @@ describe('queryPosts.locally', () => {
     const { data } = postQueryResponse;
     const { posts: expected, paging } = data;
 
-    ingestInCache(data as Amity.PostPayload);
+    ingestInCache(data as Amity.ProcessedPostPayload);
 
     pushToCache(cacheKey, { posts: expected.map(getResolver('post')), paging });
 

package/src/post/api/updatePost.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
 
 /**
  * ```js
@@ -32,11 +33,13 @@ export const updatePost = async (
   const client = getActiveClient();
   client.log('user/updatePost', patch);
 
-  const { data } = await client.http.put<Amity.PostPayload>(
+  const { data: payload } = await client.http.put<Amity.PostPayload>(
     `/api/v4/posts/${encodeURIComponent(postId)}`,
     patch,
   );
 
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 

package/src/post/events/onPostReactionAdded.ts

@@ -30,7 +30,7 @@ export const onPostReactionAdded = (callback: Amity.Listener<Amity.Post>): Amity
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       const { reactor, ...postPayload } = payload;
 
-      ingestInCache(postPayload as Amity.CommentPayload);
+      ingestInCache(postPayload as Amity.ProcessedPostPayload);
 
       const post = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])!;
 

package/src/post/events/onPostReactionRemoved.ts

@@ -30,7 +30,7 @@ export const onPostReactionRemoved = (callback: Amity.Listener<Amity.Post>): Ami
       // eslint-disable-next-line @typescript-eslint/no-unused-vars
       const { reactor, ...postPayload } = payload;
 
-      ingestInCache(postPayload as Amity.CommentPayload);
+      ingestInCache(postPayload as Amity.ProcessedPostPayload);
 
       const post = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])!;
 

package/src/post/events/utils.ts

@@ -2,6 +2,7 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { createEventSubscriber, fireEvent } from '~/core/events';
 import { queryCache, upsertInCache, pullFromCache } from '~/cache/api';
+import { prepareMembershipPayload } from '~/group/utils';
 
 export const createPostEventSubscriber = (
   event: keyof Amity.MqttPostEvents,
@@ -15,10 +16,19 @@ export const createPostEventSubscriber = (
     } else {
       const { communities, ...others } = payload;
 
-      ingestInCache(others as Amity.PostPayload);
+      const data = prepareMembershipPayload(others, 'communityUsers');
+
+      ingestInCache(data);
 
       if (communities?.[0] && !['post.updated'].includes(event)) {
-        fireEvent('community.updated', { communities });
+        fireEvent('community.updated', {
+          communities,
+          categories: [],
+          communityUsers: [],
+          feeds: [],
+          files: [],
+          users: [],
+        });
       }
 
       const post = pullFromCache<Amity.Post>(['post', 'get', payload.posts[0].postId])!;

package/src/post/observers/tests/livePost.test.ts

@@ -6,13 +6,20 @@ import {
   disconnectClient,
   generatePost,
   user12,
+  emptyPostPayload,
 } from '~/utils/tests';
 import { getFutureDate } from '~/core/model';
+
 import { livePost } from '../livePost';
 
 describe('livePost', () => {
   const post = generatePost();
-  const response = { data: { posts: [post] } };
+  const response = {
+    data: {
+      ...emptyPostPayload,
+      posts: [post],
+    } as Amity.PostPayload,
+  };
 
   beforeAll(async () => {
     await connectClient();
@@ -47,7 +54,7 @@ describe('livePost', () => {
 
     livePost(post.postId, callback);
     await pause();
-    client.emitter.emit(event, { posts: [update] });
+    client.emitter.emit(event, { ...emptyPostPayload, posts: [update] });
     await pause();
 
     expect(callback).toHaveBeenCalledTimes(3);
@@ -82,7 +89,7 @@ describe('livePost', () => {
 
     livePost(post.postId, callback);
     await pause();
-    client.emitter.emit(event, { posts: [update], reactor });
+    client.emitter.emit(event, { ...emptyPostPayload, posts: [update], reactor });
     await pause();
 
     expect(callback).toHaveBeenCalledTimes(3);

package/src/post/observers/tests/livePosts.test.ts

@@ -9,6 +9,7 @@ import {
   post14,
   postQueryResponse,
   postQueryResponsePage2,
+  emptyPostPayload,
 } from '~/utils/tests';
 
 import { livePosts } from '../livePosts';
@@ -168,9 +169,7 @@ describe('livePosts', () => {
     await pause();
     expect(callback).toHaveBeenCalledTimes(2);
 
-    client.emitter.emit(event, {
-      posts: [post],
-    });
+    client.emitter.emit(event, { ...emptyPostPayload, posts: [post] });
 
     const payload = postQueryResponse.data;
     const deletePayload = payload.posts.filter(p => p.postId !== post.postId);
@@ -209,6 +208,7 @@ describe('livePosts', () => {
       'it should update post in collection onReactionAdded',
       'post.addReaction',
       {
+        ...emptyPostPayload,
         posts: [{ ...post11, reactionsCount: 1 }],
         reactor: {
           referenceId: post11.postId,
@@ -224,6 +224,7 @@ describe('livePosts', () => {
       'it should update post in collection onReactionRemoved',
       'post.removeReaction',
       {
+        ...emptyPostPayload,
         posts: [{ ...post11, reactionsCount: 0 }],
         reactor: {
           referenceId: post11.postId,
@@ -277,6 +278,7 @@ describe('livePosts', () => {
     expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(snapshot));
 
     client.emitter.emit('post.deleted', {
+      ...emptyPostPayload,
       posts: [deletedPost],
     });
 
@@ -303,6 +305,7 @@ describe('livePosts', () => {
     expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(snapshot));
 
     client.emitter.emit('post.approved', {
+      ...emptyPostPayload,
       posts: [approvedPost],
       feeds: [
         {
@@ -323,7 +326,11 @@ describe('livePosts', () => {
     const feedId = 'publishedFeed';
     const approvedPost = { ...post14, feedId };
 
-    const approvedFeed = { ...postQueryResponsePage2.data.feeds[0], feedType: 'published' };
+    const approvedFeed = {
+      ...postQueryResponsePage2.data.feeds[0],
+      feedType: 'published' as const,
+    };
+
     postQueryResponsePage2.data.feeds = [approvedFeed];
 
     const callback = jest.fn();
@@ -341,6 +348,7 @@ describe('livePosts', () => {
     expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(snapshot));
 
     client.emitter.emit('post.approved', {
+      ...emptyPostPayload,
       posts: [approvedPost],
       feeds: [
         {

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

@@ -1,5 +1,5 @@
 import { ASCApiError } from '~/core/errors';
-import { client, posts } from '~/utils/tests';
+import { client, emptyPostPayload, posts } from '~/utils/tests';
 import { pushToCache, enableCache, disableCache } from '~/cache/api';
 
 import { getPost } from '~/post/api';
@@ -44,7 +44,12 @@ describe('post/api', () => {
 
   describe('getPost', () => {
     test('should return a post', async () => {
-      client.http.get = jest.fn().mockReturnValueOnce({ data: { posts: [post] } });
+      client.http.get = jest.fn().mockReturnValueOnce({
+        data: {
+          ...emptyPostPayload,
+          posts: [post],
+        },
+      });
 
       const data = await getPost(post.postId);
 
@@ -54,7 +59,12 @@ describe('post/api', () => {
 
     test('should put post into the cache after fetch', async () => {
       enableCache();
-      client.http.get = jest.fn().mockReturnValueOnce({ data: { posts: [post] } });
+      client.http.get = jest.fn().mockReturnValueOnce({
+        data: {
+          ...emptyPostPayload,
+          posts: [post],
+        },
+      });
 
       await getPost(post.postId);