@amityco/ts-sdk 0.0.1-e5fb0d2.0 → 0.0.1-e643f6f.0

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

@@ -0,0 +1,366 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  pause,
+  connectClient,
+  disconnectClient,
+  post11,
+  post14,
+  postQueryResponse,
+  postQueryResponsePage2,
+  emptyPostPayload,
+} from '~/utils/tests';
+
+import { livePosts } from '../livePosts';
+
+const getSnapshot = () => {
+  return {
+    data: [] as Amity.Post[],
+    loading: true,
+    error: undefined as any,
+  };
+};
+
+const { targetId, targetType } = post11;
+const params = { targetId, targetType };
+
+describe('livePosts', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  test('it should return post collection', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponse);
+
+    livePosts(params, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    const snapshot = getSnapshot();
+
+    // check if cache data returned (should be empty)
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    // cause we apply prepareChannelPayload on post raw data from server
+    const payload = postQueryResponse.data;
+
+    snapshot.data = payload.posts;
+    snapshot.loading = false;
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+  });
+
+  const filters: [string, Amity.PostLiveCollection, number?][] = [
+    ['not deleted', { ...params, includeDeleted: false }],
+    ['tags', { ...params, tags: ['test_tag'] }, 1],
+  ];
+
+  test.each(filters)(
+    'it should filter by %s posts',
+    async (filter, params, expectedPostIdx = 0) => {
+      const callback = jest.fn();
+      client.http.get = jest.fn().mockResolvedValue(postQueryResponsePage2);
+
+      const payload = postQueryResponsePage2.data;
+      const snapshotData = [payload.posts[expectedPostIdx]];
+
+      livePosts(params, callback);
+
+      expect(callback).toHaveBeenCalledTimes(1);
+
+      const snapshot = getSnapshot();
+      // check if cache data returned (should be empty)
+      expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+      await pause();
+
+      expect(callback).toHaveBeenCalledTimes(2);
+
+      snapshot.loading = false;
+      snapshot.data = snapshotData;
+
+      expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+    },
+  );
+
+  test('it should return method to fetch next page', async () => {
+    const callback = jest.fn();
+    client.http.get = jest
+      .fn()
+      .mockResolvedValue(postQueryResponse)
+      .mockResolvedValueOnce(postQueryResponsePage2);
+
+    livePosts(params, callback);
+
+    expect(callback).toHaveBeenCalled();
+
+    await pause();
+
+    expect(callback.mock.lastCall).toHaveLength(1);
+
+    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
+
+    expect(hasNextPage).toBe(true);
+    expect(onNextPage).toBeTruthy();
+
+    onNextPage();
+
+    await pause();
+
+    // 4 -> becuase 1 local & server call each per call (2)
+    expect(callback).toHaveBeenCalledTimes(4);
+
+    const payload = postQueryResponse.data;
+    const payload2 = postQueryResponsePage2.data;
+
+    const snapshot = getSnapshot();
+    snapshot.loading = false;
+    snapshot.data = [...payload2.posts, ...payload.posts];
+
+    expect(callback).toHaveBeenNthCalledWith(4, expect.objectContaining(snapshot));
+  });
+
+  const events: [string, keyof Amity.Events, Amity.Post, Amity.PostLiveCollection][] = [
+    [
+      'it should add new post to collection onCreate',
+      'post.created',
+      { ...post11, postId: 'new-post-id' },
+      params,
+    ],
+    ['it should edit post in collection onUpdate', 'post.updated', post11, params],
+    [
+      'it should update post in collection onApproved',
+      'post.approved',
+      { ...post11, postId: 'approved-post-id' },
+      params,
+    ],
+    [
+      'it should remove post in collection onDelete',
+      'post.deleted',
+      { ...post11, isDeleted: true },
+      { ...params, includeDeleted: false },
+    ],
+    ['it should remove post in collection onDeclined', 'post.declined', post11, params],
+  ];
+
+  test.each(events)('%s', async (test, event, post, params) => {
+    const snapshot = getSnapshot();
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponse);
+
+    livePosts(params, callback);
+
+    await pause();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit(event, { ...emptyPostPayload, posts: [post] });
+
+    const payload = postQueryResponse.data;
+    const deletePayload = payload.posts.filter(p => p.postId !== post.postId);
+
+    snapshot.loading = false;
+    // get data based on event
+    switch (event) {
+      case 'post.created':
+      case 'post.approved':
+        snapshot.data = [post, ...payload.posts];
+        break;
+
+      case 'post.deleted':
+      case 'post.declined':
+        snapshot.data = deletePayload;
+        break;
+
+      case 'post.addReaction':
+        payload.posts[0] = post;
+        snapshot.data = payload.posts;
+        break;
+
+      default:
+        snapshot.data = payload.posts;
+    }
+
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  const reactionEvents: [
+    string,
+    keyof Amity.Events,
+    Amity.PostPayload & { reactor: Amity.Reaction },
+  ][] = [
+    [
+      'it should update post in collection onReactionAdded',
+      'post.addReaction',
+      {
+        ...emptyPostPayload,
+        posts: [{ ...post11, reactionsCount: 1 }],
+        reactor: {
+          referenceId: post11.postId,
+          referenceType: 'post',
+          reactionId: 'test-reaction-id',
+          reactionName: 'like',
+          userId: 'test',
+          createdAt: '',
+        },
+      },
+    ],
+    [
+      'it should update post in collection onReactionRemoved',
+      'post.removeReaction',
+      {
+        ...emptyPostPayload,
+        posts: [{ ...post11, reactionsCount: 0 }],
+        reactor: {
+          referenceId: post11.postId,
+          referenceType: 'post',
+          reactionId: 'test-reaction-id',
+          reactionName: 'like',
+          userId: 'test',
+          createdAt: '',
+        },
+      },
+    ],
+  ];
+
+  test.each(reactionEvents)('%s', async (test, event, reactionPayload) => {
+    const expectedReactionCount = reactionPayload.posts[0].reactionsCount;
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponse);
+
+    livePosts(params, callback);
+
+    await pause();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit(event, reactionPayload);
+
+    const { reactionsCount } = callback.mock.lastCall[0].data[0];
+    expect(reactionsCount).toBe(expectedReactionCount);
+  });
+
+  /*
+   * This test was added as when isDeleted posts were queried, the livePosts api
+   * would try to delete the post when 'post.deleted' event occured, where instead
+   * it should be adding it to the collection. As livePosts is called with a
+   * param to reutrun deleted posts only
+   */
+  test('it should update posts to include deleted post', async () => {
+    const deletedPost = { ...post11, isDeleted: true };
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponsePage2);
+
+    livePosts({ ...params, includeDeleted: true }, callback);
+
+    await pause();
+    const payload = postQueryResponsePage2.data.posts;
+    const snapshot = getSnapshot();
+
+    snapshot.data = payload;
+    snapshot.loading = false;
+
+    expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(snapshot));
+
+    client.emitter.emit('post.deleted', {
+      ...emptyPostPayload,
+      posts: [deletedPost],
+    });
+
+    snapshot.data = [deletedPost, ...payload];
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  test('it should remove approved post when feedtype reviewing', async () => {
+    const feedId = 'publishedFeed';
+    const approvedPost = { ...post14, feedId };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponsePage2);
+
+    livePosts({ ...params, targetType: 'community', feedType: 'reviewing' }, callback);
+
+    await pause();
+    const payload = postQueryResponsePage2.data.posts;
+    const snapshot = getSnapshot();
+
+    snapshot.data = payload;
+    snapshot.loading = false;
+
+    expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(snapshot));
+
+    client.emitter.emit('post.approved', {
+      ...emptyPostPayload,
+      posts: [approvedPost],
+      feeds: [
+        {
+          ...postQueryResponsePage2.data.feeds[0],
+          targetType: 'community',
+          feedId,
+          feedType: 'published',
+        },
+      ],
+    });
+
+    snapshot.data = payload.filter(({ postId }) => postId !== approvedPost.postId);
+
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  test('it should remove reviewing post when feedtype published', async () => {
+    const feedId = 'publishedFeed';
+    const approvedPost = { ...post14, feedId };
+
+    const approvedFeed = {
+      ...postQueryResponsePage2.data.feeds[0],
+      feedType: 'published' as const,
+    };
+
+    postQueryResponsePage2.data.feeds = [approvedFeed];
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponsePage2);
+
+    livePosts({ ...params, targetType: 'community', feedType: 'published' }, callback);
+
+    await pause();
+    const payload = postQueryResponsePage2.data.posts;
+    const snapshot = getSnapshot();
+
+    snapshot.data = payload;
+    snapshot.loading = false;
+
+    expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(snapshot));
+
+    client.emitter.emit('post.approved', {
+      ...emptyPostPayload,
+      posts: [approvedPost],
+      feeds: [
+        {
+          ...postQueryResponsePage2.data.feeds[0],
+          targetType: 'community',
+          feedId,
+          feedType: 'reviewing',
+        },
+      ],
+    });
+
+    snapshot.data = payload.filter(({ postId }) => postId !== approvedPost.postId);
+
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+});

package/src/reaction/api/addReaction.ts

@@ -1,9 +1,13 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { mutateCache } from '~/core/cache'
+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';
 
+/* begin_public_function
+  id: reaction.add
+*/
 /**
  * ```js
  * import { addReaction } from '@amityco/ts-sdk'
@@ -19,29 +23,40 @@ import { dispatchReactable, fetchReference } from '../utils'
  *
  * @category Reaction API
  * @async
- **/
+ * */
 export const addReaction = async (
   referenceType: Amity.Reaction['referenceType'],
   referenceId: Amity.Reaction['referenceId'],
-  reactionName: Amity.Reaction['reactionName']
-) => {
-  const client = getActiveClient()
+  reactionName: Amity.Reaction['reactionName'],
+): Promise<boolean> => {
+  const client = getActiveClient();
   client.log('reaction/createReaction', {
     referenceId,
     referenceType,
     reactionName,
-  })
+  });
 
-  await client.http.post<{ addedId: 'string' }>(
-    '/api/v2/reactions',
-    { referenceId, referenceType, reactionName }
-  )
+  await client.http.post<{ addedId: 'string' }>('/api/v2/reactions', {
+    referenceId,
+    referenceType,
+    reactionName,
+    referenceVersion: referenceType === 'message' ? 5 : undefined,
+  });
+
+  if (client.cache) {
+    const model = pullFromCache<Amity.Models[Amity.ReactableType]>([
+      referenceType,
+      'get',
+      referenceId,
+    ]);
 
-  const model = await fetchReference(referenceType, referenceId)
-  dispatchReactable(referenceType, model)
+    model?.data &&
+      pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+  }
 
-  return model.myReactions?.includes(reactionName) ?? false
-}
+  return true;
+};
+/* end_public_function */
 
 /**
  * ```js
@@ -57,28 +72,44 @@ export const addReaction = async (
  * @returns The added result.
  *
  * @category Reaction API
- **/
+ * */
 addReaction.optimistically = (
   referenceType: Amity.ReactableType,
   referenceId: Amity.Reaction['referenceId'],
-  reactionName: Amity.Reaction['reactionName']
-) => {
-  const model = mutateCache(referenceType, referenceId, model => {
-    if (model.myReactions?.includes(reactionName)) return
+  reactionName: Amity.Reaction['reactionName'],
+): boolean | undefined => {
+  const client = getActiveClient();
+  client.log('reaction/createReaction.optimistically', {
+    referenceId,
+    referenceType,
+    reactionName,
+  });
+
+  if (!client.cache) return;
+
+  const model = pullFromCache<Amity.Models[Amity.ReactableType]>([
+    referenceType,
+    'get',
+    referenceId,
+  ]);
+
+  if (!model?.data || model.data.myReactions?.includes(reactionName)) return;
+
+  const reaction = {
+    ...model.data,
+    reactionsCount: model.data.reactionsCount + 1,
+    myReactions: [...(model.data.myReactions ?? []), reactionName],
+    reactions: {
+      ...model.data.reactions,
+      [reactionName]: (model.data.reactions[reactionName] ?? 0) + 1,
+    },
+  } as Amity.Models[Amity.ReactableType];
 
-    return {
-      ...model,
-      syncedAt: -1,
-      reactionsCount: model.reactionsCount + 1,
-      myReactions: [...(model.myReactions ?? []), reactionName],
-      reactions: {
-        ...model.reactions,
-        [reactionName]: (model.reactions[reactionName] ?? 0) + 1,
-      },
-    }
-  })
+  upsertInCache([referenceType, 'get', referenceId], reaction, {
+    cachedAt: UNSYNCED_OBJECT_CACHED_AT_VALUE,
+  });
 
-  model && dispatchReactable(referenceType, model)
+  dispatchReactable(referenceType, reaction);
 
-  return model?.myReactions?.includes(reactionName) ?? false
-}
+  return reaction?.myReactions?.includes(reactionName) ?? false;
+};

package/src/reaction/api/index.ts

@@ -1,2 +1,3 @@
-export * from './addReaction'
-export * from './removeReaction'
+export * from './addReaction';
+export * from './removeReaction';
+export * from './queryReactions';

package/src/reaction/api/queryReactions.ts

@@ -0,0 +1,58 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { toToken, toPageRaw } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+/* begin_public_function
+  id: reaction.query
+*/
+/**
+ * ```js
+ * import { queryReactions } from '@amityco/ts-sdk'
+ * const { data: reactions, prevPage, nextPage } = await queryReactions({
+ *   referenceId: 'postId',
+ *   referenceType: 'post',
+ * })
+ * ```
+ *
+ * Queries a paginable list of {@link Amity.ReactionQuery} objects
+ *
+ * @param query The query parameters
+ * @returns A page of {@link Amity.Reaction} objects
+ *
+ * @reaction Reaction API
+ * @async
+ * */
+export const queryReactions = async (
+  query: Amity.QueryReactions,
+): Promise<Amity.Paged<Amity.ReactionQuery, Amity.Page<string>>> => {
+  const client = getActiveClient();
+  client.log('reaction/queryReactions', query);
+
+  const { page = { limit: 10 }, ...params } = query ?? {};
+
+  const { data } = await client.http.get<Amity.ReactionPayload & Amity.Pagination>(
+    `/api/v3/reactions`,
+    {
+      params: {
+        ...params,
+        options: {
+          token: toToken(page, 'afterbeforeraw'),
+        },
+      },
+    },
+  );
+
+  const { paging, ...payload } = data;
+  const { reactions } = payload;
+
+  // FIXME: correct reactions type in model
+  // @ts-ignore
+  ingestInCache({ ...payload, reactions: reactions[0].reactors });
+
+  const nextPage = toPageRaw(paging.next);
+  const prevPage = toPageRaw(paging.previous);
+
+  return { data: reactions, prevPage, nextPage };
+};
+/* end_public_function */