@amityco/ts-sdk 1.0.0-8aae813.0 → 6.0.0-beta01

package/src/communityRepository/communityModeration/api/addRoles.ts

@@ -0,0 +1,49 @@
+import { getActiveClient } from '~/client/api';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+import { prepareMembershipPayload } from '~/group/utils';
+
+/* begin_public_function
+  id: community.moderation.add_roles
+*/
+/**
+ * ```js
+ * import { CommunityRepository } from '@amityco/ts-sdk'
+ * const updated = await CommunityRepository.moderation.addRoles(communityId, ['foo', 'bar'])
+ * ```
+ *
+ * Adds a list of {@link Amity.Role} to 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 added to list of {@link Amity.User} in the {@link Amity.Community}
+ *
+ * @category Community API
+ * @async
+ */
+export const addRoles = async (
+  communityId: Amity.Community['communityId'],
+  roleIds: Amity.Role['roleId'][],
+  userIds: Amity.User['userId'][],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('community/moderation/addRoles', communityId, roleIds, userIds);
+
+  const { data: payload } = await client.http.post<Amity.CommunityMembershipPayload>(
+    `/api/v4/communities/${communityId}/users/roles`,
+    { 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)),
+  );
+};
+/* end_public_function */

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

@@ -0,0 +1,4 @@
+export * from './addMembers';
+export * from './removeMembers';
+export * from './addRoles';
+export * from './removeRoles';

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

@@ -0,0 +1,50 @@
+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.User} from a {@link Amity.Community}
+ *
+ * @param communityId The ID of the {@link Amity.Community} to edit
+ * @param userIds The list of IDs {@link Amity.User} to remove
+ * @returns A success boolean if the list of {@link Amity.User} were removed from the {@link Amity.Community}
+ *
+ * @category Community API
+ * @async
+ */
+export const removeMembers = async (
+  communityId: Amity.Community['communityId'],
+  userIds: Amity.User['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('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 */

package/src/communityRepository/communityModeration/api/removeRoles.ts

@@ -0,0 +1,49 @@
+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 { CommunityRepository } from '@amityco/ts-sdk'
+ * const updated = await CommunityRepository.moderation.removeRoles(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 removeRoles = async (
+  communityId: Amity.Community['communityId'],
+  roleIds: Amity.Role['roleId'][],
+  userIds: Amity.User['userId'][],
+): Promise<boolean> => {
+  const client = getActiveClient();
+  client.log('community/moderation/removeRoles', 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)),
+  );
+};
+/* end_public_function */

package/src/communityRepository/communityModeration/api/test/addMembers.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 '../../../communityMembership/events';
+import { addMembers } from '../addMembers';
+
+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 = addMembers(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(addMembers(communityToAddUserTo.communityId, [userToAdd.userId])).rejects.toThrow(
+      'error',
+    );
+  });
+
+  test('should create cache after added user', async () => {
+    enableCache();
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    await addMembers(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 addMembers(communityToAddUserTo.communityId, [userToAdd.userId]);
+
+    await expect(callback).resolves.toEqual(
+      expect.objectContaining({ ...communityToAddUserTo, isJoined: true }),
+    );
+  });
+});

package/src/communityRepository/communityModeration/api/test/addRoles.test.ts

@@ -0,0 +1,63 @@
+import { disableCache, enableCache, pullFromCache } from '~/cache/api';
+import { getResolver } from '~/core/model';
+
+import { client, community11, communityUser11, user11 } from '~/utils/tests';
+
+import { addRoles } from '../addRoles';
+
+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('community/ moderation/ addRoles', () => {
+  test('should return true', async () => {
+    client.http.post = jest.fn().mockResolvedValue(resolvedPostValue);
+
+    const recieved = addRoles(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(
+      addRoles(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 addRoles(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/communityRepository/communityModeration/api/test/removeMembers.test.ts

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

package/src/communityRepository/communityModeration/api/test/removeRoles.test.ts

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

package/src/communityRepository/communityModeration/index.ts

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

package/src/communityRepository/events/index.ts

@@ -0,0 +1,3 @@
+export * from './onCommunityCreated';
+export * from './onCommunityUpdated';
+export * from './onCommunityDeleted';

package/src/communityRepository/events/onCommunityCreated.ts

@@ -0,0 +1,19 @@
+import { createCommunityEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommunityCreated } from '@amityco/ts-sdk'
+ * const dispose = onCommunityCreated(community => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Community} have been created
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+export const onCommunityCreated = (callback: Amity.Listener<Amity.Community>) =>
+  createCommunityEventSubscriber('community.created', callback);

package/src/communityRepository/events/onCommunityDeleted.ts

@@ -0,0 +1,19 @@
+import { createCommunityEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommunityDeleted } from '@amityco/ts-sdk'
+ * const dispose = onCommunityDeleted(community => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Community} has been deleted
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+export const onCommunityDeleted = (callback: Amity.Listener<Amity.Community>) =>
+  createCommunityEventSubscriber('community.deleted', callback);

package/src/communityRepository/events/onCommunityUpdated.ts

@@ -0,0 +1,19 @@
+import { createCommunityEventSubscriber } from './utils';
+
+/**
+ * ```js
+ * import { onCommunityUpdated } from '@amityco/ts-sdk'
+ * const dispose = onCommunityUpdated(community => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when a {@link Amity.Community} has been updated
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Community Events
+ */
+export const onCommunityUpdated = (callback: Amity.Listener<Amity.Community>) =>
+  createCommunityEventSubscriber('community.updated', callback);

package/src/communityRepository/events/test/onCommunityCreated.test.ts

@@ -0,0 +1,46 @@
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  communityUser11,
+} from '~/utils/tests';
+
+import { onCommunityCreated } from '../onCommunityCreated';
+
+const communityToCreate = community11;
+
+const eventPayload: Amity.CommunityPayload = {
+  communities: [communityToCreate],
+  communityUsers: [communityUser11],
+  files: [],
+  users: [],
+  categories: [],
+  feeds: [],
+};
+
+describe('onCommunityCreated', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should got event after community created', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityCreated(callback);
+    client.emitter.emit('community.created', eventPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(communityToCreate);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityCreated(callback);
+
+    unsub();
+
+    client.emitter.emit('community.created', eventPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/communityRepository/events/test/onCommunityDeleted.test.ts

@@ -0,0 +1,42 @@
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  emptyCommunityPayload,
+} from '~/utils/tests';
+
+import { onCommunityDeleted } from '../onCommunityDeleted';
+
+const deletedCommunity = { ...community11, isDeleted: true };
+
+const eventPayload: Amity.CommunityPayload = {
+  ...emptyCommunityPayload,
+  communities: [deletedCommunity],
+};
+
+describe('onCommunityDeleted', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should got event after community deleted', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityDeleted(callback);
+    client.emitter.emit('community.deleted', eventPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(deletedCommunity);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityDeleted(callback);
+
+    unsub();
+
+    client.emitter.emit('community.deleted', eventPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});

package/src/communityRepository/events/test/onCommunityUpdated.test.ts

@@ -0,0 +1,49 @@
+import {
+  client,
+  connectClient,
+  disconnectClient,
+  community11,
+  communityUser11,
+  user11,
+} from '~/utils/tests';
+
+import { onCommunityUpdated } from '../onCommunityUpdated';
+
+const communityToUpdate = community11;
+const patch = { displayName: 'new-display-name' };
+const updatedCommunity = { ...communityToUpdate, ...patch };
+
+const eventPayload: Amity.CommunityPayload = {
+  communities: [updatedCommunity],
+  communityUsers: [communityUser11],
+  files: [],
+  users: [user11],
+  categories: [],
+  feeds: [],
+};
+
+describe('onCommunityUpdated', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  test('it should got event after community updated', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityUpdated(callback);
+    client.emitter.emit('community.updated', eventPayload);
+
+    unsub();
+
+    expect(callback).toHaveBeenCalled();
+    expect(callback).toHaveBeenCalledWith(updatedCommunity);
+  });
+
+  test('it should got nothing if we did unsubscribe before got event', () => {
+    const callback = jest.fn();
+    const unsub = onCommunityUpdated(callback);
+
+    unsub();
+
+    client.emitter.emit('community.updated', eventPayload);
+    expect(callback).not.toHaveBeenCalled();
+  });
+});