@amityco/ts-sdk 0.0.1-beta.4 → 0.0.1-beta.40

package/src/community/api/index.ts

@@ -1,17 +1,19 @@
-export * from './queryCommunities'
-export * from './getCommunities'
-export * from './getCommunity'
+export * from './queryCommunities';
+export * from './getCommunities';
+export * from './getCommunity';
 
-export * from './createCommunity'
-export * from './updateCommunity'
-export * from './deleteCommunity'
+export * from './createCommunity';
+export * from './updateCommunity';
+export * from './deleteCommunity';
 
-export * from './joinCommunity'
-export * from './leaveCommunity'
+export * from './joinCommunity';
+export * from './leaveCommunity';
 
-export * from './queryCommunityMembers'
-export * from './addCommunityMembers'
-export * from './removeCommunityMembers'
+export * from './queryCommunityMembers';
+export * from './addCommunityMembers';
+export * from './removeCommunityMembers';
+export * from './addCommunityMembersRoles';
+export * from './removeCommunityMembersRoles';
 
-export * from './addCommunityMembersRole'
-export * from './removeCommunityMembersRole'
+export * from './getTopTrendingCommunities';
+export * from './getRecommendedCommunities';

package/src/community/api/joinCommunity.ts

@@ -1,8 +1,8 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-import { fireEvent } from '~/core/events'
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareCommunityPayload } from '~/community/utils';
+import { fireEvent } from '~/core/events';
 
 /**
  * ```js
@@ -18,24 +18,27 @@ import { fireEvent } from '~/core/events'
  * @category Community API
  * @async
  */
-export const joinCommunity = async (communityId: Amity.Community['communityId']) => {
-  const client = getActiveClient()
-  client.log('community/joinCommunity', communityId)
+export const joinCommunity = async (
+  communityId: Amity.Community['communityId'],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('community/joinCommunity', communityId);
 
-  const { data } = await client.http.post<Amity.CommunityMembershipPayload>(
+  const { data: payload } = await client.http.post<Amity.CommunityMembershipPayload>(
     `/api/v3/communities/${communityId}/join`,
-  )
+  );
 
-  decoratePayload(data)
-  ingestInCache(data)
-  fireEvent('v3.community.didJoin', {
-    communities: data.communities!
-  })
+  fireEvent('community.joined', payload);
 
-  const { communityUsers } = data
+  const data = prepareCommunityPayload(payload);
 
-  return !!communityUsers.find(communityUser => (
-    communityUser.communityId === communityId
-    && communityUser.communityMembership === 'member'
-  ))
-}
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { communityUsers } = data;
+
+  return !!communityUsers.find(
+    communityUser =>
+      communityUser.communityId === communityId && communityUser.communityMembership === 'member',
+  );
+};

package/src/community/api/leaveCommunity.ts

@@ -1,8 +1,8 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-import { fireEvent } from '~/core/events'
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareCommunityPayload } from '~/community/utils';
+import { fireEvent } from '~/core/events';
 
 /**
  * ```js
@@ -18,24 +18,27 @@ import { fireEvent } from '~/core/events'
  * @category Community API
  * @async
  */
-export const leaveCommunity = async (communityId: Amity.Community['communityId']) => {
-  const client = getActiveClient()
-  client.log('community/leaveCommunity', communityId)
+export const leaveCommunity = async (
+  communityId: Amity.Community['communityId'],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('community/leaveCommunity', communityId);
 
-  const { data } = await client.http.delete<Amity.CommunityMembershipPayload>(
+  const { data: payload } = await client.http.delete<Amity.CommunityMembershipPayload>(
     `/api/v3/communities/${communityId}/leave`,
-  )
+  );
 
-  decoratePayload(data)
-  ingestInCache(data)
-  fireEvent('v3.community.didJoin', {
-    communities: data.communities!,
-  })
+  fireEvent('community.left', payload);
 
-  const { communityUsers } = data
+  const data = prepareCommunityPayload(payload);
 
-  return !!communityUsers.find(communityUser => (
-    communityUser.communityId === communityId
-    && communityUser.communityMembership !== 'member'
-  ))
-}
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { communityUsers } = data;
+
+  return !!communityUsers.find(
+    communityUser =>
+      communityUser.communityId === communityId && communityUser.communityMembership !== 'member',
+  );
+};

package/src/community/api/queryCommunities.ts

@@ -1,8 +1,11 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload, toPage, toToken } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-import { toRecord } from '~/core/model'
+import { toPage, toToken } from '~/core/query';
+import { pushToCache } from '~/cache/api';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { getResolver } from '~/core/model';
+
+import { prepareCommunityPayload } from '../utils';
 
 /**
  * ```js
@@ -20,54 +23,54 @@ import { toRecord } from '~/core/model'
  * @async
  */
 export const queryCommunities = async (
-  query?: {
-    displayName?: string
-    membership?: 'all' | 'member' | 'notMember'
-    categoryId?: Amity.Category['categoryId'],
-    isDeleted?: Amity.Community['isDeleted'],
-    hasFlag?: boolean,
-    tags?: Amity.Taggable['tags'],
-    sortBy?: ('displayName' | 'firstCreated' | 'lastCreated')
-    page?: Amity.Page
-  }
-) => {
-  const client = getActiveClient()
-  client.log('channel/queryCommunities', query)
+  query?: Amity.QueryCommunities,
+): Promise<Amity.Cached<Amity.Paged<Amity.Community>>> => {
+  const client = getActiveClient();
+  client.log('channel/queryCommunities', query);
 
   // safe decapsulation
-  const {
-    page,
-    displayName,
-    membership,
-    ...params
-  } = query ?? {}
+  const { page, ...params } = query ?? {};
+  const { displayName, membership, ...restParams } = params ?? {};
 
   // API-FIX: parameters should be querystring.
   // API-FIX: backend doesnt answer Amity.Response
   // const { data } = await client.http.get<Amity.Response<Amity.PagedResponse<CommunityPayload>>>(
   const { data } = await client.http.get<Amity.CommunityPayload & Amity.Pagination>(
-    `/api/v3/communities`, { params: {
-      ...params,
-      keyword: displayName,
-      filter: membership,
-      options: {
-        token: toToken(page, 'skiplimit')
-      }
-    } }
-  )
+    `/api/v3/communities`,
+    {
+      params: {
+        ...restParams,
+        keyword: displayName,
+        filter: membership,
+        options: {
+          token: toToken(page, 'skiplimit'),
+        },
+      },
+    },
+  );
+
+  const { paging, ...payload } = data;
+  const unpackedPayload = prepareCommunityPayload(payload);
+  const { communities } = unpackedPayload;
 
-  // API-FIX: backend to response Amity.Response: const { paging, communities } = unwrapPayload(data)
-  const { paging, ...response } = data
+  const cachedAt = client.cache && Date.now();
 
-  decoratePayload(response as unknown as Record<string, object[]>)
-  ingestInCache(response as unknown as Record<string, object[]>)
+  if (client.cache) {
+    ingestInCache(unpackedPayload, { cachedAt });
+
+    const cacheKey = [
+      'community',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
+    pushToCache(cacheKey, { communities: communities.map(getResolver('community')), paging });
+  }
 
-  const prevPage = toPage(paging?.previous)
-  const nextPage = toPage(paging?.next)
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
 
-  const { communities } = response
-  return { data: toRecord(communities), prevPage, nextPage }
-}
+  return { data: communities, cachedAt, prevPage, nextPage };
+};
 
 /**
  * ```js
@@ -82,11 +85,9 @@ export const queryCommunities = async (
  *
  * @category Community API
  */
-queryCommunities.locally = (
-  query: Parameters<typeof queryCommunities>[0],
-) => {
-  const client = getActiveClient()
-  client.log('community/queryCommunities.locally', query)
+queryCommunities.locally = (query: Parameters<typeof queryCommunities>[0]) => {
+  const client = getActiveClient();
+  client.log('community/queryCommunities.locally', query);
 
   // TODO
-}
+};

package/src/community/api/queryCommunityMembers.ts

@@ -1,9 +1,10 @@
-import { getActiveClient } from '~/client/api'
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+import { getResolver } from '~/core/model';
 
-import { decoratePayload, toPage, toToken } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-
-import { toRecord } from '~/core/model'
+import { toPage, toToken } from '~/core/query';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
 
 /**
  * ```js
@@ -18,42 +19,53 @@ import { toRecord } from '~/core/model'
  *
  * @category Community API
  * @async
- **/
-export const queryCommunityMembers = async (query: {
-  communityId: string
-  membership?: ('banned' | 'member')[]
-  roles?: string[]
-  sortBy?: 'firstCreated' | 'lastCreated'
-  page?: Amity.Page
-}) => {
-  const client = getActiveClient()
-  client.log('community/queryCommunityMembers', query)
-
-  const { page, communityId, ...params } = query ?? {}
-
-  const { data } = await client.http.get<
+ * */
+export const queryCommunityMembers = async (
+  query: Amity.QueryCommunityMembers,
+): Promise<Amity.Cached<Amity.Paged<Amity.Membership<'community'>>>> => {
+  const client = getActiveClient();
+  client.log('community/queryCommunityMembers', query);
+
+  const { page, ...params } = query ?? {};
+
+  const { data: queryPayload } = await client.http.get<
     Amity.CommunityMembershipPayload & Amity.Pagination
-  >(`/api/v3/communities/${communityId}/users`, {
+  >(`/api/v3/communities/${params.communityId}/users`, {
     params: {
       ...params,
       options: {
         token: toToken(page, 'skiplimit'),
       },
     },
-  })
+  });
 
-  const { paging, ...response } = data
+  const { paging, ...payload } = queryPayload;
+  const preparedPayload = prepareMembershipPayload(payload, 'communityUsers');
+  const { communityUsers } = preparedPayload;
 
-  decoratePayload(response as unknown as Record<string, Object[]>)
-  ingestInCache(response as unknown as Record<string, Object[]>)
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) {
+    ingestInCache(preparedPayload, { cachedAt });
 
-  const { communityUsers } = response
+    const cacheKey = [
+      'communityUsers',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
 
-  const nextPage = toPage(paging.next)
-  const prevPage = toPage(paging.previous)
+    pushToCache(cacheKey, {
+      communityUsers: communityUsers.map(({ communityId, userId }) =>
+        getResolver('communityUsers')({ communityId, userId }),
+      ),
+      paging,
+    });
+  }
 
-  return { data: toRecord(communityUsers), nextPage, prevPage }
-}
+  const nextPage = toPage(paging.next);
+  const prevPage = toPage(paging.previous);
+
+  return { data: communityUsers, cachedAt, nextPage, prevPage };
+};
 
 /**
  * ```js
@@ -68,11 +80,38 @@ export const queryCommunityMembers = async (query: {
  *
  * @category Post API
  */
-queryCommunityMembers.locally = (
-  query: Parameters<typeof queryCommunityMembers>[0]
-) => {
-  const client = getActiveClient()
-  client.log('community/queryCommunityMembers', query)
-
-  // TODO
-}
+queryCommunityMembers.locally = (query: Parameters<typeof queryCommunityMembers>[0]) => {
+  const client = getActiveClient();
+  client.log('community/queryCommunityMembers', query);
+
+  if (!client.cache) return;
+
+  const { page, ...params } = query ?? {};
+
+  const cacheKey = [
+    'communityUsers',
+    'query',
+    { ...params, options: { ...page } } as Amity.Serializable,
+  ];
+
+  const { data, cachedAt } =
+    pullFromCache<
+      {
+        communityUsers: Pick<Amity.Membership<'community'>, 'communityId' | 'userId'>[];
+      } & Amity.Pagination
+    >(cacheKey) ?? {};
+
+  if (!data?.communityUsers.length) return;
+
+  const communityUsers: Amity.Membership<'community'>[] = data.communityUsers
+    .map(key => pullFromCache<Amity.Membership<'community'>>(['communityUsers', 'get', key])!)
+    .filter(Boolean)
+    .map(({ data }) => data);
+
+  const prevPage = toPage(data?.paging.previous);
+  const nextPage = toPage(data?.paging.next);
+
+  return communityUsers.length === data?.communityUsers?.length
+    ? { data: communityUsers, cachedAt, prevPage, nextPage }
+    : undefined;
+};

package/src/community/api/removeCommunityMembers.ts

@@ -1,8 +1,8 @@
-import { getActiveClient } from '~/client/api'
+import { getActiveClient } from '~/client/api';
 
-import { decoratePayload } from '~/core/query'
-import { ingestInCache } from '~/core/cache'
-import { fireEvent } from '~/core/events'
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
 
 /**
  * ```js
@@ -21,26 +21,26 @@ import { fireEvent } from '~/core/events'
  */
 export const removeCommunityMembers = async (
   communityId: Amity.Community['communityId'],
-  userIds: Amity.User['userId'][]
-) => {
-  const client = getActiveClient()
-  client.log('community/removeCommunityMembers', communityId, userIds)
+  userIds: Amity.User['userId'][],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('community/removeCommunityMembers', communityId, userIds);
 
-  const { data } = await client.http.delete<Amity.CommunityMembershipPayload>(
+  const { data: payload } = await client.http.delete<Amity.CommunityMembershipPayload>(
     `/api/v3/communities/${communityId}/users`,
-    { data: { communityId, userIds } }
-  )
+    { data: { communityId, userIds } },
+  );
 
-  decoratePayload(data)
-  ingestInCache(data)
-  fireEvent('v3.community.didRemoveUsers', {
-    communities: data.communities!,
-  })
+  fireEvent('community.userRemoved', payload);
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
+  if (client.cache) ingestInCache(data);
+
+  const { communityUsers } = data;
 
-  const { communityUsers } = data
   return !!communityUsers.find(
     communityUser =>
-      communityUser.communityId === communityId &&
-      communityUser.communityMembership !== 'member'
-  )
-}
+      communityUser.communityId === communityId && communityUser.communityMembership !== 'member',
+  );
+};

package/src/community/api/removeCommunityMembersRoles.ts

@@ -0,0 +1,45 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
+
+/**
+ * ```js
+ * import { removeCommunityMembersRoles } from '@amityco/ts-sdk'
+ * const updated = await removeCommunityMembersRoles(communityId,  ['foo'], ['bar'])
+ * ```
+ *
+ * Removes a list of {@link Amity.Role} from a list of {@link Amity.User} on a {@link Amity.Community}
+ *
+ * @param communityId The ID of the {@link Amity.Community} to perform
+ * @param roleIds Array of IDs of the {@link Amity.Role} to apply
+ * @param userIds Array of IDs of the {@link Amity.User} to perform
+ * @returns A success boolean if the {@link Amity.Role} were removed from list of {@link Amity.User} in the {@link Amity.Community}
+ *
+ * @category Community API
+ * @async
+ */
+export const removeCommunityMembersRoles = async (
+  communityId: Amity.Community['communityId'],
+  roleIds: Amity.Role['roleId'][],
+  userIds: Amity.User['userId'][],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('community/removeCommunityMembersRoles', communityId, roleIds, userIds);
+
+  const { data: payload } = await client.http.delete<Amity.CommunityMembershipPayload>(
+    `/api/v4/communities/${communityId}/users/roles`,
+    { data: { communityId, roles: roleIds, userIds } },
+  );
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
+  if (client.cache) ingestInCache(data);
+
+  const { communityUsers } = data;
+  return !!communityUsers.find(
+    communityUser =>
+      communityUser.communityId === communityId &&
+      !roleIds.some(role => communityUser.roles.includes(role)),
+  );
+};

package/src/community/api/test/addCommunityMember.test.ts

@@ -0,0 +1,83 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  communityUser11,
+  user11,
+} from '~/utils/tests';
+
+import { onCommunityUserAdded } from '../../events';
+import { addCommunityMembers } from '../addCommunityMembers';
+
+const communityToAddUserTo = community11;
+const userToAdd = communityUser11;
+
+const resolvedPostValue = {
+  data: {
+    communities: [communityToAddUserTo],
+    communityUsers: [userToAdd],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('addCommunityMembers', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('should return true value', async () => {
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    const recieved = addCommunityMembers(communityToAddUserTo.communityId, [userToAdd.userId]);
+
+    await expect(recieved).resolves.toBe(true);
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(
+      addCommunityMembers(communityToAddUserTo.communityId, [userToAdd.userId]),
+    ).rejects.toThrow('error');
+  });
+
+  test('should create cache after added user', async () => {
+    enableCache();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    await addCommunityMembers(communityToAddUserTo.communityId, [userToAdd.userId]);
+    const recieved = pullFromCache([
+      'communityUsers',
+      'get',
+      getResolver('communityUsers')({
+        communityId: communityToAddUserTo.communityId,
+        userId: userToAdd.userId,
+      }),
+    ])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(userToAdd));
+
+    disableCache();
+  });
+
+  test('should fire event `onCommunityUserAdded`', async () => {
+    let dispose;
+    client.http.post = jest.fn().mockResolvedValueOnce(resolvedPostValue);
+
+    const callback = new Promise(resolve => {
+      dispose = onCommunityUserAdded(resolve);
+    }).finally(dispose);
+
+    await addCommunityMembers(communityToAddUserTo.communityId, [userToAdd.userId]);
+
+    await expect(callback).resolves.toEqual(
+      expect.objectContaining({ ...communityToAddUserTo, isJoined: true }),
+    );
+  });
+});

package/src/community/api/test/addCommunityMemberRole.test.ts

@@ -0,0 +1,67 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+
+import { client, community11, communityUser11, user11 } from '~/utils/tests';
+
+import { addCommunityMembersRoles } from '../addCommunityMembersRoles';
+
+const roleToAdd = 'some-new-sole';
+const userCommunity = community11;
+const userToAddRole = communityUser11;
+
+const addedRoleUser = {
+  ...userToAddRole,
+  roles: [...userToAddRole.roles, roleToAdd],
+};
+
+const resolvedPostValue = {
+  data: {
+    communities: [userCommunity],
+    communityUsers: [addedRoleUser],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('addCommunityMembersRoles', () => {
+  test('should return true', async () => {
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    const recieved = addCommunityMembersRoles(
+      userCommunity.communityId,
+      [roleToAdd],
+      [userToAddRole.userId],
+    );
+
+    await expect(recieved).resolves.toBe(true);
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(
+      addCommunityMembersRoles(userCommunity.communityId, [roleToAdd], [userToAddRole.userId]),
+    ).rejects.toThrow('error');
+  });
+
+  test('should create cache after added user', async () => {
+    enableCache();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    await addCommunityMembersRoles(userCommunity.communityId, [roleToAdd], [userToAddRole.userId]);
+    const recieved = pullFromCache([
+      'communityUsers',
+      'get',
+      getResolver('communityUsers')({
+        communityId: userCommunity.communityId,
+        userId: userToAddRole.userId,
+      }),
+    ])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(addedRoleUser));
+
+    disableCache();
+  });
+});