@amityco/ts-sdk 7.10.1-9fe9d33d.0 → 7.10.1-ec1ce4a3.0

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

@@ -1,82 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,107 +0,0 @@
-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

@@ -1,65 +0,0 @@
-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

@@ -1,72 +0,0 @@
-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';
-import { LinkedObject } from '~/utils/linkedObject';
-
-/* begin_public_function
-  id: community.update
-*/
-/**
- * ```js
- * import { updateCommunity } from '@amityco/ts-sdk'
- * const updated = await updateCommunity(communityId, { displayName: 'foobar', isDiscoverable: true, requiresJoinApproval: false })
- * ```
- *
- * 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'
-    | 'isDiscoverable'
-    | 'requiresJoinApproval'
-    | 'isPublic'
-    | 'categoryIds'
-  > &
-    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: LinkedObject.community(
-      communities.find(community => community.communityId === communityId)!,
-    ),
-    cachedAt,
-  };
-};
-/* end_public_function */

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

@@ -1,49 +0,0 @@
-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

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

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

@@ -1,118 +0,0 @@
-import { pullFromCache, pushToCache } from '~/cache/api';
-import { getActiveClient } from '~/client/api';
-import { getResolver } from '~/core/model';
-
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { prepareMembershipPayload } from '~/group/utils';
-
-/**
- * ```js
- * import { queryCommunityMembers } from '@amityco/ts-sdk'
- * const communityMembers = await queryCommunityMembers({ communityId: 'foo' })
- * ```
- *
- * Queries a paginable list of {@link Amity.CommunityUser} objects
- *
- * @param query The query parameters
- * @returns A page of {@link Amity.CommunityUser} objects
- *
- * @category Community API
- * @async
- * */
-export const queryCommunityMembers = async (
-  query: Amity.QueryCommunityMembers,
-): Promise<Amity.Cached<Amity.PageToken<Amity.Membership<'community'>>>> => {
-  const client = getActiveClient();
-  client.log('community/queryCommunityMembers', query);
-
-  const { page, limit, ...params } = query ?? {};
-
-  const options = (() => {
-    if (page) return { token: page };
-    if (limit) return { limit };
-
-    return undefined;
-  })();
-
-  const { data: queryPayload } = await client.http.get<
-    Amity.CommunityMembershipPayload & Amity.Pagination
-  >(`/api/v3/communities/${params.communityId}/users`, {
-    params: {
-      ...params,
-      options,
-    },
-  });
-
-  const { paging, ...payload } = queryPayload;
-  const preparedPayload = prepareMembershipPayload(payload, 'communityUsers');
-  const { communityUsers } = preparedPayload;
-
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) {
-    ingestInCache(preparedPayload, { cachedAt });
-
-    const cacheKey = ['communityUsers', 'query', { ...params, options } as Amity.Serializable];
-
-    pushToCache(cacheKey, {
-      communityUsers: communityUsers.map(({ communityId, userId }) =>
-        getResolver('communityUsers')({ communityId, userId }),
-      ),
-      paging,
-    });
-  }
-
-  return { data: communityUsers, cachedAt, paging };
-};
-
-/**
- * ```js
- * import { queryCommunityMembers } from '@amityco/ts-sdk'
- * const communityMembers = await queryCommunityMembers(query)
- * ```
- *
- * Queries a paginable list of {@link Amity.InternalPost} objects from cache
- *
- * @param query The query parameters
- * @returns posts
- *
- * @category Post API
- */
-queryCommunityMembers.locally = (
-  query: Parameters<typeof queryCommunityMembers>[0],
-): Amity.Cached<Amity.PageToken<Amity.Membership<'community'>>> | undefined => {
-  const client = getActiveClient();
-  client.log('community/queryCommunityMembers', query);
-
-  if (!client.cache) return;
-
-  const { page, limit, ...params } = query ?? {};
-
-  const options = (() => {
-    if (page) return { token: page };
-    if (limit) return { limit };
-
-    return undefined;
-  })();
-
-  const cacheKey = ['communityUsers', 'query', { ...params, options } 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 { paging } = data;
-
-  return communityUsers.length === data?.communityUsers?.length
-    ? { data: communityUsers, cachedAt, paging }
-    : undefined;
-};

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

@@ -1,50 +0,0 @@
-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 { CommunityRepository } from '@amityco/ts-sdk'
- * const updated = await CommunityRepository.moderation.removeMembers(communityId, ['foo', 'bar'])
- * ```
- *
- * Removes a list of {@link Amity.InternalUser} from a {@link Amity.Community}
- *
- * @param communityId The ID of the {@link Amity.Community} to edit
- * @param userIds The list of IDs {@link Amity.InternalUser} to remove
- * @returns A success boolean if the list of {@link Amity.InternalUser} were removed from the {@link Amity.Community}
- *
- * @category Community API
- * @async
- */
-export const removeMembers = async (
-  communityId: Amity.Community['communityId'],
-  userIds: Amity.InternalUser['userId'][],
-): Promise<boolean> => {
-  const client = getActiveClient();
-  client.log('community/moderation/removeMembers', communityId, userIds);
-
-  const { data: payload } = await client.http.delete<Amity.CommunityMembershipPayload>(
-    `/api/v3/communities/${communityId}/users`,
-    { data: { communityId, userIds } },
-  );
-
-  fireEvent('local.community.userRemoved', 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 */