@amityco/ts-sdk 7.10.1-c2a9783.0 → 7.10.1-ec1ce4a3.0

package/src/communityRepository/communityMembership/observers/searchMembers/SearchCommunityMembersQueryStreamController.ts

@@ -1,111 +0,0 @@
-import { QueryStreamController } from '~/core/liveCollection/QueryStreamController';
-import { pullFromCache, pushToCache } from '~/cache/api';
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { getResolver } from '~/core/model';
-import { getActiveClient } from '~/client';
-import { EnumCommunityMemberActions } from './enums';
-
-export class SearchCommunityMembersQueryStreamController extends QueryStreamController<
-  Amity.CommunityMembershipPayload,
-  Amity.SearchCommunityMemberLiveCollection
-> {
-  private notifyChange: (params: Amity.LiveCollectionNotifyParams) => void;
-
-  private preparePayload: (
-    response: Amity.CommunityMembershipPayload,
-  ) => Amity.ProcessedCommunityMembershipPayload;
-
-  constructor(
-    query: Amity.SearchCommunityMemberLiveCollection,
-    cacheKey: string[],
-    notifyChange: (params: Amity.LiveCollectionNotifyParams) => void,
-    preparePayload: (
-      response: Amity.CommunityMembershipPayload,
-    ) => Amity.ProcessedCommunityMembershipPayload,
-  ) {
-    super(query, cacheKey);
-    this.notifyChange = notifyChange;
-    this.preparePayload = preparePayload;
-  }
-
-  async saveToMainDB(response: Amity.CommunityMembershipPayload) {
-    const processedPayload = await this.preparePayload(response);
-
-    const client = getActiveClient();
-    const cachedAt = client.cache && Date.now();
-
-    if (client.cache) {
-      ingestInCache(processedPayload, { cachedAt });
-    }
-  }
-
-  appendToQueryStream(
-    response: Amity.CommunityMembershipPayload & Partial<Amity.Pagination>,
-    direction: Amity.LiveCollectionPageDirection,
-    refresh = false,
-  ) {
-    if (refresh) {
-      pushToCache(this.cacheKey, {
-        data: response.communityUsers.map(({ communityId, userId }) =>
-          getResolver('communityUsers')({ communityId, userId }),
-        ),
-      });
-    } else {
-      const collection = pullFromCache<Amity.CommunityLiveCollectionCache>(this.cacheKey)?.data;
-
-      const communityUsers = collection?.data ?? [];
-
-      pushToCache(this.cacheKey, {
-        ...collection,
-        data: [
-          ...new Set([
-            ...communityUsers,
-            ...response.communityUsers.map(({ communityId, userId }) =>
-              getResolver('communityUsers')({ communityId, userId }),
-            ),
-          ]),
-        ],
-      });
-    }
-  }
-
-  reactor(action: EnumCommunityMemberActions) {
-    return (
-      community: Amity.InternalCommunity,
-      communityMembers: Amity.Membership<'community'>[],
-    ) => {
-      const collection = pullFromCache<Amity.SearchCommunityMemberLiveCollectionCache>(
-        this.cacheKey,
-      )?.data;
-      if (!collection) return;
-
-      communityMembers.forEach(communityMember => {
-        const communityMemberCacheId = getResolver('communityUsers')({
-          communityId: this.query.communityId,
-          userId: communityMember.userId,
-        });
-
-        if (communityMember.communityMembership === 'none') {
-          collection.data = collection.data.filter(m => m !== communityMemberCacheId);
-        }
-      });
-
-      pushToCache(this.cacheKey, collection);
-      this.notifyChange({ origin: Amity.LiveDataOrigin.EVENT, loading: false });
-    };
-  }
-
-  subscribeRTE(
-    createSubscriber: {
-      fn: (
-        reactor: (
-          channel: Amity.InternalCommunity,
-          communityUser: Amity.Membership<'community'>[],
-        ) => void,
-      ) => Amity.Unsubscriber;
-      action: EnumCommunityMemberActions;
-    }[],
-  ) {
-    return createSubscriber.map(subscriber => subscriber.fn(this.reactor(subscriber.action)));
-  }
-}

package/src/communityRepository/communityMembership/observers/searchMembers/enums.ts

@@ -1,10 +0,0 @@
-export enum EnumCommunityMemberActions {
-  OnCommunityJoined = 'onCommunityJoined',
-  OnLocalCommunityJoin = 'onLocalCommunityJoin',
-  OnCommunityLeft = 'onCommunityLeft',
-  OnCommunityUserBanned = 'onCommunityUserBanned',
-  OnCommunityUserChanged = 'onCommunityUserChanged',
-  OnCommunityUserRoleAdded = 'onCommunityUserRoleAdded',
-  OnCommunityUserRoleRemoved = 'onCommunityUserRoleRemoved',
-  OnCommunityUserUnbanned = 'onCommunityUserUnbanned',
-}

package/src/communityRepository/communityMembership/observers/searchMembers.ts

@@ -1,60 +0,0 @@
-import { getActiveClient } from '~/client/api';
-import { ENABLE_CACHE_MESSAGE } from '~/utils/constants';
-import { dropFromCache } from '~/cache/api';
-import { SearchCommunityMembersLiveCollectionController } from './searchMembers/SearchCommunityMembersLiveCollectionController';
-
-/* begin_public_function
-  id: community.membership.query
-*/
-/**
- * ```js
- * import { searchMembers } from '@amityco/ts-sdk'
- *
- * let communityMembers = []
- * const unsub = searchMembers({
- *   communityId: Amity.Community['communityId'],
- * }, response => merge(communityMembers, response.data))
- * ```
- *
- * Observe all mutations on a list of {@link Amity.CommunityUser}s
- *
- * @param params for querying community users
- * @param callback the function to call when new data are available
- * @returns An {@link Amity.Unsubscriber} function to run when willing to stop observing the community users
- *
- * @category Community Live Collection
- */
-export const searchMembers = (
-  params: Amity.SearchCommunityMemberLiveCollection,
-  callback: Amity.LiveCollectionCallback<Amity.Membership<'community'>>,
-  config?: Amity.LiveCollectionConfig,
-) => {
-  const { log, cache } = getActiveClient();
-
-  if (!cache) {
-    console.log(ENABLE_CACHE_MESSAGE);
-  }
-
-  const timestamp = Date.now();
-  log(`getMembers(tmpid: ${timestamp}) > listen`);
-
-  const searchCommunityMemberLiveCollection = new SearchCommunityMembersLiveCollectionController(
-    params,
-    resp => {
-      callback(resp);
-    },
-  );
-  const disposers = searchCommunityMemberLiveCollection.startSubscription();
-
-  const cacheKey = searchCommunityMemberLiveCollection.getCacheKey();
-
-  disposers.push(() => {
-    dropFromCache(cacheKey);
-  });
-
-  return () => {
-    log(`getMembers(tmpid: ${timestamp}) > dispose`);
-    disposers.forEach(fn => fn());
-  };
-};
-/* end_public_function */

package/src/communityRepository/communityMembership/observers/tests/getMembers.test.ts

@@ -1,246 +0,0 @@
-import { getPastDate } from '~/core/model';
-import { disableCache, enableCache } from '~/cache/api';
-import {
-  bannedCommunityUser,
-  client,
-  community11,
-  communityUser11,
-  communityUser13,
-  communityUserQueryResponse,
-  communityUserQueryResponsePage2,
-  connectClient,
-  convertedCommunityUser1,
-  convertedCommunityUser2,
-  convertedCommunityUser3,
-  disconnectClient,
-  pause,
-  user11,
-  user13,
-  withRoleCommunityUser,
-} from '~/utils/tests';
-
-// makes it easier to spy on applyFilter
-import * as getMembersModule from '../getMembers';
-
-const { getMembers, applyFilter } = getMembersModule;
-
-const getSnapshot = (params?: Record<string, any>) => {
-  return {
-    data: [] as Amity.Membership<'community'>[],
-    loading: true,
-    error: undefined as any,
-    ...params,
-  };
-};
-
-describe('getMembers', () => {
-  beforeAll(connectClient);
-  afterAll(disconnectClient);
-
-  beforeEach(enableCache);
-  afterEach(disableCache);
-
-  const { communityId } = community11;
-
-  test('it should return community members collection', async () => {
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(communityUserQueryResponse);
-
-    getMembers({ communityId }, callback);
-    await pause();
-
-    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
-    expect(callback).toHaveBeenNthCalledWith(
-      2,
-      expect.objectContaining(
-        getSnapshot({ data: [convertedCommunityUser1, convertedCommunityUser2], loading: false }),
-      ),
-    );
-  });
-
-  test('it should return method to fetch next page', async () => {
-    const callback = jest.fn();
-    client.http.get = jest
-      .fn()
-      .mockResolvedValue(communityUserQueryResponse)
-      .mockResolvedValueOnce(communityUserQueryResponsePage2);
-
-    getMembers({ communityId, sortBy: 'firstCreated' }, callback);
-    await pause();
-
-    expect(callback).toHaveBeenCalled();
-    expect(callback.mock.lastCall).toHaveLength(1);
-
-    const { onNextPage, hasNextPage } = callback.mock.lastCall[0];
-
-    expect(hasNextPage).toBe(true);
-    expect(onNextPage).toBeTruthy();
-
-    onNextPage();
-    await pause();
-
-    const payload = [convertedCommunityUser1, convertedCommunityUser2];
-    const payload2 = [withRoleCommunityUser, bannedCommunityUser];
-
-    const snapshot = getSnapshot();
-    snapshot.loading = false;
-    snapshot.data = [...payload2, ...payload];
-
-    expect(callback).toHaveBeenNthCalledWith(4, expect.objectContaining(snapshot));
-  });
-
-  const events: [
-    string,
-    keyof Amity.Events,
-    Amity.RawMembership<'community'>,
-    Amity.InternalUser,
-    Amity.Membership<'community'>[],
-  ][] = [
-    [
-      'it should add new member to collection onJoined',
-      'community.joined',
-      communityUser13,
-      user13,
-      [convertedCommunityUser1, convertedCommunityUser3, convertedCommunityUser2],
-    ],
-    [
-      'it should remove member from collection onLeft',
-      'community.left',
-      { ...communityUser11, communityMembership: 'none' },
-      user11,
-      [{ ...convertedCommunityUser1, communityMembership: 'none' }, convertedCommunityUser2],
-    ],
-    [
-      'it should add new member to collection onMemberCountChanged',
-      'community.userChanged',
-      communityUser13,
-      user13,
-      [convertedCommunityUser1, convertedCommunityUser3, convertedCommunityUser2],
-    ],
-    [
-      'it should update member in collection onMemberCountChanged',
-      'community.userChanged',
-      { ...communityUser13, communityMembership: 'none' },
-      user13,
-      [
-        convertedCommunityUser1,
-        { ...convertedCommunityUser3, communityMembership: 'none' },
-        convertedCommunityUser2,
-      ],
-    ],
-    [
-      'it should update member membership on ban',
-      'community.userBanned',
-      { ...communityUser11, communityMembership: 'banned' },
-      user11,
-      [{ ...convertedCommunityUser1, communityMembership: 'banned' }, convertedCommunityUser2],
-    ],
-    [
-      'it should update membership on Unban',
-      'community.userUnbanned',
-      communityUser13,
-      user13,
-      [convertedCommunityUser1, convertedCommunityUser3, convertedCommunityUser2],
-    ],
-  ];
-
-  test.each(events)('%s', async (test, event, communityUserRaw, user, expected) => {
-    const callback = jest.fn();
-    client.http.get = jest.fn().mockResolvedValue(communityUserQueryResponse);
-
-    getMembers({ communityId, sortBy: 'firstCreated' }, callback);
-    await pause();
-
-    client.emitter.emit(event, {
-      communities: [community11],
-      communityUsers: [communityUserRaw],
-      users: [user],
-      files: [],
-    });
-    await pause();
-
-    expect(callback).toHaveBeenNthCalledWith(
-      3,
-      expect.objectContaining(
-        getSnapshot({
-          data: expected,
-          loading: false,
-        }),
-      ),
-    );
-  });
-
-  test('it should apply fileters on RTE only', async () => {
-    const callback = jest.fn();
-    const applyFilterSpy = jest.spyOn(getMembersModule, 'applyFilter');
-    client.http.get = jest.fn().mockResolvedValue(communityUserQueryResponse);
-
-    getMembers({ communityId, sortBy: 'firstCreated' }, callback);
-    await pause();
-
-    expect(applyFilterSpy).not.toHaveBeenCalled();
-
-    client.emitter.emit('community.joined', {
-      communities: [community11],
-      communityUsers: [communityUser13],
-      users: [user13],
-      files: [],
-      categories: [],
-      feeds: [],
-    });
-    await pause();
-
-    expect(applyFilterSpy).toHaveBeenCalled();
-  });
-});
-
-describe('getMembers > applyFilter', () => {
-  const { communityId } = community11;
-
-  const m1 = {
-    communityId,
-    userId: 'test',
-    communityMembership: 'member',
-    roles: ['test-role'],
-    createdAt: new Date().toISOString(),
-  } as Amity.Membership<'community'>;
-
-  const m2 = {
-    communityId,
-    userId: 'searchable',
-    communityMembership: 'banned',
-    createdAt: getPastDate(),
-  } as Amity.Membership<'community'>;
-
-  const filters: [
-    string,
-    Amity.CommunityMemberLiveCollection,
-    Amity.Membership<'community'>[],
-    Amity.Membership<'community'>[],
-  ][] = [
-    ['it should filter by roles', { communityId, roles: ['test-role'] }, [m1, m2], [m1]],
-    [
-      'it should filter by memberships: member',
-      { communityId, memberships: ['member'] },
-      [m1, m2],
-      [m1],
-    ],
-    [
-      'it should filter by memberships: banned',
-      { communityId, memberships: ['banned'] },
-      [m1, m2],
-      [m2],
-    ],
-    ['it should sort by last created', { communityId }, [m1, m2], [m1, m2]],
-    [
-      'it should sort by first created',
-      { communityId, sortBy: 'firstCreated' },
-      [m1, m2],
-      [m2, m1],
-    ],
-  ];
-
-  test.each(filters)('%s', (test, param, input, expected) => {
-    expect(applyFilter(input, param)).toStrictEqual(expected);
-  });
-});

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

@@ -1,52 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { fireEvent } from '~/core/events';
-import { prepareCommunityMembershipPayload } from '~/communityRepository/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.InternalUser} 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.InternalUser} to perform
- * @returns A success boolean if the {@link Amity.Role} were added to list of {@link Amity.InternalUser} in the {@link Amity.Community}
- *
- * @category Community API
- * @async
- */
-export const addRoles = async (
-  communityId: Amity.Community['communityId'],
-  roleIds: Amity.Role['roleId'][],
-  userIds: Amity.InternalUser['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 = prepareCommunityMembershipPayload(payload);
-
-  if (client.cache) ingestInCache(data);
-
-  fireEvent('local.community.roleAdded', 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/banMembers.ts

@@ -1,50 +0,0 @@
-import { getActiveClient } from '~/client/api/activeClient';
-
-import { ingestInCache } from '~/cache/api/ingestInCache';
-
-import { prepareMembershipPayload } from '~/group/utils';
-
-/* begin_public_function
-  id: community.moderation.ban_members
-*/
-/**
- * ```js
- * import { CommunityRepository } from '@amityco/ts-sdk'
- *
- * await CommunityRepository.Moderation.banMembers('communityId', ['userId1', 'userId2'])
- * ```
- *
- * @param communityId of {@link Amity.Community} from which the users should be banned
- * @param userIds of the {@link Amity.InternalUser}'s to be banned
- * @returns the updated {@link Amity.Membership}'s object
- *
- * @category Community API
- * @async
- * */
-export const banMembers = async (
-  communityId: Amity.Community['communityId'],
-  userIds: Amity.InternalUser['userId'][],
-): Promise<Amity.Cached<Amity.Membership<'community'>[]>> => {
-  const client = getActiveClient();
-  client.log('community/banMembers', { userIds, communityId });
-
-  const { data: payload } = await client.http.put<Amity.CommunityMembershipPayload>(
-    `/api/v3/communities/${communityId}/users/ban`,
-    {
-      userIds,
-    },
-  );
-
-  const data = prepareMembershipPayload(payload, 'communityUsers');
-
-  const cachedAt = client.cache && Date.now();
-  if (client.cache) ingestInCache(data, { cachedAt });
-
-  const { communityUsers } = data;
-
-  return {
-    data: communityUsers.filter(u => userIds.includes(u.userId)),
-    cachedAt,
-  };
-};
-/* end_public_function */

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

@@ -1,5 +0,0 @@
-export * from './addRoles';
-export * from './removeRoles';
-
-export * from './banMembers';
-export * from './unbanMembers';

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

@@ -1,52 +0,0 @@
-import { getActiveClient } from '~/client/api';
-
-import { ingestInCache } from '~/cache/api/ingestInCache';
-import { prepareCommunityMembershipPayload } from '~/communityRepository/utils';
-import { fireEvent } from '~/core/events';
-
-/* 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.InternalUser} 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.InternalUser} to perform
- * @returns A success boolean if the {@link Amity.Role} were removed from list of {@link Amity.InternalUser} in the {@link Amity.Community}
- *
- * @category Community API
- * @async
- */
-export const removeRoles = async (
-  communityId: Amity.Community['communityId'],
-  roleIds: Amity.Role['roleId'][],
-  userIds: Amity.InternalUser['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 = prepareCommunityMembershipPayload(payload);
-
-  if (client.cache) ingestInCache(data);
-
-  fireEvent('local.community.roleRemoved', 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/addRoles.test.ts

@@ -1,63 +0,0 @@
-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();
-  });
-});