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

package/src/post/events/tests/onPostFlagged.test.ts

@@ -0,0 +1,33 @@
+import { onPostFlagged } from '../onPostFlagged';
+import { client, connectClient, disconnectClient, postPayload, post11 } from '~/utils/tests';
+
+describe('onPostFlagged', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should got event after post flagged', () => {
+    const callback = jest.fn();
+    const unsub = onPostFlagged(callback);
+    client.emitter.emit('post.flagged', postPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(post11);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onPostFlagged(callback);
+
+    unsub();
+
+    client.emitter.emit('post.flagged', postPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/post/events/tests/onPostReactionAdded.test.ts

@@ -0,0 +1,40 @@
+import { onPostReactionAdded } from '../onPostReactionAdded';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  postPayload,
+  post11,
+  reaction11,
+} from '~/utils/tests';
+
+describe('onPostReactionAdded', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should got event after add reaction to post', () => {
+    const callback = jest.fn();
+    const unsub = onPostReactionAdded(callback);
+    client.emitter.emit('post.addReaction', { ...postPayload, reactor: reaction11 });
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(post11);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onPostReactionAdded(callback);
+
+    unsub();
+
+    client.emitter.emit('post.addReaction', { ...postPayload, reactor: reaction11 });
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/post/events/tests/onPostReactionRemoved.test.ts

@@ -0,0 +1,40 @@
+import { onPostReactionRemoved } from '../onPostReactionRemoved';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  postPayload,
+  post11,
+  reaction11,
+} from '~/utils/tests';
+
+describe('onPostReactionRemoved', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should got event after reaction got removed from post', () => {
+    const callback = jest.fn();
+    const unsub = onPostReactionRemoved(callback);
+    client.emitter.emit('post.removeReaction', { ...postPayload, reactor: reaction11 });
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(post11);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onPostReactionRemoved(callback);
+
+    unsub();
+
+    client.emitter.emit('post.removeReaction', { ...postPayload, reactor: reaction11 });
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/post/events/tests/onPostUnflagged.test.ts

@@ -0,0 +1,33 @@
+import { onPostUnflagged } from '../onPostUnflagged';
+import { client, connectClient, disconnectClient, postPayload, post11 } from '~/utils/tests';
+
+describe('onPostUnflagged', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should got event after post unflagged', () => {
+    const callback = jest.fn();
+    const unsub = onPostUnflagged(callback);
+    client.emitter.emit('post.unflagged', postPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(post11);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onPostUnflagged(callback);
+
+    unsub();
+
+    client.emitter.emit('post.unflagged', postPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/post/events/tests/onPostUpdated.test.ts

@@ -0,0 +1,33 @@
+import { onPostUpdated } from '../onPostUpdated';
+import { client, connectClient, disconnectClient, postPayload, post11 } from '~/utils/tests';
+
+describe('onPostUpdated', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  test('it should got event after post updated', () => {
+    const callback = jest.fn();
+    const unsub = onPostUpdated(callback);
+    client.emitter.emit('post.updated', postPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(post11);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onPostUpdated(callback);
+
+    unsub();
+
+    client.emitter.emit('post.updated', postPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/post/events/utils.ts

@@ -4,7 +4,7 @@ import { createEventSubscriber, fireEvent } from '~/core/events';
 import { queryCache, upsertInCache, pullFromCache } from '~/cache/api';
 
 export const createPostEventSubscriber = (
-  event: keyof Amity.MqttPostMessageEvents,
+  event: keyof Amity.MqttPostEvents,
   callback: Amity.Listener<Amity.Post>,
 ) => {
   const client = getActiveClient();

package/src/post/observers/livePosts.ts

@@ -89,6 +89,10 @@ export const livePosts = (
 
     posts = posts.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
 
+    if (params.tags) {
+      posts = posts.filter(p => p.tags?.some(t => params.tags?.includes(t)));
+    }
+
     callback({
       onNextPage: onFetch,
       data: posts,
@@ -98,18 +102,34 @@ export const livePosts = (
     });
   };
 
-  const realtimeRouter = (post: Amity.Post, action: Amity.PostActionType) => {
+  const realtimeRouter = (action: Amity.PostActionType) => (post: Amity.Post) => {
     const collection = pullFromCache<Amity.PostLiveCollectionCache>(cacheKey)?.data;
 
     if (params.targetId !== post.targetId || params.targetType !== post.targetType || !collection)
       return;
 
-    if (action === 'onCreate') {
+    if (['onCreate', 'onApproved'].includes(action)) {
       collection.data = [...new Set([post.postId, ...collection.data])];
     } else if (['onDelete', 'onDeclined'].includes(action)) {
       collection.data = collection.data.filter(p => p !== post.postId);
+
+      /*
+       * if isDeleted is true, collection should add deleted items to the
+       * begining of the collection
+       */
+      if (params.isDeleted) collection.data.unshift(post.postId);
     }
 
+    /*
+     * FIX-ME
+     * This is a shortcoming as the feed object is not saved to the cache.
+     * The responder should pull the feed from cache once available and should
+     * match the collection to feedType param
+     * https://ekoapp.atlassian.net/browse/ASC-9382
+     */
+    if (params.feedType === 'reviewing' && action === 'onApproved')
+      collection.data = collection.data.filter(p => p !== post.postId);
+
     pushToCache(cacheKey, collection);
 
     responder(collection);
@@ -150,16 +170,16 @@ export const livePosts = (
   };
 
   disposers.push(
-    onPostCreated(post => realtimeRouter(post, 'onCreate')),
-    onPostApproved(post => realtimeRouter(post, 'onApproved')),
-    onPostDeclined(post => realtimeRouter(post, 'onDeclined')),
-    onPostDeleted(post => realtimeRouter(post, 'onDelete')),
-
-    onPostUpdated(post => realtimeRouter(post, 'onUpdate')),
-    onPostFlagged(post => realtimeRouter(post, 'onFlagged')),
-    onPostUnflagged(post => realtimeRouter(post, 'onUnflagged')),
-    onPostReactionAdded(post => realtimeRouter(post, 'onReactionAdded')),
-    onPostReactionRemoved(post => realtimeRouter(post, 'onReactionRemoved')),
+    onPostCreated(realtimeRouter('onCreate')),
+    onPostApproved(realtimeRouter('onApproved')),
+    onPostDeclined(realtimeRouter('onDeclined')),
+    onPostDeleted(realtimeRouter('onDelete')),
+
+    onPostUpdated(realtimeRouter('onUpdate')),
+    onPostFlagged(realtimeRouter('onFlagged')),
+    onPostUnflagged(realtimeRouter('onUnflagged')),
+    onPostReactionAdded(realtimeRouter('onReactionAdded')),
+    onPostReactionRemoved(realtimeRouter('onReactionRemoved')),
   );
 
   onFetch();

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

@@ -0,0 +1,302 @@
+import { disableCache, enableCache } from '~/cache/api';
+
+import {
+  client,
+  pause,
+  connectClient,
+  disconnectClient,
+  post11,
+  postQueryResponse,
+  postQueryResponsePage2,
+} 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, isDeleted: false }],
+    ['deleted', { ...params, isDeleted: true }, 1],
+    ['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][] = [
+    [
+      'it should add new post to collection onCreate',
+      'post.created',
+      { ...post11, postId: 'new-post-id' },
+    ],
+    ['it should edit post in collection onUpdate', 'post.updated', post11],
+    [
+      'it should update post in collection onApproved',
+      'post.approved',
+      { ...post11, postId: 'approved-post-id' },
+    ],
+    ['it should remove post in collection onDelete', 'post.deleted', post11],
+    ['it should remove post in collection onDeclined', 'post.declined', post11],
+  ];
+
+  test.each(events)('%s', async (test, event, post) => {
+    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, {
+      posts: [post],
+    });
+
+    const payload = postQueryResponse.data;
+    const deletePayload = payload.posts.filter(post => post.postId !== post11.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',
+      {
+        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',
+      {
+        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, isDeleted: true }, callback);
+
+    await pause();
+    const payload = postQueryResponsePage2.data.posts.filter(p => p.isDeleted);
+    const snapshot = getSnapshot();
+
+    snapshot.data = payload;
+    snapshot.loading = false;
+
+    expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(snapshot));
+
+    client.emitter.emit('post.deleted', {
+      posts: [deletedPost],
+    });
+
+    snapshot.data = [deletedPost, ...payload];
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  test('it should remove approved post when feedtype reviewing', async () => {
+    const approvedPost = post11;
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(postQueryResponsePage2);
+
+    livePosts({ ...params, 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', {
+      posts: [approvedPost],
+    });
+
+    snapshot.data = payload.filter(({ postId }) => postId !== approvedPost.postId);
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+});

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
@@ -36,8 +37,20 @@ export const addReaction = async (
     referenceId,
     referenceType,
     reactionName,
+    referenceVersion: referenceType === 'message' ? 5 : undefined,
   });
 
+  if (client.cache) {
+    const model = pullFromCache<Amity.Model[Amity.ReactableType]>([
+      referenceType,
+      'get',
+      referenceId,
+    ]);
+
+    model?.data &&
+      pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+  }
+
   return true;
 };
 
@@ -88,7 +101,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
@@ -33,9 +34,25 @@ export const removeReaction = async (
   });
 
   await client.http.delete<{ removedId: string }>(`/api/v2/reactions`, {
-    data: { referenceId, referenceType, reactionName },
+    data: {
+      referenceId,
+      referenceType,
+      reactionName,
+      referenceVersion: referenceType === 'message' ? 5 : undefined,
+    },
   });
 
+  if (client.cache) {
+    const model = pullFromCache<Amity.Model[Amity.ReactableType]>([
+      referenceType,
+      'get',
+      referenceId,
+    ]);
+
+    model?.data &&
+      pushToCache([referenceType, 'get', referenceId], model.data, { cachedAt: Date.now() });
+  }
+
   return true;
 };
 
@@ -86,7 +103,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);