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

package/src/core/query/tests/paging.test.ts

@@ -0,0 +1,66 @@
+import { toPage, isSkip, isAfterBefore } from '../paging';
+
+describe('paging', () => {
+  const skipToken = 'eyJza2lwIjoiMTAiLCJsaW1pdCI6IjEwIn0=';
+  const afterToken = 'eyJhZnRlciI6InRlc3QtdG9rZW4iLCJsaW1pdCI6Mn0=';
+  const beforeToken =
+    'eyJiZWZvcmUiOiI2M2Y0NzFjZmI2MTQzOTExZjFkMWUwNmYiLCJsaW1pdCI6Miwic2VnbWVudCI6Nn0=';
+
+  describe('toPage', () => {
+    test('it should return expected response for skip paging token', () => {
+      const expected = { after: '10', limit: '10' };
+
+      expect(toPage(skipToken)).toStrictEqual(expected);
+    });
+
+    test('it should return appropriate response for "before" paging token', () => {
+      const expected = {
+        before: '63f471cfb6143911f1d1e06f',
+        limit: undefined,
+      };
+
+      expect(toPage(beforeToken)).toStrictEqual(expected);
+    });
+
+    test('it should return appropriate response for "after" paging token', () => {
+      const expected = {
+        after: 'test-token',
+        limit: undefined,
+      };
+
+      expect(toPage(afterToken)).toStrictEqual(expected);
+    });
+  });
+
+  describe('isSkip', () => {
+    test('it should return true if skip prop in object', () => {
+      expect(isSkip({ skip: 10 })).toBe(true);
+    });
+
+    test('it should return true if skip prop not in object', () => {
+      expect(isSkip({ limit: 10 })).toBe(false);
+    });
+  });
+
+  describe('isAfterBefore', () => {
+    test('it should return true if after prop in object', () => {
+      expect(isAfterBefore({ after: '' })).toBe(true);
+    });
+
+    test('it should return true if before prop in object', () => {
+      expect(isAfterBefore({ before: '' })).toBe(true);
+    });
+
+    test('it should return true if first prop in object', () => {
+      expect(isAfterBefore({ first: '' })).toBe(true);
+    });
+
+    test('it should return true if last prop in object', () => {
+      expect(isAfterBefore({ last: '' })).toBe(true);
+    });
+
+    test('it should return false if skip prop in object', () => {
+      expect(isAfterBefore({ skip: '' })).toBe(false);
+    });
+  });
+});

package/src/message/api/queryMessages.ts

@@ -1,7 +1,7 @@
 import { getActiveClient } from '~/client/api';
 
 import { fireEvent } from '~/core/events';
-import { toPage } from '~/core/query';
+import { toPageRaw } from '~/core/query';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
@@ -23,7 +23,7 @@ import { convertQueryParams, convertResponseFromRaw } from '../utils';
  */
 export const queryMessages = async (
   query: Amity.QueryMessages,
-): Promise<Amity.Cached<Amity.Paged<Amity.Message>>> => {
+): Promise<Amity.Cached<Amity.Paged<Amity.Message, Amity.Page<string>>>> => {
   const client = getActiveClient();
   client.log('message/queryMessages', query);
 
@@ -53,8 +53,8 @@ export const queryMessages = async (
 
   fireEvent('local.message.fetched', { messages });
 
-  const nextPage = toPage(paging.next);
-  const prevPage = toPage(paging.previous);
+  const nextPage = toPageRaw(paging.next);
+  const prevPage = toPageRaw(paging.previous);
 
   return { data: messages, cachedAt, prevPage, nextPage };
 };
@@ -74,7 +74,7 @@ export const queryMessages = async (
  */
 queryMessages.locally = (
   query: Parameters<typeof queryMessages>[0],
-): Amity.Cached<Amity.Paged<Amity.Message>> | undefined => {
+): Amity.Cached<Amity.Paged<Amity.Message, Amity.Page<string>>> | undefined => {
   const client = getActiveClient();
   client.log('message/queryMessages.locally', query);
 
@@ -94,8 +94,8 @@ queryMessages.locally = (
     .filter(Boolean)
     .map(({ data }) => data);
 
-  const prevPage = toPage(data?.paging.previous);
-  const nextPage = toPage(data?.paging.next);
+  const prevPage = toPageRaw(data?.paging.previous);
+  const nextPage = toPageRaw(data?.paging.next);
 
   return messages.length === data?.messages?.length
     ? { data: messages, cachedAt, prevPage, nextPage }

package/src/message/api/tests/queryMessages.test.ts

@@ -14,9 +14,9 @@ const messageIds = messagesToQuery.map(x => x.messageId);
 const queryCriteriaWithoutPage = { subChannelId: messagesToQuery[0].subChannelId };
 const queryCriteria = { ...queryCriteriaWithoutPage, page: { limit: 10 } };
 const paging = {
-  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
-  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJsaW1pdCI6MiwiYmVmb3JlIjo2MzQ3MTYxNDM5MTExMTAwMDAwMH0',
 };
+const nextPage = { before: 63471614391111000000, limit: 2 };
 
 const getResolvedMessageValue = () => ({
   data: {
@@ -34,8 +34,8 @@ describe('queryMessages', () => {
     await expect(queryMessages(queryCriteria)).resolves.toEqual(
       expect.objectContaining({
         data: messagesToQuery,
-        prevPage: { before: 55, limit: 10 },
-        nextPage: { before: 55, limit: 10 },
+        nextPage,
+        prevPage: undefined,
       }),
     );
   });
@@ -91,8 +91,8 @@ describe('queryMessages.locally', () => {
     expect(queryMessages.locally(queryCriteria)).toEqual(
       expect.objectContaining({
         data: messagesToQuery,
-        prevPage: { before: 55, limit: 10 },
-        nextPage: { before: 55, limit: 10 },
+        prevPage: undefined,
+        nextPage,
       }),
     );
   });

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/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/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();
+  });
+});

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

@@ -0,0 +1,93 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  flaggedUser as unflaggedUser,
+  flaggedUserQueryResponse as unflaggedUserQueryResponse,
+} from '~/utils/tests';
+import { ASCApiError } from '~/core/errors';
+
+import { onUserUnflagged } from '~/user/events';
+
+import { deleteReport } from '..';
+import REFERENCE_TYPES from '../../constants/referenceTypes';
+
+describe('deleteReport', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  // integration_test_id: fddf1d63-98e2-4296-ab3a-4e2b55044f89
+  test('it should unflag user with userId', async () => {
+    const expected = true;
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedUserQueryResponse);
+
+    const received = await deleteReport('user', unflaggedUser.userId);
+
+    expect(received).toBe(expected);
+  });
+
+  // integration_test_id: a95a0784-56ce-4b17-ac1b-0f1c50a361ef
+  test('it should throw error with 400400 when sending invalid userId', async () => {
+    client.http.delete = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('unauthorized', Amity.ServerError.ITEM_NOT_FOUND, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(deleteReport('user', unflaggedUser.userId)).rejects.toThrow('400400');
+  });
+
+  test('it should fire event for user', async () => {
+    let dispose;
+    const expected = unflaggedUser;
+
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedUserQueryResponse);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onUserUnflagged(resolve);
+    }).finally(dispose);
+
+    const recieved = await deleteReport('user', unflaggedUser.userId);
+
+    expect(recieved).toBe(true);
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(expected));
+  });
+
+  test.todo('it should fire event for unflagging message');
+  test.todo('it should fire event for unflagging delete');
+
+  const tests: [keyof typeof REFERENCE_TYPES, string, string][] = [
+    ['user', 'userId', `/api/v4/me/flags/${encodeURIComponent('userId')}`],
+    ['post', 'postId', `/api/v3/posts/${encodeURIComponent('postId')}/unflag`],
+    ['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.delete = apimock.mockResolvedValue({ data: {} });
+
+      await deleteReport(referenceType, referenceId);
+
+      const received = apimock.mock.lastCall[0];
+
+      expect(received).toBe(expected);
+    },
+  );
+
+  test('it should add data to cache', async () => {
+    enableCache();
+    const expected = unflaggedUser;
+    client.http.delete = jest.fn().mockResolvedValue(unflaggedUserQueryResponse);
+
+    await deleteReport('user', unflaggedUser.userId);
+    const recieved = pullFromCache(['user', 'get', unflaggedUser.userId]);
+
+    expect(recieved?.data).toBe(expected);
+
+    disableCache();
+  });
+});

package/src/user/api/queryUsers.ts

@@ -23,12 +23,7 @@ import { fireEvent } from '~/core/events';
  * @async
  */
 export const queryUsers = async (
-  query: {
-    displayName?: Amity.User['displayName'];
-    filter?: 'all' | 'flagged';
-    sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
-    page?: Amity.Page;
-  } = {},
+  query: Amity.QueryUsers = {},
 ): Promise<Amity.Cached<Amity.Paged<Amity.User>>> => {
   const client = getActiveClient();
   client.log('user/queryUsers', query);

package/src/user/observers/index.ts

@@ -1,2 +1,3 @@
 export { liveUser } from './liveUser';
+export { liveUsers } from './liveUsers';
 export { observeUser } from './observeUser';