@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb5cdb1.0

package/src/community/api/queryCommunities.ts

@@ -5,6 +5,11 @@ import { pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 
+import { prepareCommunityPayload } from '../utils';
+
+/* begin_public_function
+  id: community.query
+*/
 /**
  * ```js
  * import { queryCommunities } from '@amityco/ts-sdk'
@@ -20,21 +25,15 @@ import { getResolver } from '~/core/model';
  * @category Community API
  * @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;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Community>>> => {
+export const queryCommunities = async (
+  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, includeDeleted, ...restParams } = params ?? {};
 
   // API-FIX: parameters should be querystring.
   // API-FIX: backend doesnt answer Amity.Response
@@ -43,7 +42,8 @@ export const queryCommunities = async (query?: {
     `/api/v3/communities`,
     {
       params: {
-        ...params,
+        ...restParams,
+        isDeleted: includeDeleted === false ? false : undefined,
         keyword: displayName,
         filter: membership,
         options: {
@@ -54,12 +54,13 @@ export const queryCommunities = async (query?: {
   );
 
   const { paging, ...payload } = data;
-  const { communities } = payload;
+  const unpackedPayload = prepareCommunityPayload(payload);
+  const { communities } = unpackedPayload;
 
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(payload as Amity.CommunityPayload, { cachedAt });
+    ingestInCache(unpackedPayload, { cachedAt });
 
     const cacheKey = [
       'community',
@@ -74,6 +75,7 @@ export const queryCommunities = async (query?: {
 
   return { data: communities, cachedAt, prevPage, nextPage };
 };
+/* end_public_function */
 
 /**
  * ```js

package/src/community/api/queryCommunityMembers.ts

@@ -1,8 +1,14 @@
+import { pullFromCache, pushToCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
+import { getResolver } from '~/core/model';
 
 import { toPage, toToken } from '~/core/query';
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
 
+/* begin_public_function
+  id: community.membership.query
+*/
 /**
  * ```js
  * import { queryCommunityMembers } from '@amityco/ts-sdk'
@@ -17,36 +23,45 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * @category Community API
  * @async
  * */
-export const queryCommunityMembers = async (query: {
-  communityId: string;
-  membership?: ('banned' | 'member')[];
-  roles?: string[];
-  sortBy?: 'firstCreated' | 'lastCreated';
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Membership<'community'>>>> => {
+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, communityId, ...params } = query ?? {};
+  const { page, ...params } = query ?? {};
 
-  const { data } = await client.http.get<Amity.CommunityMembershipPayload & Amity.Pagination>(
-    `/api/v3/communities/${communityId}/users`,
-    {
-      params: {
-        ...params,
-        options: {
-          token: toToken(page, 'skiplimit'),
-        },
+  const { data: queryPayload } = await client.http.get<
+    Amity.CommunityMembershipPayload & Amity.Pagination
+  >(`/api/v3/communities/${params.communityId}/users`, {
+    params: {
+      ...params,
+      options: {
+        token: toToken(page, 'skiplimit'),
       },
     },
-  );
+  });
 
-  const { paging, ...payload } = data;
-  const { communityUsers } = payload;
+  const { paging, ...payload } = queryPayload;
+  const preparedPayload = prepareMembershipPayload(payload, 'communityUsers');
+  const { communityUsers } = preparedPayload;
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) {
-    ingestInCache(payload as Amity.CommunityMembershipPayload, { cachedAt });
+    ingestInCache(preparedPayload, { cachedAt });
+
+    const cacheKey = [
+      'communityUsers',
+      'query',
+      { ...params, options: { ...page } } as Amity.Serializable,
+    ];
+
+    pushToCache(cacheKey, {
+      communityUsers: communityUsers.map(({ communityId, userId }) =>
+        getResolver('communityUsers')({ communityId, userId }),
+      ),
+      paging,
+    });
   }
 
   const nextPage = toPage(paging.next);
@@ -54,6 +69,7 @@ export const queryCommunityMembers = async (query: {
 
   return { data: communityUsers, cachedAt, nextPage, prevPage };
 };
+/* end_public_function */
 
 /**
  * ```js
@@ -72,5 +88,34 @@ queryCommunityMembers.locally = (query: Parameters<typeof queryCommunityMembers>
   const client = getActiveClient();
   client.log('community/queryCommunityMembers', query);
 
-  // TODO
+  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

@@ -2,7 +2,11 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
+import { prepareMembershipPayload } from '~/group/utils';
 
+/* begin_public_function
+  id: community.membership.remove_member
+*/
 /**
  * ```js
  * import { removeCommunityMembers } from '@amityco/ts-sdk'
@@ -25,18 +29,22 @@ export const removeCommunityMembers = async (
   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 } },
   );
 
-  if (client.cache) ingestInCache(data);
+  fireEvent('community.userRemoved', payload);
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
 
-  fireEvent('community.userRemoved', data);
+  if (client.cache) ingestInCache(data);
 
   const { communityUsers } = data;
+
   return !!communityUsers.find(
     communityUser =>
       communityUser.communityId === communityId && communityUser.communityMembership !== 'member',
   );
 };
+/* end_public_function */

package/src/community/api/removeCommunityMembersRoles.ts

@@ -1,7 +1,11 @@
 import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
 
+/* begin_public_function
+  id: community.moderation.remove_roles
+*/
 /**
  * ```js
  * import { removeCommunityMembersRoles } from '@amityco/ts-sdk'
@@ -12,7 +16,7 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  *
  * @param communityId The ID of the {@link Amity.Community} to perform
  * @param roleIds Array of IDs of the {@link Amity.Role} to apply
- * @param userId Array of IDs of the {@link Amity.User} to perform
+ * @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
@@ -26,11 +30,13 @@ export const removeCommunityMembersRoles = async (
   const client = getActiveClient();
   client.log('community/removeCommunityMembersRoles', communityId, roleIds, userIds);
 
-  const { data } = await client.http.delete<Amity.CommunityMembershipPayload>(
+  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;
@@ -40,3 +46,4 @@ export const removeCommunityMembersRoles = async (
       !roleIds.some(role => communityUser.roles.includes(role)),
   );
 };
+/* end_public_function */

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

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

@@ -0,0 +1,61 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+
+import { client, community11, communityUser11 } from '~/utils/tests';
+
+import { onCommunityCreated } from '../../events';
+import { createCommunity } from '../createCommunity';
+
+const communityToCreate = community11;
+const { communityId: createId, ...payload } = communityToCreate;
+
+const resolvedPostValue = {
+  data: {
+    communities: [communityToCreate],
+    communityUsers: [communityUser11],
+    files: [],
+    users: [],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('createCommunity', () => {
+  test('should return created community', async () => {
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    const recieved = createCommunity(payload);
+
+    await expect(recieved).resolves.toEqual(expect.objectContaining({ data: communityToCreate }));
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.post = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(createCommunity(payload)).rejects.toThrow('error');
+  });
+
+  test('should create cache after created community', async () => {
+    enableCache();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    await createCommunity(payload);
+    const recieved = pullFromCache(['community', 'get', createId])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(communityToCreate));
+
+    disableCache();
+  });
+
+  test('should fire event `onCommunityCreated`', async () => {
+    let dispose;
+    client.http.post = jest.fn().mockResolvedValueOnce(resolvedPostValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onCommunityCreated(resolve);
+    }).finally(dispose);
+
+    await createCommunity(payload);
+
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(communityToCreate));
+  });
+});

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

@@ -0,0 +1,74 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, community11, communityUser11, user11 } from '~/utils/tests';
+
+import { deleteCommunity } from '../deleteCommunity';
+import { onCommunityDeleted } from '../../events';
+
+const communityToDelete = community11;
+const { communityId: deleteId } = communityToDelete;
+const deletedCommunity = { ...communityToDelete, isDeleted: true };
+const { updatedAt, ...deletedCommunityWithoutTS } = deletedCommunity;
+
+const resolvedDeleteValue = {
+  data: {
+    success: true,
+  },
+};
+
+const resolvedGetValue = {
+  data: {
+    communities: [deletedCommunity],
+    communityUsers: [communityUser11],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('deleteCommunity', () => {
+  test('should return deleted community', async () => {
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    await expect(deleteCommunity(deleteId)).resolves.toEqual(
+      expect.objectContaining(deletedCommunityWithoutTS),
+    );
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.delete = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(deleteCommunity(deleteId)).rejects.toThrow('error');
+  });
+
+  test('should update cache after deleted community', async () => {
+    enableCache();
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+    pushToCache(['community', 'get', deleteId], communityToDelete);
+
+    await deleteCommunity(deleteId);
+    const recieved = pullFromCache(['community', 'get', deleteId])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(deletedCommunityWithoutTS));
+
+    disableCache();
+  });
+
+  test('should fire event `onCommunityDeleted`', async () => {
+    let dispose;
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onCommunityDeleted(resolve);
+    }).finally(dispose);
+
+    await deleteCommunity(deleteId);
+
+    await expect(callbackPromise).resolves.toEqual(
+      expect.objectContaining(deletedCommunityWithoutTS),
+    );
+  });
+});

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

@@ -0,0 +1,73 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, community11, community21 } from '~/utils/tests';
+
+import { getCommunities } from '../getCommunities';
+
+const communitiesToGet = [community11, community21];
+const getIds = communitiesToGet.map(({ communityId }) => communityId);
+
+const resolvedGetValue = {
+  data: {
+    communities: communitiesToGet,
+    communityUsers: [community11, community21],
+    files: [],
+    users: [],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('getCommunities', () => {
+  test('should return fetched communities', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    await expect(getCommunities(getIds)).resolves.toEqual(
+      expect.objectContaining({ data: communitiesToGet }),
+    );
+  });
+
+  test('should update cache after fetching communities', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    await getCommunities(getIds);
+
+    const recieved = getIds.map(id => pullFromCache(['community', 'get', id])?.data);
+
+    expect(recieved).toEqual(communitiesToGet);
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(getCommunities(getIds)).rejects.toThrow('error');
+  });
+});
+
+describe('getCommunities.locally', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
+
+  test('should return cached communities', () => {
+    communitiesToGet.forEach(community =>
+      pushToCache(['community', 'get', community.communityId], community),
+    );
+
+    expect(getCommunities.locally(getIds)?.data).toEqual(communitiesToGet);
+  });
+
+  test('it should return undefined if communities not in cache', () => {
+    expect(getCommunities.locally(['non-existent-communities'])).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    disableCache();
+    communitiesToGet.forEach(community =>
+      pushToCache(['community', 'get', community.communityId], community),
+    );
+
+    expect(getCommunities.locally(getIds)).toBeUndefined();
+  });
+});