@amityco/ts-sdk 6.35.3-f8f74ab5.0 → 6.35.3

package/src/communityRepository/api/test/getTopTrendingCommunities.test.ts

@@ -0,0 +1,102 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { client, community11, community21 } from '~/utils/tests';
+
+import { getTopTrendingCommunities } from '../getTopTrendingCommunities';
+
+const topTrendCommunities = [community11, community21];
+const topTrendIds = topTrendCommunities.map(({ communityId }) => communityId);
+
+const pagingToken = {
+  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+};
+
+const pagingCriteria = { limit: 10 };
+
+const resolvedGetValue = {
+  data: {
+    communities: topTrendCommunities,
+    communityUsers: [community11, community21],
+    files: [],
+    users: [],
+    categories: [],
+    feeds: [],
+    paging: pagingToken,
+  },
+};
+
+describe('getTopTrendingCommunities', () => {
+  test('should return fetched top trend communities with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    await expect(getTopTrendingCommunities(pagingCriteria)).resolves.toEqual(
+      expect.objectContaining({ data: topTrendCommunities }),
+    );
+  });
+
+  test('should update cache after fetching top trend communities', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    await getTopTrendingCommunities(pagingCriteria);
+
+    const recieved = pullFromCache([
+      'community',
+      'top-trending',
+      { params: { options: pagingCriteria } },
+    ])?.data;
+
+    expect(recieved).toEqual({ communities: topTrendIds });
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(getTopTrendingCommunities(pagingCriteria)).rejects.toThrow('error');
+  });
+});
+
+describe('getTopTrendingCommunities.locally', () => {
+  beforeEach(() => enableCache());
+  afterEach(() => disableCache());
+
+  test('should return cached top trend communities', () => {
+    topTrendCommunities.forEach(community =>
+      pushToCache(['community', 'get', community.communityId], community),
+    );
+
+    pushToCache(['community', 'top-trending', { params: { options: pagingCriteria } }], {
+      communities: topTrendIds,
+    });
+
+    expect(getTopTrendingCommunities.locally(pagingCriteria)?.data).toEqual(topTrendCommunities);
+  });
+
+  test('it should return undefined if top trend communities not in cache', () => {
+    topTrendCommunities.forEach(community =>
+      pushToCache(['community', 'get', community.communityId], community),
+    );
+
+    pushToCache(['community', 'top-trending', { params: { options: pagingCriteria } }], {
+      communities: topTrendIds,
+    });
+
+    expect(getTopTrendingCommunities.locally({ limit: -1 })).toBeUndefined();
+  });
+
+  test('should return undefined if cache not enabled', () => {
+    disableCache();
+
+    topTrendCommunities.forEach(community =>
+      pushToCache(['community', 'get', community.communityId], community),
+    );
+
+    pushToCache(['community', 'top-trending', { params: { options: pagingCriteria } }], {
+      communities: topTrendIds,
+    });
+
+    expect(getTopTrendingCommunities.locally(pagingCriteria)).toBeUndefined();
+  });
+});

package/src/communityRepository/api/test/getTrendingCommunities.test.ts

@@ -0,0 +1,56 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { client, community11, community21 } from '~/utils/tests';
+
+import { getTrendingCommunities } from '../getTrendingCommunities';
+
+const topTrendCommunities = [community11, community21];
+
+const pagingToken = {
+  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+};
+
+const pagingCriteria = { limit: 10 };
+
+const resolvedGetValue = {
+  data: {
+    communities: topTrendCommunities,
+    communityUsers: [],
+    files: [],
+    users: [],
+    categories: [],
+    feeds: [],
+    paging: pagingToken,
+  },
+};
+
+describe('getTrendingCommunities', () => {
+  test('should return fetched top trend communities with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    await expect(getTrendingCommunities(pagingCriteria)).resolves.toEqual(
+      expect.objectContaining({ data: topTrendCommunities }),
+    );
+  });
+
+  test('should update cache after fetching top trend communities', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    await getTrendingCommunities(pagingCriteria);
+
+    const community1 = pullFromCache(['community', 'get', community11.communityId])?.data;
+    const community2 = pullFromCache(['community', 'get', community21.communityId])?.data;
+
+    expect(community1).toStrictEqual(community11);
+    expect(community2).toStrictEqual(community21);
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(getTrendingCommunities(pagingCriteria)).rejects.toThrow('error');
+  });
+});

package/src/communityRepository/api/test/joinCommunity.test.ts

@@ -0,0 +1,82 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  communityUser11,
+  user11,
+} from '~/utils/tests';
+
+import { onCommunityJoined } from '../../communityMembership/events';
+import { joinCommunity } from '../joinCommunity';
+
+const communityToJoin = community11;
+const joinedUser = communityUser11;
+
+const resolvedPostValue = {
+  data: {
+    communities: [communityToJoin],
+    communityUsers: [joinedUser],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('joinCommunity', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('should return true value', async () => {
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    const recieved = joinCommunity(communityToJoin.communityId);
+
+    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(joinCommunity(communityToJoin.communityId)).rejects.toThrow('error');
+  });
+
+  test('should create cache after join community', async () => {
+    enableCache();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    await joinCommunity(communityToJoin.communityId);
+
+    const recieved = pullFromCache([
+      'communityUsers',
+      'get',
+      getResolver('communityUsers')({
+        communityId: communityToJoin.communityId,
+        userId: joinedUser.userId,
+      }),
+    ])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(joinedUser));
+
+    disableCache();
+  });
+
+  test('should fire event `onCommunityJoined`', async () => {
+    let dispose;
+    client.http.post = jest.fn().mockResolvedValueOnce(resolvedPostValue);
+
+    const callback = new Promise(resolve => {
+      dispose = onCommunityJoined(resolve);
+    }).finally(dispose);
+
+    await joinCommunity(communityToJoin.communityId);
+
+    await expect(callback).resolves.toEqual(
+      expect.objectContaining({ ...communityToJoin, isJoined: true }),
+    );
+  });
+});

package/src/communityRepository/api/test/leaveCommunity.test.ts

@@ -0,0 +1,88 @@
+import { disableCache, enableCache, pullFromCache, pushToCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  communityUser11,
+  user11,
+} from '~/utils/tests';
+
+import { leaveCommunity } from '../leaveCommunity';
+import { onCommunityLeft } from '../../communityMembership/events';
+
+const communityToLeave = community11;
+const toLeaveUser = { ...communityUser11, communityMembership: 'member' };
+const leavedUser = { ...communityUser11, communityMembership: 'none' };
+
+const resolvedDeleteValue = {
+  data: {
+    communities: [communityToLeave],
+    communityUsers: [leavedUser],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('leaveCommunity', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('should return true value', async () => {
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+
+    await expect(leaveCommunity(communityToLeave.communityId)).resolves.toBe(true);
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.delete = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(leaveCommunity(communityToLeave.communityId)).rejects.toThrow('error');
+  });
+
+  test('should update cache after leaved community', async () => {
+    enableCache();
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+    pushToCache(
+      [
+        'communityUsers',
+        'get',
+        getResolver('communityUsers')({
+          communityId: communityToLeave.communityId,
+          userId: toLeaveUser.userId,
+        }),
+      ],
+      toLeaveUser,
+    );
+
+    await leaveCommunity(communityToLeave.communityId);
+    const recieved = pullFromCache([
+      'communityUsers',
+      'get',
+      getResolver('communityUsers')({
+        communityId: communityToLeave.communityId,
+        userId: toLeaveUser.userId,
+      }),
+    ])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(leavedUser));
+
+    disableCache();
+  });
+
+  test('should fire event `onCommunityLeft`', async () => {
+    let dispose;
+    client.http.delete = jest.fn().mockResolvedValueOnce(resolvedDeleteValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onCommunityLeft(resolve);
+    }).finally(dispose);
+
+    await leaveCommunity(toLeaveUser.userId);
+
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(communityToLeave));
+  });
+});

package/src/communityRepository/api/test/queryCommunity.test.ts

@@ -0,0 +1,107 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+
+import { client, community11, community21, communityUser11 } from '~/utils/tests';
+
+import { queryCommunities } from '../queryCommunities';
+
+const communities = [community11, community21];
+
+const pagingToken = {
+  previous: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+  next: 'eyJiZWZvcmUiOjU1LCJsYXN0IjoxMH0=',
+};
+
+const communitiesToQuery = [community11];
+const communityIdsToQuery = communitiesToQuery.map(community => community.communityId);
+const communityUsersToQuery = [communityUser11];
+const queryCriteriaWithoutQueryToken = { displayName: communities[0].displayName, limit: 10 };
+const queryCriteriaWithQueryToken = {
+  ...queryCriteriaWithoutQueryToken,
+  page: pagingToken.next,
+};
+
+const resolvedGetValue = {
+  data: {
+    communities: communitiesToQuery,
+    communityUsers: communityUsersToQuery,
+    files: [],
+    users: [],
+    categories: [],
+    feeds: [],
+    paging: pagingToken,
+  },
+};
+
+describe('queryCommunities', () => {
+  test('should return fetched communities with correct paging', async () => {
+    client.http.get = jest.fn().mockResolvedValueOnce(resolvedGetValue);
+
+    await expect(queryCommunities(queryCriteriaWithoutQueryToken)).resolves.toEqual(
+      expect.objectContaining({
+        data: communitiesToQuery,
+        paging: pagingToken,
+      }),
+    );
+  });
+
+  test('should update cache after fetching communities', async () => {
+    enableCache();
+    client.http.get = jest.fn().mockResolvedValue(resolvedGetValue);
+
+    await queryCommunities(queryCriteriaWithQueryToken);
+
+    const { page, limit, ...params } = queryCriteriaWithQueryToken;
+
+    const recieved = pullFromCache([
+      'community',
+      'query',
+      {
+        ...params,
+        options: { token: queryCriteriaWithQueryToken.page },
+      },
+    ])?.data;
+
+    expect(recieved).toEqual({
+      communities: communityIdsToQuery,
+      paging: pagingToken,
+    });
+
+    disableCache();
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.get = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(queryCommunities(queryCriteriaWithQueryToken)).rejects.toThrow('error');
+  });
+
+  test('it should set isDeleted to undefined if includeDeleted is true', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(resolvedGetValue);
+
+    await queryCommunities({ ...queryCriteriaWithoutQueryToken, includeDeleted: true });
+
+    expect(mockFn.mock.lastCall).toHaveLength(2);
+    expect(mockFn.mock.lastCall[1].params.isDeleted).toBeUndefined();
+  });
+
+  test('it should set isDeleted to false if includeDeleted is false', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(resolvedGetValue);
+
+    await queryCommunities({ ...queryCriteriaWithoutQueryToken, includeDeleted: false });
+
+    expect(mockFn.mock.lastCall).toHaveLength(2);
+    expect(mockFn.mock.lastCall[1].params.isDeleted).toBe(false);
+  });
+
+  test('it should set isDeleted to false if includeDeleted is undefined', async () => {
+    const mockFn = jest.fn();
+    client.http.get = mockFn.mockResolvedValue(resolvedGetValue);
+
+    await queryCommunities(queryCriteriaWithoutQueryToken);
+
+    expect(mockFn.mock.lastCall).toHaveLength(2);
+    expect(mockFn.mock.lastCall[1].params.isDeleted).toBe(false);
+  });
+});

package/src/communityRepository/api/test/updateCommunity.test.ts

@@ -0,0 +1,65 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { client, community11, communityUser11, user11 } from '~/utils/tests';
+
+import { updateCommunity } from '../updateCommunity';
+import { onCommunityUpdated } from '../../events';
+
+const communityToUpdate = community11;
+const patch = { displayName: 'new-display-name' };
+const updatedCommunity = { ...communityToUpdate, ...patch };
+
+const resolvedPutValue = {
+  data: {
+    communities: [updatedCommunity],
+    communityUsers: [communityUser11],
+    files: [],
+    users: [user11],
+    categories: [],
+    feeds: [],
+  },
+};
+
+describe('updateCommunity', () => {
+  test('should return updated community', async () => {
+    client.http.put = jest.fn().mockResolvedValueOnce(resolvedPutValue);
+
+    const recieved = updateCommunity(communityToUpdate.communityId, patch);
+
+    await expect(recieved).resolves.toEqual(expect.objectContaining({ data: updatedCommunity }));
+  });
+
+  test('should throw an error if request fails', async () => {
+    client.http.put = jest.fn().mockRejectedValueOnce(new Error('error'));
+
+    await expect(updateCommunity(communityToUpdate.communityId, patch)).rejects.toThrow('error');
+  });
+
+  test('should update cache after updated community', async () => {
+    enableCache();
+    client.http.put = jest.fn().mockResolvedValueOnce(resolvedPutValue);
+
+    await updateCommunity(communityToUpdate.communityId, patch);
+    const recieved = pullFromCache<Amity.Community>([
+      'community',
+      'get',
+      communityToUpdate.communityId,
+    ])?.data;
+
+    expect(recieved).toEqual(expect.objectContaining(updatedCommunity));
+
+    disableCache();
+  });
+
+  test('should fire event `onCommunityUpdated`', async () => {
+    let dispose;
+    client.http.put = jest.fn().mockResolvedValueOnce(resolvedPutValue);
+
+    const callbackPromise = new Promise(resolve => {
+      dispose = onCommunityUpdated(resolve);
+    }).finally(dispose);
+
+    await updateCommunity(updatedCommunity.communityId, patch);
+
+    await expect(callbackPromise).resolves.toEqual(expect.objectContaining(updatedCommunity));
+  });
+});

package/src/communityRepository/api/updateCommunity.ts

@@ -0,0 +1,60 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { fireEvent } from '~/core/events';
+
+import { saveCommunityUsers } from '~/communityRepository/utils/saveCommunityUsers';
+import { prepareCommunityPayload, prepareCommunityRequest } from '../utils';
+
+/* begin_public_function
+  id: community.update
+*/
+/**
+ * ```js
+ * import { updateCommunity } from '@amityco/ts-sdk'
+ * const updated = await updateCommunity(communityId, { displayName: 'foobar' })
+ * ```
+ *
+ * Updates an {@link Amity.Community}
+ *
+ * @param communityId The ID of the {@link Amity.Community} to edit
+ * @param patch The patch data to apply
+ * @returns the updated {@link Amity.Community} object
+ *
+ * @category Community API
+ * @async
+ */
+export const updateCommunity = async (
+  communityId: Amity.Community['communityId'],
+  patch: Patch<
+    Amity.Community,
+    'displayName' | 'avatarFileId' | 'description' | 'postSetting' | 'tags' | 'metadata'
+  > &
+    Amity.CommunityStorySettings,
+): Promise<Amity.Cached<Amity.Community>> => {
+  const client = getActiveClient();
+  client.log('community/updateCommunity', communityId, patch);
+
+  const { data: payload } = await client.http.put<Amity.CommunityPayload>(
+    `/api/v3/communities/${communityId}`,
+    prepareCommunityRequest(patch),
+  );
+
+  fireEvent('community.updated', payload);
+
+  const data = prepareCommunityPayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) {
+    ingestInCache(data, { cachedAt });
+    saveCommunityUsers(data.communities, data.communityUsers);
+  }
+
+  const { communities } = data;
+
+  return {
+    data: communities.find(community => community.communityId === communityId)!,
+    cachedAt,
+  };
+};
+/* end_public_function */

package/src/communityRepository/communityMembership/api/addMembers.ts

@@ -0,0 +1,49 @@
+import { getActiveClient } from '~/client/api';
+
+import { fireEvent } from '~/core/events';
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
+
+/* begin_public_function
+  id: community.membership.add_members
+*/
+/**
+ * ```js
+ * import { CommunityRepository } from '@amityco/ts-sdk'
+ * const updated = await CommunityRepository.moderation.addMembers(communityId, ['foo', 'bar'])
+ * ```
+ *
+ * Adds a list of {@link Amity.InternalUser} to a {@link Amity.Community} to add users to
+ *
+ * @param communityId The ID of the {@link Amity.Community} to perform
+ * @param userIds The list of IDs {@link Amity.InternalUser} to add
+ * @returns A success boolean if the {@link Amity.InternalUser} were added to the {@link Amity.Community}
+ *
+ * @category Community API
+ * @async
+ */
+export const addMembers = async (
+  communityId: Amity.Community['communityId'],
+  userIds: Amity.InternalUser['userId'][],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('community/moderation/addMembers', communityId, userIds);
+
+  const { data: payload } = await client.http.post<Amity.CommunityMembershipPayload>(
+    `/api/v3/communities/${communityId}/users`,
+    { communityId, userIds },
+  );
+
+  fireEvent('local.community.userAdded', payload);
+
+  const data = prepareMembershipPayload(payload, 'communityUsers');
+
+  if (client.cache) ingestInCache(data);
+
+  const { communityUsers } = data;
+  return !!communityUsers.find(
+    communityUser =>
+      communityUser.communityId === communityId && communityUser.communityMembership === 'member',
+  );
+};
+/* end_public_function */

package/src/communityRepository/communityMembership/api/index.ts

@@ -0,0 +1,2 @@
+export * from './addMembers';
+export * from './removeMembers';