@amityco/ts-sdk 0.0.1-beta.28 → 0.0.1-beta.29

package/src/community/api/getCommunity.ts

@@ -3,6 +3,8 @@ import { getActiveClient } from '~/client/api';
 import { pullFromCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { unpackCommunityPayload } from '../utils';
+
 /**
  * ```js
  * import { getCommunity } from '@amityco/ts-sdk'
@@ -24,10 +26,12 @@ export const getCommunity = async (
   client.log('community/getCommunity', communityId);
 
   // API-FIX: endpoint should not be /list, parameters should be querystring.
-  const { data } = await client.http.get<Amity.CommunityPayload>(
+  const { data: payload } = await client.http.get<Amity.CommunityPayload>(
     `/api/v3/communities/${communityId}`,
   );
 
+  const data = unpackCommunityPayload(payload);
+
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 

package/src/community/api/getRecommendedCommunities.ts

@@ -4,6 +4,8 @@ import { getResolver } from '~/core/model';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { unpackCommunityPayload } from '../utils';
+
 /**
  * ```js
  * import { getRecommendedCommunities } from '@amityco/ts-sdk'
@@ -27,12 +29,13 @@ export const getRecommendedCommunities = async (
   const { limit = 5 } = query ?? {};
 
   // API-FIX: backend doesnt answer Amity.Response
-  // const { data } = await client.http.get<Amity.Response<CommunityPayload>>(
-  const { data } = await client.http.get<Amity.CommunityPayload>(
+  // const { data: payload } = await client.http.get<Amity.Response<CommunityPayload>>(
+  const { data: payload } = await client.http.get<Amity.CommunityPayload>(
     `/api/v3/communities/recommended`,
     { params: { options: { limit } } },
   );
 
+  const data = unpackCommunityPayload(payload);
   const { communities } = data;
 
   const cachedAt = client.cache && Date.now();

package/src/community/api/getTopTrendingCommunities.ts

@@ -4,6 +4,8 @@ import { getResolver } from '~/core/model';
 import { pullFromCache, pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { unpackCommunityPayload } from '../utils';
+
 /**
  * ```js
  * import { getTopTrendingCommunities } from '@amityco/ts-sdk'
@@ -28,11 +30,12 @@ export const getTopTrendingCommunities = async (
 
   // API-FIX: backend doesnt answer Amity.Response
   // const { data } = await client.http.get<Amity.Response<CommunityPayload>>(
-  const { data } = await client.http.get<Amity.CommunityPayload>(
+  const { data: payload } = await client.http.get<Amity.CommunityPayload>(
     `/api/v3/communities/top-trending`,
     { params: { options: { limit } } },
   );
 
+  const data = unpackCommunityPayload(payload);
   const { communities } = data;
 
   const cachedAt = client.cache && Date.now();

package/src/community/api/queryCommunities.ts

@@ -5,6 +5,8 @@ import { pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 
+import { unpackCommunityPayload } from '../utils';
+
 /**
  * ```js
  * import { queryCommunities } from '@amityco/ts-sdk'
@@ -54,12 +56,13 @@ export const queryCommunities = async (query?: {
   );
 
   const { paging, ...payload } = data;
-  const { communities } = payload;
+  const unpackedPayload = unpackCommunityPayload(payload);
+  const { communities } = unpackedPayload;
 
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(payload as Amity.CommunityPayload, { cachedAt });
+    ingestInCache(unpackedPayload as Amity.CommunityPayload, { cachedAt });
 
     const cacheKey = [
       'community',

package/src/community/api/updateCommunity.ts

@@ -3,6 +3,8 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 
+import { packCommunityPayload, unpackCommunityPayload } from '../utils';
+
 /**
  * ```js
  * import { updateCommunity } from '@amityco/ts-sdk'
@@ -22,17 +24,19 @@ export const updateCommunity = async (
   communityId: Amity.Community['communityId'],
   patch: Patch<
     Amity.Community,
-    'displayName' | 'description' | 'avatarFileId' | 'tags' | 'metadata'
+    'displayName' | 'description' | 'avatarFileId' | 'postSetting' | 'tags' | 'metadata'
   >,
 ): Promise<Amity.Cached<Amity.Community>> => {
   const client = getActiveClient();
   client.log('community/updateCommunity', communityId, patch);
 
-  const { data } = await client.http.put<Amity.CommunityPayload>(
+  const { data: payload } = await client.http.put<Amity.CommunityPayload>(
     `/api/v3/communities/${communityId}`,
-    patch,
+    packCommunityPayload(patch),
   );
 
+  const data = unpackCommunityPayload(payload);
+
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 

package/src/community/events/utils.ts

@@ -4,6 +4,8 @@ import { createEventSubscriber } from '~/core/events';
 import { pullFromCache } from '~/cache/api';
 import { getResolver } from '~/core/model';
 
+import { unpackCommunityPayload } from '../utils';
+
 export const createCommunityEventSubscriber = (
   event: keyof Amity.MqttCommunityMessageEvents,
   callback: Amity.Listener<Amity.Community>,
@@ -11,16 +13,18 @@ export const createCommunityEventSubscriber = (
   const client = getActiveClient();
 
   const filter = (payload: Amity.CommunityPayload) => {
+    const unpackedPayload = unpackCommunityPayload(payload);
+
     if (!client.cache) {
       // TODO: here we are missing specific properties here!
-      callback(payload.communities[0]);
+      callback(unpackedPayload.communities[0]);
     } else {
-      ingestInCache(payload);
+      ingestInCache(unpackedPayload);
 
       const community = pullFromCache<Amity.Community>([
         'community',
         'get',
-        payload.communities[0].communityId,
+        unpackedPayload.communities[0].communityId,
       ])!;
 
       callback(community.data);
@@ -77,21 +81,23 @@ export const createCommunityMemberEventSubscriber = (
   const client = getActiveClient();
 
   const filter = (payload: Amity.CommunityMembershipPayload) => {
+    const unpackedPayload = unpackCommunityPayload(payload);
+
     if (!client.cache) {
       // TODO: here we are missing specific properties here!
-      callback(payload.communities[0], getEventRelatedMember(event, payload));
+      callback(unpackedPayload.communities[0], getEventRelatedMember(event, unpackedPayload));
     } else {
-      ingestInCache(payload);
+      ingestInCache(unpackedPayload);
 
       const community = pullFromCache<Amity.Community>([
         'community',
         'get',
-        payload.communities[0].communityId,
+        unpackedPayload.communities[0].communityId,
       ])!;
       const member = pullFromCache<Amity.Membership<'community'>>([
         'communityUsers',
         'get',
-        getResolver('communityUsers')(getEventRelatedMember(event, payload)),
+        getResolver('communityUsers')(getEventRelatedMember(event, unpackedPayload)),
       ])!;
 
       callback(community.data, member.data);

package/src/community/utils/index.ts

@@ -0,0 +1 @@
+export * from './payload';

package/src/community/utils/payload.ts

@@ -0,0 +1,44 @@
+import { CommunityPostSettingMaps, DefaultCommunityPostSetting } from '~/@types';
+
+const getMatchPostSetting = (value: {
+  needApprovalOnPostCreation: Amity.RawCommunity['needApprovalOnPostCreation'];
+  onlyAdminCanPost: Amity.RawCommunity['onlyAdminCanPost'];
+}): Amity.Community['postSetting'] =>
+  Object.keys(CommunityPostSettingMaps).find(
+    key =>
+      value.needApprovalOnPostCreation ===
+        CommunityPostSettingMaps[key].needApprovalOnPostCreation &&
+      value.onlyAdminCanPost === CommunityPostSettingMaps[key].onlyAdminCanPost,
+  ) ?? DefaultCommunityPostSetting;
+
+/*
+ * Unpack community payload by mapping payload field to postSetting value.
+ */
+export const unpackCommunityPayload = <T extends Amity.CommunityPayload>({
+  communities,
+  ...restPayload
+}: T) => ({
+  communities: communities.map<Amity.Community>(
+    ({ needApprovalOnPostCreation, onlyAdminCanPost, ...restCommunityPayload }) => ({
+      postSetting: getMatchPostSetting({
+        needApprovalOnPostCreation,
+        onlyAdminCanPost,
+      }),
+      ...restCommunityPayload,
+    }),
+  ),
+  ...restPayload,
+});
+
+/*
+ * Repack community payload by mapping postSetting to the actual value.
+ */
+export const packCommunityPayload = <
+  T extends { postSetting?: Amity.Community['postSetting']; [k: string]: any },
+>({
+  postSetting = undefined,
+  ...restParam
+}: T) => ({
+  ...restParam,
+  ...(postSetting ? CommunityPostSettingMaps[postSetting] : undefined),
+});

package/src/core/model/identifyModel.ts

@@ -26,7 +26,7 @@ const CRITERIAS: Criterias = {
   channel: ['channelId', 'rateLimit'],
   channelUsers: ['channelId', 'userId', 'membership'],
   message: ['messageId'],
-  community: ['communityId', 'onlyAdminCanPost'],
+  community: ['communityId', 'postSetting'],
   category: ['categoryId'],
   communityUsers: ['userId', 'communityId', 'communityMembership'],
   post: ['postId', 'feedId'],

package/src/follow/observers/liveFollowers.ts

@@ -67,7 +67,7 @@ export const liveFollowers = (
         .filter(Boolean)
         .map(({ data }) => data) ?? [];
 
-    if (params.status) {
+    if (params.status && params.status !== 'all') {
       followers = filterByPropEquality(followers, 'status', params.status);
     }
 

package/src/follow/observers/liveFollowings.ts

@@ -67,7 +67,7 @@ export const liveFollowings = (
         .filter(Boolean)
         .map(({ data }) => data) ?? [];
 
-    if (params.status) {
+    if (params.status && params.status !== 'all') {
       followings = filterByPropEquality(followings, 'status', params.status);
     }
 

package/src/follow/tests/observers/liveFollowers.test.ts

@@ -0,0 +1,240 @@
+import { ASCApiError } from '~/core/errors';
+import { disableCache, enableCache } from '~/cache/api';
+import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
+
+import { queryFollowers } from '../../api/queryFollowers';
+import { liveFollowers } from '../../observers/liveFollowers';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  follows,
+  encodeJson,
+  follow21,
+} from '~/utils/tests';
+
+const getSnapshot = () => {
+  return {
+    loading: true,
+    error: undefined as any,
+    data: [] as Amity.FollowStatus[],
+  };
+};
+
+describe('liveFollowers', () => {
+  beforeAll(async () => {
+    await connectClient();
+  });
+
+  afterAll(async () => {
+    await disconnectClient();
+  });
+
+  beforeEach(enableCache);
+
+  afterEach(disableCache);
+
+  const { userId } = follows;
+  const args: Amity.FollowerLiveCollection = { userId };
+
+  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 liveFollowers check if mocked console get's called with the correct
+    // message
+    client.use();
+    liveFollowers(args, callback);
+
+    expect(console.log).toBeCalledWith(ENABLE_CACHE_MESSAGE);
+  });
+
+  test('it should return following collection', async () => {
+    const snapshot = getSnapshot();
+    const response = { data: { paging: {}, follows: follows.page2 } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveFollowers(args, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await expect(queryFollowers(args)).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.loading = false;
+    snapshot.data = response.data.follows;
+    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,
+    );
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockRejectedValue(error);
+
+    liveFollowers(args, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    await expect(queryFollowers(args)).rejects.toThrow();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.error = error;
+    snapshot.loading = false;
+    expect(callback).toHaveBeenLastCalledWith(expect.objectContaining(snapshot));
+  });
+
+  const statusFilters: [string, Amity.FollowerLiveCollection][] = [
+    ['all', { ...args, status: 'all', limit: 10 }],
+    ['accepted', { ...args, status: 'accepted', limit: 10 }],
+    ['pending', { ...args, status: 'pending', limit: 10 }],
+  ];
+
+  test.each(statusFilters)('it should filter %s follows based on param', async (filter, params) => {
+    const snapshot = getSnapshot();
+    const response = { data: { paging: {}, follows: follows.page2 } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveFollowers(params, callback);
+
+    expect(callback).toHaveBeenCalledTimes(1);
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+
+    // TODO : why ts gives no shit about args here ? wrong type :D
+    const query = queryFollowers(params);
+
+    await expect(query).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    snapshot.loading = false;
+    snapshot.data =
+      filter === 'all'
+        ? response.data.follows
+        : response.data.follows.filter(fl => fl.status === filter);
+
+    expect(callback).toHaveBeenCalledWith(expect.objectContaining(snapshot));
+  });
+
+  test('it should return method to fetch next page', async () => {
+    const snapshot = getSnapshot();
+    const args: Amity.FollowerLiveCollection = { userId, limit: 3 };
+    const next = encodeJson({
+      limit: 3,
+      before: follows.page2[2].from,
+      updatedAt: follows.page2[2].updatedAt,
+    });
+
+    const response = { data: { follows: follows.page1, paging: {} } };
+    const responseWithNextPage = { data: { follows: follows.page2, paging: { next } } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(responseWithNextPage);
+
+    liveFollowers(args, callback);
+
+    expect(callback).toHaveBeenCalled();
+
+    await expect(queryFollowers(args)).resolves.toBeTruthy();
+
+    expect(callback.mock.lastCall).toHaveLength(1);
+
+    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
+
+    expect(hasNextPage).toBe(true);
+    expect(onNextPage).toBeTruthy();
+
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    onNextPage();
+
+    await expect(queryFollowers(args)).resolves.toBeTruthy();
+
+    expect(callback).toHaveBeenCalledTimes(4);
+
+    snapshot.loading = false;
+    snapshot.data = [...responseWithNextPage.data.follows, ...response.data.follows];
+    expect(callback).toHaveBeenNthCalledWith(4, expect.objectContaining(snapshot));
+  });
+
+  const createEvents: [keyof Amity.Events][] = [
+    ['follow.created'],
+    ['follow.requested'],
+    ['follow.accepted'],
+  ];
+
+  test.each(createEvents)('it should add new follow to collection on %s', async event => {
+    const snapshot = getSnapshot();
+    const newFollower: Amity.FollowStatus = {
+      ...follow21,
+      from: 'some-user',
+    };
+    const response = { data: { follows: follows.page2, paging: {} } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveFollowers(args, callback);
+
+    await expect(queryFollowers(args)).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit(event, { follows: [newFollower] });
+
+    snapshot.loading = false;
+    snapshot.data = [newFollower, ...response.data.follows];
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+
+  const removeEvents: [keyof Amity.Events][] = [
+    ['follow.requestDeclined'],
+    ['follow.requestCanceled'],
+    ['follow.unfollowed'],
+    ['follow.followerDeleted'],
+  ];
+
+  test.each(removeEvents)('it should remove a follow to collection on %s', async event => {
+    const snapshot = getSnapshot();
+    const response = { data: { follows: follows.page2, paging: {} } };
+
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(response);
+
+    liveFollowers(args, callback);
+
+    await expect(queryFollowers(args)).resolves.toBeTruthy();
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    client.emitter.emit(event, { follows: [response.data.follows[0]] });
+
+    const [first, ...data] = response.data.follows;
+
+    snapshot.data = data;
+    snapshot.loading = false;
+    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  });
+});