@amityco/ts-sdk-react-native 6.7.1-80c1951.0

package/src/channelRepsitory/channelMembership/api/tests/removeMembers.test.ts

@@ -0,0 +1,112 @@
+import { ASCApiError } from '~/core/errors';
+import { getResolver } from '~/core/model';
+import { pullFromCache, enableCache, disableCache } from '~/cache/api';
+
+import {
+  client,
+  pause,
+  channelUserQueryResponse,
+  rawChannelUser,
+  rawChannelUser3,
+  channel1,
+  channelUser,
+  channelUser3,
+  connectClient,
+  disconnectClient,
+} from '~/utils/tests';
+
+import { onChannelMemberRemoved } from '~/channelRepsitory/events';
+
+import { removeMembers } from '../removeMembers';
+
+describe('removeMembers', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const { channelId } = channelUserQueryResponse.data.channels[0];
+  const { userId } = rawChannelUser;
+
+  // integration_test_id: fa47f7d9-2b60-4f4e-b65f-f3c3a7999a3f
+  test('it should remove channel members from channel', async () => {
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const recieved = await removeMembers(channelId, [userId]);
+
+    expect(recieved).toBe(true);
+  });
+
+  test('it should update cache with removed channel members', async () => {
+    enableCache();
+
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const channelUserCacheKey = getResolver('channelUsers')({
+      channelId,
+      userId,
+    });
+
+    const recieved = await removeMembers(channelId, [userId]);
+    const recievedCache = pullFromCache<Amity.Membership<'channel'>>([
+      'channelUsers',
+      'get',
+      channelUserCacheKey,
+    ])?.data;
+
+    expect(recieved).toBe(true);
+    expect(recievedCache).toBeDefined();
+    expect(recievedCache).toEqual(channelUser);
+
+    disableCache();
+  });
+
+  test('it should fire event when members are removed', async () => {
+    expect.assertions(1);
+
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+    let dispose;
+
+    const callback = new Promise(resolve => {
+      dispose = onChannelMemberRemoved(resolve);
+    }).finally(dispose);
+
+    await removeMembers(channelId, [userId]);
+
+    return expect(callback).resolves.not.toThrow();
+  });
+
+  test('it should fire event with all removed members', async () => {
+    client.http.delete = jest.fn().mockResolvedValueOnce(channelUserQueryResponse);
+
+    const callback = jest.fn();
+    const { userId: userId2 } = rawChannelUser3;
+    const unsub = onChannelMemberRemoved(callback);
+
+    const recieved = await removeMembers(channelId, [userId, userId2]);
+
+    expect(recieved).toBe(true);
+
+    await pause();
+
+    /*
+     * Removed assertion for checking what the callback was called with as it's
+     * impossible to guarantee the order in which the events will be fired
+     */
+    expect(callback).toHaveBeenCalledTimes(2);
+
+    unsub();
+  });
+
+  // integration_test_id: a9d13eff-5e17-4fc5-b20e-43c568aa8c23
+  test('it should return an error', async () => {
+    client.http.delete = jest
+      .fn()
+      .mockRejectedValueOnce(
+        new ASCApiError('banned', Amity.ServerError.CHANNEL_BAN, Amity.ErrorLevel.ERROR),
+      );
+
+    await expect(removeMembers('channelId', [])).rejects.toThrow('400304');
+  });
+});

package/src/channelRepsitory/channelMembership/index.ts

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

package/src/channelRepsitory/channelMembership/observers/getMembers.ts

@@ -0,0 +1,218 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+import {
+  createQuery,
+  filterByPropIntersection,
+  filterBySearchTerm,
+  queryOptions,
+  runQuery,
+  sortByFirstCreated,
+  sortByLastCreated,
+} from '~/core/query';
+import {
+  COLLECTION_DEFAULT_CACHING_POLICY,
+  COLLECTION_DEFAULT_PAGINATION_LIMIT,
+  ENABLE_CACHE_MESSAGE,
+} from '~/utils/constants';
+import {
+  onChannelJoined,
+  onChannelLeft,
+  onChannelMemberAdded,
+  onChannelMemberBanned,
+  onChannelMemberRemoved,
+  onChannelMemberUnbanned,
+} from '../../events';
+import { queryChannelMembers } from '../api/queryChannelMembers';
+
+/*
+ * Exported for testing
+ * @hidden
+ */
+export const applyFilter = <T extends Amity.Membership<'channel'>>(
+  data: T[],
+  params: Amity.ChannelMembersLiveCollection,
+): T[] => {
+  let channelMembers = filterByPropIntersection(data, 'roles', params.roles);
+
+  if (params.memberships) {
+    /*
+     * even though membership includes muted as a possible value
+     * when querying the server.
+     * Muted is specified under seperarte property namely isMuted
+     * Hence why I've seperately checked for it's equality
+     */
+    channelMembers = channelMembers.filter(member => {
+      // @ts-ignore
+      if (params.memberships.includes('muted') && member.isMuted) {
+        return true;
+      }
+
+      // @ts-ignore
+      return params.memberships.includes(member.membership);
+    });
+  }
+
+  if (params.search) {
+    // eslint-disable-next-line no-console
+    console.warn(
+      '`search` param will be deprecated in the next major release. If you want to search channel members by displayName, Please use `searchMembers()` instead.',
+    );
+    channelMembers = filterBySearchTerm(channelMembers, params.search);
+  }
+
+  // sort, 'lastCreated' is the default sort order
+  const sortBy = params.sortBy ? params.sortBy : 'lastCreated';
+  channelMembers = channelMembers.sort(
+    sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated,
+  );
+
+  return channelMembers;
+};
+
+/* begin_public_function
+  id: channel.member.query
+*/
+/**
+ * ```js
+ * import { getMembers } from '@amityco/ts-sdk-react-native'
+ *
+ * let channelMembers = []
+ * const unsub = getMembers({
+ *   channelId: Amity.Channel['channelId'],
+ * }, response => merge(channelMembers, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.ChannelUser}s
+ *
+ * @param params for querying channel 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 channel users
+ *
+ * @category Channel Live Collection
+ */
+export const getMembers = (
+  params: Amity.ChannelMembersLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Membership<'channel'>>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    // eslint-disable-next-line no-console
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`getMembers(tmpid: ${timestamp}) > listen`);
+
+  const { limit: queryLimit, ...queryParams } = params;
+
+  const limit = queryLimit ?? COLLECTION_DEFAULT_PAGINATION_LIMIT;
+  const { policy = COLLECTION_DEFAULT_CACHING_POLICY } = config ?? {};
+
+  const disposers: Amity.Unsubscriber[] = [];
+
+  // Put all overlap field to unknown type before convert again to Amity.Serializable
+  const cacheKey = ['channelUsers', 'collection', queryParams as unknown as Amity.Serializable];
+  const cacheByChannelKey = ['channelUsers', 'collection', { channelId: queryParams.channelId }];
+
+  const responder = (data: Amity.ChannelMembersLiveCollectionCache, isEventModel = false) => {
+    const channelMembers: Amity.Membership<'channel'>[] =
+      data.data
+        .map(id => pullFromCache<Amity.Membership<'channel'>>(['channelUsers', 'get', id])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    callback({
+      onNextPage: onFetch,
+      /*
+       * Only apply filter to RTE Model
+       */
+      data: isEventModel ? applyFilter(channelMembers, params) : channelMembers,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter =
+    (action: Amity.ChannelMemberActionType) =>
+    (channel: Amity.Channel, channelMember: Amity.Membership<'channel'>) => {
+      if (params.channelId !== channelMember.channelId) {
+        return;
+      }
+
+      const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(cacheKey)?.data;
+      if (!collection) return;
+
+      const channelMemberCacheId = getResolver('channelUsers')({
+        channelId: params.channelId,
+        userId: channelMember.userId,
+      });
+
+      if (channelMember.membership === 'none') {
+        collection.data = collection.data.filter(m => m !== channelMemberCacheId);
+      } else if (!collection.data.includes(channelMemberCacheId)) {
+        collection.data = [channelMemberCacheId, ...collection.data];
+      }
+
+      pushToCache(cacheKey, collection);
+      pushToCache(cacheByChannelKey, collection);
+
+      responder(collection, true);
+    };
+
+  const onFetch = (initial = false) => {
+    const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(cacheKey)?.data;
+
+    const channelMembers = collection?.data ?? [];
+
+    if (!initial && channelMembers.length > 0 && !collection?.params.page) return;
+
+    const query = createQuery(queryChannelMembers, {
+      ...queryParams,
+      page: (!initial ? collection?.params.page : undefined) ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: channelMembers,
+        };
+
+        if (result) {
+          data.data = [...new Set([...channelMembers, ...result.map(getResolver('channelUsers'))])];
+        }
+
+        pushToCache(cacheKey, data);
+        pushToCache(cacheByChannelKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onChannelJoined(realtimeRouter('onJoin')),
+    onChannelLeft(realtimeRouter('onLeft')),
+    onChannelMemberAdded(realtimeRouter('onMemberAdded')),
+    onChannelMemberRemoved(realtimeRouter('onMemberRemoved')),
+    onChannelMemberBanned(realtimeRouter('onChannelMemberBanned')),
+    onChannelMemberUnbanned(realtimeRouter('onChannelMemberUnbanned')),
+  );
+
+  onFetch(true);
+
+  return () => {
+    log(`getMembers(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};
+/* end_public_function */

package/src/channelRepsitory/channelMembership/observers/index.ts

@@ -0,0 +1,2 @@
+export * from './getMembers';
+export * from './searchMembers';

package/src/channelRepsitory/channelMembership/observers/searchMembers.ts

@@ -0,0 +1,33 @@
+/* eslint-disable no-use-before-define */
+
+import { getMembers } from './getMembers';
+
+/* begin_public_function
+  id: channel.member.search
+*/
+/**
+ * ```js
+ * import { ChannelRepository } from '@amityco/ts-sdk-react-native'
+ *
+ * let channelMembers = []
+ * const unsub = ChannelRepository.Membership.searchMembers({
+ *   channelId: Amity.Channel['channelId'],
+ * }, response => merge(channelMembers, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.ChannelUser}s
+ *
+ * @param params for searching channel 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 channel users
+ *
+ * @category Channel Live Collection
+ */
+export const searchMembers = (
+  params: Amity.SearchChannelMembers,
+  callback: Amity.LiveCollectionCallback<Amity.Membership<'channel'>>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  return getMembers(params, callback, config);
+};
+/* end_public_function */

package/src/channelRepsitory/channelMembership/observers/tests/getMembers.test.ts

@@ -0,0 +1,227 @@
+import { getPastDate } from '~/core/model';
+import { disableCache, enableCache } from '~/cache/api';
+import {
+  bannedChannelUser,
+  channel1,
+  channelRaw1,
+  channelUser,
+  channelUser3,
+  channelUserModel,
+  channelUserQueryResponse,
+  channelUserWithRole,
+  client,
+  connectClient,
+  disconnectClient,
+  emptyChannelUserQueryResponse,
+  pause,
+  rawBannedChannelUser,
+  rawChannelUser,
+  rawChannelUserWithRole,
+  user11,
+  user13,
+  user14,
+} 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.RawMembership<'channel'>[],
+    loading: true,
+    error: undefined as any,
+    ...params,
+  };
+};
+
+describe('getMembers', () => {
+  beforeAll(connectClient);
+  afterAll(disconnectClient);
+
+  beforeEach(enableCache);
+  afterEach(disableCache);
+
+  const { channelId } = channel1;
+
+  test('it should return channel members collection', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
+
+    getMembers({ channelId }, callback);
+    await pause();
+
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(getSnapshot({ data: channelUserModel, loading: false })),
+    );
+  });
+
+  const events: [
+    string,
+    keyof Amity.Events,
+    Amity.RawMembership<'channel'>,
+    Amity.User,
+    Amity.Membership<'channel'>[],
+  ][] = [
+    [
+      'it should add new member to collection onMemberAdded',
+      'channel.membersAdded',
+      rawChannelUserWithRole,
+      user14,
+      [channelUserWithRole, channelUser, channelUser3],
+    ],
+    [
+      'it should remove channel member from collection onMemberRemoved',
+      'channel.membersRemoved',
+      { ...rawChannelUser, membership: 'none' },
+      user11,
+      [channelUser3],
+    ],
+    [
+      'it should update channel member membership on onChannelMemberBanned',
+      'channel.banned',
+      { ...rawChannelUser, membership: 'banned', isBanned: true },
+      user11,
+      [{ ...channelUser, membership: 'banned', isBanned: true }, channelUser3],
+    ],
+    [
+      'it should update channel member membership on onChannelMemberUnbanned',
+      'channel.unbanned',
+      { ...rawChannelUser, membership: 'none', isBanned: false },
+      user11,
+      [channelUser3],
+    ],
+  ];
+
+  test.each(events)('%s', async (test, event, channelUser, user, expected) => {
+    const callback = jest.fn();
+
+    client.http.get = jest.fn().mockImplementation(url => {
+      if (url === `/api/v4/channels/${encodeURIComponent(channelId)}/users`)
+        return Promise.resolve(channelUserQueryResponse);
+
+      return undefined;
+    });
+
+    getMembers({ channelId }, callback);
+    await pause();
+
+    client.emitter.emit(event, {
+      channels: [channelRaw1],
+      channelUsers: [channelUser],
+      users: [user],
+      files: [],
+    });
+    await pause();
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining(
+        getSnapshot({
+          data: expected,
+          loading: false,
+        }),
+      ),
+    );
+  });
+
+  it('should add the banned user to the collection if channel.banned event happens', async () => {
+    const callback = jest.fn();
+    client.http.get = jest.fn().mockResolvedValue(emptyChannelUserQueryResponse);
+
+    getMembers({ channelId, memberships: ['banned'] }, callback);
+    await pause();
+    client.emitter.emit('channel.banned', {
+      channels: [channelRaw1],
+      channelUsers: [rawBannedChannelUser],
+      users: [user13],
+      files: [],
+    });
+    await pause();
+
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining(getSnapshot({ data: [bannedChannelUser], loading: false })),
+    );
+  });
+
+  test('it should apply filter on RTE only', async () => {
+    const callback = jest.fn();
+    const applyFilterSpy = jest.spyOn(getMembersModule, 'applyFilter');
+
+    client.http.get = jest.fn().mockResolvedValue(emptyChannelUserQueryResponse);
+
+    getMembers({ channelId, memberships: ['banned'] }, callback);
+    await pause();
+
+    expect(applyFilterSpy).not.toHaveBeenCalled();
+
+    client.emitter.emit('channel.banned', {
+      channels: [channelRaw1],
+      channelUsers: [rawBannedChannelUser],
+      users: [user13],
+      files: [],
+    });
+    await pause();
+
+    expect(applyFilterSpy).toHaveBeenCalled();
+  });
+});
+
+describe('getMembers > applyFilter', () => {
+  const { channelId } = channel1;
+
+  const ch1 = {
+    channelId,
+    userId: 'test',
+    membership: 'member',
+    readToSegment: 1,
+    roles: ['test-role'],
+    lastMentionedSegment: 1,
+    createdAt: new Date().toISOString(),
+  } as Amity.Membership<'channel'>;
+
+  const ch2 = {
+    channelId,
+    userId: 'test1',
+    membership: 'banned',
+    readToSegment: 1,
+    lastMentionedSegment: 1,
+    createdAt: getPastDate(),
+  } as Amity.Membership<'channel'>;
+
+  const filters: [
+    string,
+    Amity.ChannelMembersLiveCollection,
+    Amity.Membership<'channel'>[],
+    Amity.Membership<'channel'>[],
+  ][] = [
+    ['it should filter by roles', { channelId, roles: ['test-role'] }, [ch1, ch2], [ch1]],
+    [
+      'it should filter by membership:member',
+      { channelId, memberships: ['member'] },
+      [ch1, ch2],
+      [ch1],
+    ],
+    [
+      'it should filter by membership:banned',
+      { channelId, memberships: ['banned'] },
+      [ch1, ch2],
+      [ch2],
+    ],
+    ['it should sort by last created', { channelId }, [ch1, ch2], [ch1, ch2]],
+    [
+      'it should sort by first created',
+      { channelId, sortBy: 'firstCreated' },
+      [ch1, ch2],
+      [ch2, ch1],
+    ],
+  ];
+
+  test.each(filters)('%s', (test, param, input, expected) => {
+    expect(applyFilter(input, param)).toStrictEqual(expected);
+  });
+});