@amityco/ts-sdk 0.0.1-beta.32 → 0.0.1-beta.36

package/src/channel/observers/liveChannelMembers.ts

@@ -4,12 +4,11 @@ import { pullFromCache, pushToCache } from '~/cache/api';
 import { getActiveClient } from '~/client/api';
 import {
   createQuery,
-  runQuery,
-  queryOptions,
   filterByPropEquality,
-  sortByLastCreated,
+  queryOptions,
+  runQuery,
   sortByFirstCreated,
-  filterByPropInclusion,
+  sortByLastCreated,
 } from '~/core/query';
 import {
   COLLECTION_DEFAULT_CACHING_POLICY,
@@ -17,9 +16,11 @@ import {
   ENABLE_CACHE_MESSAGE,
 } from '~/utils/constants';
 import {
+  onChannelJoined,
+  onChannelLeft,
   onChannelMemberAdded,
-  onChannelMemberRemoved,
   onChannelMemberBanned,
+  onChannelMemberRemoved,
   onChannelMemberUnbanned,
 } from '../events';
 import { queryChannelMembers } from '../api';
@@ -80,13 +81,15 @@ export const liveChannelMembers = (
        * Muted is specified under seperarte property namely isMuted
        * Hence why I've seperately checked for it's equality
        */
-      if (params.memberships.some(m => ['member', 'banned'].includes(m))) {
-        channelMembers = filterByPropInclusion(channelMembers, 'membership', params.memberships);
-      }
+      channelMembers = channelMembers.filter(member => {
+        // @ts-ignore
+        if (params.memberships.includes('muted') && member.isMuted) {
+          return true;
+        }
 
-      if (params.memberships.includes('muted')) {
-        channelMembers = filterByPropEquality(channelMembers, 'isMuted', true);
-      }
+        // @ts-ignore
+        return params.memberships.includes(member.membership);
+      });
     }
 
     if (params.search) {
@@ -109,29 +112,30 @@ export const liveChannelMembers = (
     });
   };
 
-  const realtimeRouter = (
-    channelMember: Amity.Membership<'channel'>,
-    action: Amity.ChannelMemberActionType,
-  ) => {
-    const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(cacheKey)?.data;
-    if (!collection) return;
+  const realtimeRouter =
+    (action: Amity.ChannelMemberActionType) =>
+    (channel: Amity.Channel, channelMember: Amity.Membership<'channel'>) => {
+      if (params.channelId !== channelMember.channelId) {
+        return;
+      }
 
-    const channelMemberCacheId = getResolver('channelUsers')({
-      channelId: params.channelId,
-      userId: channelMember.userId,
-    });
+      const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(cacheKey)?.data;
+      if (!collection) return;
 
-    if (action === 'onMemberAdded') {
-      collection.data = [...new Set([channelMemberCacheId, ...collection.data])];
-    }
+      const channelMemberCacheId = getResolver('channelUsers')({
+        channelId: params.channelId,
+        userId: channelMember.userId,
+      });
 
-    if (action === 'onMemberRemoved') {
-      collection.data = collection.data.filter(m => m !== channelMemberCacheId);
-    }
+      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);
-    responder(collection);
-  };
+      pushToCache(cacheKey, collection);
+      responder(collection);
+    };
 
   const onFetch = () => {
     const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(cacheKey)?.data;
@@ -168,10 +172,12 @@ export const liveChannelMembers = (
   };
 
   disposers.push(
-    onChannelMemberAdded((_, member) => realtimeRouter(member, 'onMemberAdded')),
-    onChannelMemberRemoved((_, member) => realtimeRouter(member, 'onMemberRemoved')),
-    onChannelMemberBanned((_, member) => realtimeRouter(member, 'onChannelMemberBanned')),
-    onChannelMemberUnbanned((_, member) => realtimeRouter(member, 'onChannelMemberUnbanned')),
+    onChannelJoined(realtimeRouter('onJoin')),
+    onChannelLeft(realtimeRouter('onLeft')),
+    onChannelMemberAdded(realtimeRouter('onMemberAdded')),
+    onChannelMemberRemoved(realtimeRouter('onMemberRemoved')),
+    onChannelMemberBanned(realtimeRouter('onChannelMemberBanned')),
+    onChannelMemberUnbanned(realtimeRouter('onChannelMemberUnbanned')),
   );
 
   onFetch();

package/src/channel/observers/liveChannels.ts

@@ -12,14 +12,23 @@ import {
   sortByDisplayName,
   sortByFirstCreated,
 } from '~/core/query';
-import { onChannelCreated, onChannelDeleted, onChannelUpdated } from '../events';
-import { queryChannels } from '../api';
-
 import {
   COLLECTION_DEFAULT_CACHING_POLICY,
   COLLECTION_DEFAULT_PAGINATION_LIMIT,
   ENABLE_CACHE_MESSAGE,
 } from '~/utils/constants';
+import { onMessageCreated } from '~/message/events';
+import {
+  onChannelCreated,
+  onChannelDeleted,
+  onChannelUpdated,
+  onChannelMuted,
+  onChannelJoined,
+  onChannelLeft,
+  onChannelMemberAdded,
+  onChannelMemberRemoved,
+} from '../events';
+import { queryChannels } from '../api';
 
 /**
  * ```js
@@ -117,18 +126,14 @@ export const liveChannels = (
     });
   };
 
-  const realtimeRouter = (channel: Amity.Channel, action: Amity.ChannelActionType) => {
+  const realtimeRouter = (action: Amity.ChannelActionType) => (channel: Amity.Channel) => {
     const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(cacheKey)?.data;
     if (!collection) return;
 
-    if (action === 'onCreate') {
-      collection.data = [...new Set([channel.channelId, ...collection.data])];
-      /*
-       * if the filter isDeleted is set, only collection item must be updated and not
-       * the collection
-       */
-    } else if (action === 'onDelete' && !params.isDeleted) {
+    if (action === 'onDelete' && params.isDeleted === false) {
       collection.data = collection.data.filter(c => c !== channel.channelId);
+    } else {
+      collection.data = [...new Set([channel.channelId, ...collection.data])];
     }
 
     pushToCache(cacheKey, collection);
@@ -170,9 +175,15 @@ export const liveChannels = (
   };
 
   disposers.push(
-    onChannelCreated(channel => realtimeRouter(channel, 'onCreate')),
-    onChannelDeleted(channel => realtimeRouter(channel, 'onDelete')),
-    onChannelUpdated(channel => realtimeRouter(channel, 'onUpdate')),
+    onChannelCreated(realtimeRouter('onCreate')),
+    onChannelDeleted(realtimeRouter('onDelete')),
+    onChannelUpdated(realtimeRouter('onUpdate')),
+    onChannelMuted(realtimeRouter('onMute')),
+    onChannelJoined(realtimeRouter('onJoin')),
+    onChannelLeft(realtimeRouter('onLeft')),
+    onChannelMemberAdded(realtimeRouter('onMemberAdded')),
+    onChannelMemberRemoved(realtimeRouter('onMemberRemoved')),
+    onMessageCreated(() => null), // watch unread count
   );
 
   onFetch();

package/src/channel/observers/observeChannel.ts

@@ -9,6 +9,7 @@ import {
   onChannelDeleted,
   onChannelJoined,
   onChannelLeft,
+  onChannelMuted,
   onChannelMemberAdded,
   onChannelMemberRemoved,
 } from '../events';
@@ -57,6 +58,7 @@ export const observeChannel = <Events extends [Exclude<Amity.ChannelActionType,
     onChannelDeleted(data => router({ data, loading: false, origin: 'event' }, 'onDelete')),
     onChannelJoined(data => router({ data, loading: false, origin: 'event' }, 'onJoin')),
     onChannelLeft(data => router({ data, loading: false, origin: 'event' }, 'onLeft')),
+    onChannelMuted(data => router({ data, loading: false, origin: 'event' }, 'onMute')),
     onChannelMemberAdded(data =>
       router({ data, loading: false, origin: 'event' }, 'onMemberAdded'),
     ),

package/src/channel/observers/observeChannels.ts

@@ -6,6 +6,7 @@ import {
   onChannelDeleted,
   onChannelJoined,
   onChannelLeft,
+  onChannelMuted,
   onChannelMemberAdded,
   onChannelMemberRemoved,
 } from '../events';
@@ -48,6 +49,7 @@ export const observeChannels = (
     onChannelDeleted(data => router(data, 'onDelete')),
     onChannelJoined(data => router(data, 'onJoin')),
     onChannelLeft(data => router(data, 'onLeft')),
+    onChannelMuted(data => router(data, 'onMute')),
     onChannelMemberAdded(data => router(data, 'onMemberAdded')),
     onChannelMemberRemoved(data => router(data, 'onMemberRemoved')),
   );

package/src/channel/observers/tests/liveChannelMembers.test.ts

@@ -1,24 +1,38 @@
 import { disableCache, enableCache } from '~/cache/api';
+import { prepareMembershipPayload } from '~/group/utils';
 import {
+  bannedChannelUser,
+  channel1,
+  channelRaw1,
+  channelUser,
+  channelUser3,
+  channelUserModel,
+  channelUserQueryResponse,
+  channelUserQueryResponsePage2,
+  channelUserQueryResponsePage3,
+  channelUserWithRole,
   client,
   connectClient,
   disconnectClient,
-  channelUser1,
-  channelUser4,
-  channelUserQueryResponse,
-  channelUserQueryResponsePage3,
-  channelUserQueryResponsePage2,
-  channel11,
+  emptyChannelUserQueryResponse,
+  mutedChannelUser,
   pause,
+  rawBannedChannelUser,
+  rawChannelUser,
+  rawChannelUserWithRole,
+  user11,
+  user13,
+  user14,
 } from '~/utils/tests';
 import { liveChannelMembers } from '../liveChannelMembers';
 import { prepareChannelPayload } from '../../utils';
 
-const getSnapshot = () => {
+const getSnapshot = (params?: Record<string, any>) => {
   return {
-    data: [] as Amity.Membership<'channel'>[],
+    data: [] as Amity.MembershipRaw<'channel'>[],
     loading: true,
     error: undefined as any,
+    ...params,
   };
 };
 
@@ -35,51 +49,36 @@ describe('liveChannelMembers', () => {
 
   afterEach(disableCache);
 
-  const { channelId } = channel11;
+  const { channelId } = channel1;
 
   test('it should return channel members collection', async () => {
-    // mock response of queryChannels and validate
     const callback = jest.fn();
     client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
 
     liveChannelMembers({ channelId }, callback);
     await pause();
 
-    // check if cache data returned (should be empty)
     expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
-
-    const snapshot = getSnapshot();
-    snapshot.data = channelUserQueryResponse.data.channelUsers;
-    snapshot.loading = false;
-
-    expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(snapshot));
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining(getSnapshot({ data: channelUserModel, loading: false })),
+    );
   });
 
   const filters: [string, Amity.ChannelMembersLiveCollection, Amity.Membership<'channel'>[]][] = [
     [
       'roles',
       { channelId, roles: channelUserQueryResponsePage3.data.channelUsers[0].roles },
-      [channelUserQueryResponsePage3.data.channelUsers[0]],
-    ],
-    [
-      'searched term',
-      { channelId, search: 'use' },
-      [channelUserQueryResponsePage3.data.channelUsers[0]],
-    ],
-    [
-      'member',
-      { channelId, memberships: ['member'] },
-      [channelUserQueryResponsePage3.data.channelUsers[0]],
-    ],
-    [
-      'muted members',
-      { channelId, memberships: ['muted'] },
-      [channelUserQueryResponsePage3.data.channelUsers[1]],
+      [channelUserWithRole],
     ],
+    ['searched term', { channelId, search: 'use' }, [channelUserWithRole, bannedChannelUser]],
+    ['member', { channelId, memberships: ['member'] }, [channelUserWithRole, mutedChannelUser]],
+    ['muted members', { channelId, memberships: ['muted'] }, [mutedChannelUser]],
+    ['banned members', { channelId, memberships: ['banned'] }, [bannedChannelUser]],
     [
-      'banned members',
-      { channelId, memberships: ['banned'] },
-      [channelUserQueryResponsePage3.data.channelUsers[1]],
+      'muted and banned members',
+      { channelId, memberships: ['muted', 'banned'] },
+      [mutedChannelUser, bannedChannelUser],
     ],
   ];
 
@@ -90,14 +89,11 @@ describe('liveChannelMembers', () => {
     liveChannelMembers(params, callback);
     await pause();
 
-    const snapshot = getSnapshot();
-    // check if cache data returned (should be empty)
-    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(snapshot));
-
-    snapshot.loading = false;
-    snapshot.data = expected;
-
-    expect(callback).toHaveBeenNthCalledWith(2, expect.objectContaining(snapshot));
+    expect(callback).toHaveBeenNthCalledWith(1, expect.objectContaining(getSnapshot()));
+    expect(callback).toHaveBeenNthCalledWith(
+      2,
+      expect.objectContaining({ data: expected, loading: false }),
+    );
   });
 
   test('it should return method to fetch next page', async () => {
@@ -121,8 +117,15 @@ describe('liveChannelMembers', () => {
     onNextPage();
     await pause();
 
-    const payload = prepareChannelPayload(channelUserQueryResponse.data);
-    const payload2 = prepareChannelPayload(channelUserQueryResponsePage2.data);
+    const payload = prepareMembershipPayload(
+      prepareChannelPayload(channelUserQueryResponse.data),
+      'channelUsers',
+    );
+
+    const payload2 = prepareMembershipPayload(
+      prepareChannelPayload(channelUserQueryResponsePage2.data),
+      'channelUsers',
+    );
 
     const snapshot = getSnapshot();
     snapshot.loading = false;
@@ -131,32 +134,44 @@ describe('liveChannelMembers', () => {
     expect(callback).toHaveBeenNthCalledWith(4, expect.objectContaining(snapshot));
   });
 
-  const events: [string, keyof Amity.Events, Amity.Membership<'channel'>][] = [
+  const events: [
+    string,
+    keyof Amity.Events,
+    Amity.MembershipRaw<'channel'>,
+    Amity.User,
+    Amity.Membership<'channel'>[],
+  ][] = [
     [
       'it should add new member to collection onMemberAdded',
-      'v3.channel.didAddUsers',
-      channelUser4,
+      'channel.membersAdded',
+      rawChannelUserWithRole,
+      user14,
+      [channelUserWithRole, channelUser, channelUser3],
     ],
     [
-      'it should remove channel memeber from collection onMemberRemoved',
-      'v3.channel.didRemoveUsers',
-      channelUser1,
+      'it should remove channel member from collection onMemberRemoved',
+      'channel.membersRemoved',
+      { ...rawChannelUser, membership: 'none' },
+      user11,
+      [channelUser3],
     ],
     [
-      'it should update channel memeber membership on onChannelMemberBanned',
-      'v3.channel.didBan',
-      { ...channelUser1, membership: 'banned', isBanned: true },
+      '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 memeber membership on onChannelMemberUnbanned',
-      'v3.channel.didUnban',
-      { ...channelUser1, membership: 'none', isBanned: false },
+      '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) => {
-    const snapshot = getSnapshot();
-
+  test.each(events)('%s', async (test, event, channelUser, user, expected) => {
     const callback = jest.fn();
     client.http.get = jest.fn().mockResolvedValue(channelUserQueryResponse);
 
@@ -164,44 +179,41 @@ describe('liveChannelMembers', () => {
     await pause();
 
     client.emitter.emit(event, {
-      channels: [channel11],
+      channels: [channelRaw1],
       channelUsers: [channelUser],
-      users: [],
+      users: [user],
       files: [],
     });
+    await pause();
 
-    const payload = prepareChannelPayload(channelUserQueryResponse.data);
+    expect(callback).toHaveBeenNthCalledWith(
+      3,
+      expect.objectContaining(
+        getSnapshot({
+          data: expected,
+          loading: false,
+        }),
+      ),
+    );
+  });
 
-    snapshot.loading = false;
-    // get data based on event
-    switch (event) {
-      case 'v3.channel.didAddUsers':
-        snapshot.data = [channelUser, ...payload.channelUsers];
-        break;
-
-      case 'v3.channel.didBan': {
-        const bannedUserIdx = payload.channelUsers.findIndex(u => u.userId === channelUser.userId);
-        payload.channelUsers[bannedUserIdx] = channelUser;
-
-        snapshot.data = payload.channelUsers;
-        break;
-      }
-
-      case 'v3.channel.didUnban': {
-        const unbannedUserIdx = payload.channelUsers.findIndex(
-          u => u.userId === channelUser.userId,
-        );
-        payload.channelUsers[unbannedUserIdx] = channelUser;
-
-        snapshot.data = payload.channelUsers;
-        break;
-      }
-
-      default:
-        // delete payload
-        snapshot.data = payload.channelUsers.filter(u => u.userId !== channelUser.userId);
-    }
-
-    expect(callback).toHaveBeenNthCalledWith(3, expect.objectContaining(snapshot));
+  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);
+
+    liveChannelMembers({ 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 })),
+    );
   });
 });