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

package/src/message/tests/observers/liveMessage.test.ts

@@ -1,9 +1,6 @@
 import { ASCApiError } from '~/core/errors';
 import { disableCache, enableCache } from '~/cache/api';
-import {
-  LIVE_OBJECT_ENABLE_CACHE_MESSAGE,
-  UNSYNCED_OBJECT_CACHED_AT_MESSAGE,
-} from '~/utils/constants';
+import { UNSYNCED_OBJECT_CACHED_AT_MESSAGE } from '~/utils/constants';
 import { pause, client, connectClient, disconnectClient, generateRawMessage } from '~/utils/tests';
 import { getFutureDate } from '~/core/model';
 import { convertFromRaw } from '../../utils';
@@ -37,145 +34,6 @@ describe('liveMessage', () => {
 
   afterEach(disableCache);
 
-  test('it should show message if cache not enabled', () => {
-    /*
-     * NOTE: at the time of writing this test cache is diabled by default, but
-     * there is a proposal to enable cache by default. So I'm disabling cache
-     * here to ensure cache is disabled
-     */
-    disableCache();
-
-    const callback = jest.fn();
-    jest.spyOn(global.console, 'log');
-    client.http.get = jest.fn();
-
-    // call liveMessage check if mocked console get's called with the correct
-    // message
-    client.use();
-    liveMessage(message.messageId, callback);
-
-    expect(console.log).toBeCalledWith(LIVE_OBJECT_ENABLE_CACHE_MESSAGE);
-  });
-
-  test('it should return message live object', async () => {
-    const snapshot = getSnapshot();
-
-    // mock response of queryMessages and validate
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(messageQueryResponseRaw);
-
-    liveMessage(message.messageId, callback);
-
-    expect(callback).toHaveBeenCalledTimes(1);
-
-    // 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 = message;
-
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
-  });
-
-  test('it should return error on api failure', async () => {
-    const snapshot = getSnapshot();
-    const error = new ASCApiError(
-      'server error!',
-      Amity.ServerError.ITEM_NOT_FOUND,
-      Amity.ErrorLevel.ERROR,
-    );
-
-    // mock response of queryMessages and validate
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockRejectedValue(error);
-
-    liveMessage(message.messageId, callback);
-
-    expect(callback).toHaveBeenCalledTimes(1);
-
-    // check if cache data returned (should be empty)
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
-
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-
-    snapshot.error = error;
-    snapshot.loading = false;
-    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
-  });
-
-  test('it should terminate updates on api failure', async () => {
-    const snapshot = getSnapshot();
-    const error = new ASCApiError(
-      'server error!',
-      Amity.ServerError.ITEM_NOT_FOUND,
-      Amity.ErrorLevel.ERROR,
-    );
-
-    // mock response of queryMessages and validate
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockRejectedValue(error);
-
-    liveMessage(message.messageId, callback);
-
-    expect(callback).toHaveBeenCalledTimes(1);
-
-    // check if cache data returned (should be empty)
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
-
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-
-    snapshot.error = error;
-    snapshot.loading = false;
-    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
-
-    const rawUpdatedMessage = { ...rawMessage, updatedAt: getFutureDate(rawMessage.updatedAt) };
-    const updatedMessage = convertFromRaw(rawUpdatedMessage);
-    client.emitter.emit('message.updated', { messages: [rawUpdatedMessage] });
-
-    delete snapshot.error;
-    snapshot.loading = false;
-    snapshot.data = updatedMessage;
-    expect(callback).not.toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
-  });
-
-  test('it should not return updates on obtain once!', async () => {
-    const snapshot = getSnapshot();
-
-    // mock response of queryMessages and validate
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(messageQueryResponseRaw);
-
-    const unsub = liveMessage(message.messageId, callback);
-
-    expect(callback).toHaveBeenCalledTimes(1);
-
-    // check if cache data returned (should be empty)
-    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
-
-    await pause();
-
-    expect(callback).toHaveBeenCalledTimes(2);
-
-    unsub();
-
-    const rawUpdatedMessage = { ...rawMessage, updatedAt: getFutureDate(rawMessage.updatedAt) };
-    const updatedMessage = convertFromRaw(rawUpdatedMessage);
-    client.emitter.emit('message.updated', { messages: [rawUpdatedMessage] });
-
-    delete snapshot.error;
-    snapshot.loading = false;
-    snapshot.data = updatedMessage;
-    expect(callback).not.toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
-  });
-
   const events: [string, keyof Amity.Events][] = [
     ['it should return updated message on onFetch', 'local.message.fetched'],
     ['it should return updated message on onUpdate', 'message.updated'],

package/src/message/tests/observers/liveMessages.test.ts

@@ -182,8 +182,8 @@ describe('liveMessages', () => {
         data: {
           messages: returnValue,
           paging: {
-            previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
-            next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+            previous: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+            next: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
           },
         },
       })
@@ -191,8 +191,8 @@ describe('liveMessages', () => {
         data: {
           messages: returnValue2,
           paging: {
-            previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
-            next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+            previous: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
+            next: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
           },
         },
       });

package/src/post/observers/index.ts

@@ -1,3 +1,4 @@
 export * from './observePosts';
 export * from './observePost';
+export * from './livePost';
 export * from './livePosts';

package/src/post/observers/livePost.ts

@@ -0,0 +1,47 @@
+import { liveObject } from '~/utils/liveObject';
+import { getPost } from '../api';
+import {
+  onPostApproved,
+  onPostDeclined,
+  onPostDeleted,
+  onPostFlagged,
+  onPostReactionAdded,
+  onPostReactionRemoved,
+  onPostUnflagged,
+  onPostUpdated,
+} from '../events';
+
+/**
+ * ```js
+ * import { livePost } from '@amityco/ts-sdk';
+ *
+ * let post;
+ *
+ * const unsubscribe = livePost(postId, response => {
+ *   post = response.data;
+ * });
+ * ```
+ *
+ * Observe all mutation on a given {@link Amity.Post}
+ *
+ * @param postId the ID of the message to observe
+ * @param callback the function to call when new data are available
+ * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the sub channel
+ *
+ * @category Post Live Object
+ */
+export const livePost = (
+  postId: Amity.Post['postId'],
+  callback: Amity.LiveObjectCallback<Amity.Post>,
+): Amity.Unsubscriber => {
+  return liveObject(postId, callback, 'postId', getPost, [
+    onPostApproved,
+    onPostDeclined,
+    onPostDeleted,
+    onPostFlagged,
+    onPostReactionAdded,
+    onPostReactionRemoved,
+    onPostUnflagged,
+    onPostUpdated,
+  ]);
+};

package/src/post/observers/livePosts.ts

@@ -7,6 +7,7 @@ import {
   runQuery,
   queryOptions,
   filterByPropEquality,
+  filterByFeedType,
   sortByFirstCreated,
   sortByLastCreated,
 } from '~/core/query';
@@ -43,8 +44,8 @@ import { queryPosts } from '../api';
  *
  * Observe all mutations on a list of {@link Amity.Post} for a given target object
  *
- * @param targetType the type of the target
- * @param targetId the ID of the target
+ * @param param.targetType the type of the target
+ * @param param.targetId the ID of the target
  * @param callback the function to call when new data are available
  * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the messages
  *
@@ -86,13 +87,16 @@ export const livePosts = (
     posts = filterByPropEquality(posts, 'isDeleted', params.isDeleted);
 
     const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
-
     posts = posts.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
 
     if (params.tags) {
       posts = posts.filter(p => p.tags?.some(t => params.tags?.includes(t)));
     }
 
+    if (params.targetType === 'community' && params.feedType) {
+      posts = filterByFeedType(posts, params.feedType);
+    }
+
     callback({
       onNextPage: onFetch,
       data: posts,
@@ -108,27 +112,15 @@ export const livePosts = (
     if (params.targetId !== post.targetId || params.targetType !== post.targetType || !collection)
       return;
 
-    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
+     * This is not ideal, but currently this is the only way to update the
+     * collection on post declined
      */
-    if (params.feedType === 'reviewing' && action === 'onApproved')
-      collection.data = collection.data.filter(p => p !== post.postId);
+    if (action === 'onDeclined') {
+      collection.data = collection.data.filter(postId => postId !== post.postId);
+    } else {
+      collection.data = [...new Set([post.postId, ...collection.data])];
+    }
 
     pushToCache(cacheKey, collection);
 

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

@@ -0,0 +1,97 @@
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  pause,
+  client,
+  connectClient,
+  disconnectClient,
+  generatePost,
+  user12,
+} from '~/utils/tests';
+import { getFutureDate } from '~/core/model';
+import { livePost } from '../livePost';
+
+describe('livePost', () => {
+  const post = generatePost();
+  const response = { data: { posts: [post] } };
+
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const events: [string, keyof Amity.MqttPostEvents][] = [
+    ['should get update on post.updated event', 'post.updated'],
+    ['should get update on post.deleted event', 'post.deleted'],
+    ['should get update on post.approved event', 'post.approved'],
+    ['should get update on post.declined event', 'post.declined'],
+    ['should get update on post.flagged event', 'post.flagged'],
+    ['should get update on post.unflagged event', 'post.unflagged'],
+  ];
+
+  test.each(events)('%s', async (test, event) => {
+    const update = {
+      ...post,
+      data: { text: 'new-text' },
+      updatedAt: getFutureDate(post.updatedAt),
+    };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    livePost(post.postId, callback);
+    await pause();
+    client.emitter.emit(event, { posts: [update] });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: update,
+        loading: false,
+      }),
+    );
+  });
+
+  test.each([
+    ['should get update on post.addReaction event', 'post.addReaction'],
+    ['should get update on post.removeReaction event', 'post.removeReaction'],
+  ] as [string, keyof Amity.MqttPostEvents][])('%s', async (test, event) => {
+    const update = {
+      ...post,
+      data: { text: 'new-text' },
+      updatedAt: getFutureDate(post.updatedAt),
+    };
+    const reactor: Amity.Reaction = {
+      createdAt: getFutureDate(post.updatedAt),
+      reactionId: 'like',
+      reactionName: 'like',
+      referenceId: post.postId,
+      referenceType: 'post',
+      userId: user12.userId,
+    };
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    livePost(post.postId, callback);
+    await pause();
+    client.emitter.emit(event, { posts: [update], reactor });
+    await pause();
+
+    expect(callback).toHaveBeenCalledTimes(3);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining({
+        data: update,
+        loading: false,
+      }),
+    );
+  });
+});

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

@@ -6,6 +6,7 @@ import {
   connectClient,
   disconnectClient,
   post11,
+  post14,
   postQueryResponse,
   postQueryResponsePage2,
 } from '~/utils/tests';
@@ -133,23 +134,30 @@ describe('livePosts', () => {
     expect(callback).toHaveBeenNthCalledWith(4, expect.objectContaining(snapshot));
   });
 
-  const events: [string, keyof Amity.Events, Amity.Post][] = [
+  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],
+    ['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],
-    ['it should remove post in collection onDeclined', 'post.declined', post11],
+    [
+      'it should remove post in collection onDelete',
+      'post.deleted',
+      { ...post11, isDeleted: true },
+      { ...params, isDeleted: false },
+    ],
+    ['it should remove post in collection onDeclined', 'post.declined', post11, params],
   ];
 
-  test.each(events)('%s', async (test, event, post) => {
+  test.each(events)('%s', async (test, event, post, params) => {
     const snapshot = getSnapshot();
 
     const callback = jest.fn();
@@ -165,7 +173,7 @@ describe('livePosts', () => {
     });
 
     const payload = postQueryResponse.data;
-    const deletePayload = payload.posts.filter(post => post.postId !== post11.postId);
+    const deletePayload = payload.posts.filter(p => p.postId !== post.postId);
 
     snapshot.loading = false;
     // get data based on event
@@ -277,11 +285,51 @@ describe('livePosts', () => {
   });
 
   test('it should remove approved post when feedtype reviewing', async () => {
-    const approvedPost = post11;
+    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', {
+      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' };
+    postQueryResponsePage2.data.feeds = [approvedFeed];
+
     const callback = jest.fn();
     client.http.get = jest.fn().mockResolvedValue(postQueryResponsePage2);
 
-    livePosts({ ...params, feedType: 'reviewing' }, callback);
+    livePosts({ ...params, targetType: 'community', feedType: 'published' }, callback);
 
     await pause();
     const payload = postQueryResponsePage2.data.posts;
@@ -294,9 +342,18 @@ describe('livePosts', () => {
 
     client.emitter.emit('post.approved', {
       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/report/api/createReport.ts

@@ -49,12 +49,7 @@ export const createReport = async (
       referenceType === 'message' ? prepareMessagePayload(data as Amity.RawMessagePayload) : data,
     );
 
-  if (referenceType === 'message') {
-    fireEvent('message.flagged', data as Amity.RawMessagePayload);
-  } else {
-    // @ts-ignore
-    fireEvent(`${referenceType}.flagged`, data);
-  }
+  fireEvent(`${referenceType}.flagged`, data);
 
   return !!data;
 };

package/src/report/api/deleteReport.ts

@@ -49,12 +49,8 @@ export const deleteReport = async (
       referenceType === 'message' ? prepareMessagePayload(data as Amity.RawMessagePayload) : data,
     );
 
-  if (referenceType === 'message') {
-    fireEvent('message.unflagged', data as Amity.RawMessagePayload);
-  } else {
-    // @ts-ignore
-    fireEvent(`${referenceType}.unflagged`, data);
-  }
+  // @ts-ignore
+  fireEvent(`${referenceType}.unflagged`, data);
 
   return !!data;
 };

package/src/report/api/tests/createReport.test.ts

@@ -0,0 +1,93 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  flaggedUser,
+  flaggedUserQueryResponse,
+} from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+
+import { onUserFlagged } from '~/user/events';
+
+import { createReport } from '..';
+import REFERENCE_TYPES from '../../constants/referenceTypes';
+
+describe('createReport', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  // integration_test_id: ca4a760f-4342-4a99-9f3c-6c17cd205ca6
+  test('it should flag user with userId', async () => {
+    const expected = true;
+    client.http.post = jest.fn().mockResolvedValue(flaggedUserQueryResponse);
+
+    const received = await createReport('user', flaggedUser.userId);
+
+    expect(received).toBe(expected);
+  });
+
+  // integration_test_id: e8d0f02c-3558-488f-bdae-e70835d8cefb
+  test('it should throw error with 400400 when sending invalid userId', async () => {
+    client.http.post = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('unauthorized', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(createReport('user', flaggedUser.userId)).rejects.toThrow('400400');
+  });
+
+  test('it should fire event for user', async () => {
+    let dispose;
+    const expected = flaggedUser;
+
+    client.http.post = jest.fn().mockResolvedValue(flaggedUserQueryResponse);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onUserFlagged(resolve);
+    }).finally(dispose);
+
+    const recieved = await createReport('user', flaggedUser.userId);
+
+    expect(recieved).toBe(true);
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(expected));
+  });
+
+  test.todo('it should fire event for flagging message');
+  test.todo('it should fire event for flagging post');
+
+  const tests: [keyof typeof REFERENCE_TYPES, string, string][] = [
+    ['user', 'userId', `/api/v4/me/flags/${encodeURIComponent('userId')}`],
+    ['post', 'postId', `/api/v3/posts/${encodeURIComponent('postId')}/flag`],
+    ['message', 'messageId', `/api/v5/messages/${encodeURIComponent('messageId')}/flags`],
+  ];
+
+  test.each(tests)(
+    'it should call the appropriate api for %s',
+    async (referenceType, referenceId, expected) => {
+      const apimock = jest.fn();
+
+      client.http.post = apimock.mockResolvedValue({ data: {} });
+
+      await createReport(referenceType, referenceId);
+
+      const received = apimock.mock.lastCall[0];
+
+      expect(received).toBe(expected);
+    },
+  );
+
+  test('it should add data to cache', async () => {
+    enableCache();
+    const expected = flaggedUser;
+    client.http.post = jest.fn().mockResolvedValue(flaggedUserQueryResponse);
+
+    await createReport('user', flaggedUser.userId);
+    const recieved = pullFromCache(['user', 'get', flaggedUser.userId]);
+
+    expect(recieved?.data).toBe(expected);
+
+    disableCache();
+  });
+});