@amityco/ts-sdk 0.0.1-cb052d5.0 → 0.0.1-cb393db.0

package/src/channel/api/queryChannelMembers.ts

@@ -3,6 +3,8 @@ import { getActiveClient } from '~/client/api';
 import { toPage, toToken } from '~/core/query';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { queryChannelMembers } from '@amityco/ts-sdk'
@@ -19,35 +21,37 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  * */
 export const queryChannelMembers = async (query: {
   channelId: string;
-  membership?: 'all' | 'muted' | 'banned' | 'member&banned';
+  memberships?: ('muted' | 'banned' | 'member')[];
   roles?: string[];
   sortBy?: 'firstCreated' | 'lastCreated';
+  search?: string;
   page?: Amity.Page;
 }): Promise<Amity.Cached<Amity.Paged<Amity.Membership<'channel'>>>> => {
   const client = getActiveClient();
   client.log('channel/queryChannelMembers', query);
 
-  const { page, channelId, membership, ...params } = query ?? {};
+  const { page, channelId, ...params } = query ?? {};
 
-  const { data } = await client.http.get<Amity.ChannelMembershipPayload & Amity.Pagination>(
-    `/api/v3/channels/${encodeURIComponent(channelId)}/users`,
-    {
-      params: {
-        ...params,
-        filter: membership,
-        options: {
-          token: toToken(page, 'skiplimit'),
-        },
+  const { data: queryPayload } = await client.http.get<
+    Amity.ChannelMembershipPayload & Amity.Pagination
+  >(`/api/v4/channels/${encodeURIComponent(channelId)}/users`, {
+    params: {
+      ...params,
+      options: {
+        token: toToken(page, 'skiplimit'),
       },
     },
-  );
+  });
+
+  const { paging, ...payload } = queryPayload;
+
+  const data = prepareChannelPayload(payload);
 
-  const { paging, ...payload } = data;
-  const { channelUsers } = payload;
+  const { channelUsers } = data;
 
   const cachedAt = client.cache && Date.now();
   if (client.cache) {
-    ingestInCache(payload as Amity.ChannelMembershipPayload);
+    ingestInCache(data as Amity.ChannelMembershipPayload);
   }
 
   const nextPage = toPage(paging.next);

package/src/channel/api/queryChannels.ts

@@ -5,6 +5,8 @@ import { pushToCache } from '~/cache/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { getResolver } from '~/core/model';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { queryChannels } from '@amityco/ts-sdk'
@@ -20,15 +22,9 @@ import { getResolver } from '~/core/model';
  * @category Channel API
  * @async
  */
-export const queryChannels = async (query?: {
-  displayName?: string;
-  membership?: 'all' | 'member' | 'notMember';
-  sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
-  types?: Amity.ChannelType;
-  tags?: Amity.Taggable['tags'];
-  excludeTags?: Amity.Taggable['tags'];
-  page?: Amity.Page;
-}): Promise<Amity.Cached<Amity.Paged<Amity.Channel>>> => {
+export const queryChannels = async (
+  query?: Amity.QueryChannels,
+): Promise<Amity.Cached<Amity.Paged<Amity.Channel>>> => {
   const client = getActiveClient();
   client.log('channel/queryChannels', query);
 
@@ -38,7 +34,7 @@ export const queryChannels = async (query?: {
   // API-FIX: parameters should be querystring.
   // API-FIX: backend doesnt answer Amity.Response
   // const { data } = await client.http.get<Amity.Response<Amity.Paged<ChannelPayload>>>(
-  const { data } = await client.http.get<Amity.ChannelPayload & Amity.Pagination>(
+  const { data: queryPayload } = await client.http.get<Amity.ChannelPayload & Amity.Pagination>(
     `/api/v3/channels`,
     {
       params: {
@@ -52,13 +48,16 @@ export const queryChannels = async (query?: {
     },
   );
 
-  const { paging, ...payload } = data;
-  const { channels } = payload;
+  const { paging, ...payload } = queryPayload;
+
+  const data = prepareChannelPayload(payload);
+
+  const { channels } = data;
 
   const cachedAt = client.cache && Date.now();
 
   if (client.cache) {
-    ingestInCache(payload as Amity.ChannelPayload, { cachedAt });
+    ingestInCache(data as Amity.ChannelPayload, { cachedAt });
 
     const cacheKey = [
       'channel',

package/src/channel/api/removeChannelMembers.ts

@@ -3,6 +3,8 @@ import { getActiveClient } from '~/client/api';
 import { ingestInCache } from '~/cache/api/ingestInCache';
 import { fireEvent } from '~/core/events';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { removeChannelMembers } from '@amityco/ts-sdk'
@@ -25,16 +27,16 @@ export const removeChannelMembers = async (
   const client = getActiveClient();
   client.log('channel/removeChannelMembers', channelId, userIds);
 
-  const { data } = await client.http.delete<Amity.ChannelMembershipPayload>(
+  const { data: payload } = await client.http.delete<Amity.ChannelMembershipPayload>(
     `/api/v3/channels/${encodeURIComponent(channelId)}/users`,
     { data: { channelId, userIds } },
   );
 
+  const data = prepareChannelPayload(payload);
+
   if (client.cache) ingestInCache(data);
 
-  fireEvent('v3.channel.didRemoveUsers', {
-    channels: data.channels!,
-  });
+  fireEvent('v3.channel.didRemoveUsers', data);
 
   const { channelUsers } = data;
   return !!channelUsers.find(

package/src/channel/api/removeChannelMembersRole.ts

@@ -2,6 +2,8 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { removeChannelMembersRole } from '@amityco/ts-sdk'
@@ -26,11 +28,13 @@ export const removeChannelMembersRole = async (
   const client = getActiveClient();
   client.log('channel/removeChannelMembersRole', channelId, roleId, userIds);
 
-  const { data } = await client.http.delete<Amity.ChannelMembershipPayload>(
+  const { data: payload } = await client.http.delete<Amity.ChannelMembershipPayload>(
     `/api/v3/channels/${encodeURIComponent(channelId)}/users/roles`,
     { data: { channelId, role: roleId, userIds } },
   );
 
+  const data = prepareChannelPayload(payload);
+
   if (client.cache) ingestInCache(data);
 
   const { channelUsers } = data;

package/src/channel/api/unbanChannelMembers.ts

@@ -0,0 +1,45 @@
+import { getActiveClient } from '~/client/api/activeClient';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { unbanChannelMembers } from '@amityco/ts-sdk'
+ *
+ * await unbanChannelMembers('channel-id-1', ['userId1', 'userId2'])
+ * ```
+ *
+ * @param channelId of {@link Amity.Channel} where the users should be unbanned
+ * @param userIds of the {@link Amity.User}'s to be unbanned
+ * @returns the updated {@link Amity.Membership}'s object
+ *
+ * @category Channel API
+ * @async
+ * */
+export const unbanChannelMembers = async (
+  channelId: Amity.Channel['channelId'],
+  userIds: Amity.User['userId'][],
+): Promise<Amity.Cached<Amity.Membership<'channel'>[]>> => {
+  const client = getActiveClient();
+  client.log('channel/unbanChannelMembers', { userIds, channelId });
+
+  const { data: payload } = await client.http.put<Amity.ChannelPayload>(
+    `/api/v3/channels/${encodeURIComponent(channelId)}/users/unban`,
+    {
+      userIds,
+    },
+  );
+
+  const data = prepareChannelPayload(payload);
+
+  const cachedAt = client.cache && Date.now();
+  if (client.cache) ingestInCache(data, { cachedAt });
+
+  const { channelUsers } = data;
+  return {
+    data: channelUsers?.filter(user => user.membership === 'member')!,
+    cachedAt,
+  };
+};

package/src/channel/api/updateChannel.ts

@@ -2,6 +2,8 @@ import { getActiveClient } from '~/client/api';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { updateChannel } from '@amityco/ts-sdk'
@@ -19,16 +21,18 @@ import { ingestInCache } from '~/cache/api/ingestInCache';
  */
 export const updateChannel = async (
   channelId: Amity.Channel['channelId'],
-  patch: Patch<Amity.Channel, 'displayName' | 'description' | 'avatarFileId' | 'metadata'>,
+  patch: Patch<Amity.Channel, 'displayName' | 'avatarFileId' | 'tags' | 'metadata'>,
 ): Promise<Amity.Cached<Amity.Channel>> => {
   const client = getActiveClient();
   client.log('channel/updateChannel', channelId, patch);
 
-  const { data } = await client.http.put<Amity.ChannelPayload>(
+  const { data: payload } = await client.http.put<Amity.ChannelPayload>(
     `/api/v3/channels/${encodeURIComponent(channelId)}`,
     patch,
   );
 
+  const data = prepareChannelPayload(payload);
+
   const cachedAt = client.cache && Date.now();
   if (client.cache) ingestInCache(data, { cachedAt });
 

package/src/channel/events/index.ts

@@ -1,6 +1,7 @@
+export * from './onChannelCreated';
 export * from './onChannelUpdated';
 export * from './onChannelDeleted';
 export * from './onChannelJoined';
 export * from './onChannelLeft';
-export * from './onMemberAdded';
-export * from './onMemberRemoved';
+export * from './onChannelMemberAdded';
+export * from './onChannelMemberRemoved';

package/src/channel/events/onChannelCreated.ts

@@ -3,6 +3,8 @@ import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { onChannelCreated } from '@amityco/ts-sdk'
@@ -22,8 +24,10 @@ export const onChannelCreated = (callback: Amity.Listener<Amity.Channel>) => {
   const client = getActiveClient();
 
   const filter = (payload: Amity.ChannelPayload) => {
-    ingestInCache(payload);
-    callback(payload.channels[0]);
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0]);
   };
 
   return createEventSubscriber(client, 'onChannelCreated', 'v3.channel.didCreate', filter);

package/src/channel/events/onChannelDeleted.ts

@@ -3,6 +3,8 @@ import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { onChannelDeleted } from '@amityco/ts-sdk'
@@ -22,8 +24,10 @@ export const onChannelDeleted = (callback: Amity.Listener<Amity.Channel>) => {
   const client = getActiveClient();
 
   const filter = (payload: Amity.ChannelPayload) => {
-    ingestInCache(payload);
-    callback(payload.channels[0]);
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0]);
   };
 
   return createEventSubscriber(client, 'onChannelDeleted', 'v3.channel.didDelete', filter);

package/src/channel/events/onChannelJoined.ts

@@ -3,6 +3,8 @@ import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { onChannelJoined } from '@amityco/ts-sdk'
@@ -22,8 +24,10 @@ export const onChannelJoined = (callback: Amity.Listener<Amity.Channel>) => {
   const client = getActiveClient();
 
   const filter = (payload: Amity.ChannelPayload) => {
-    ingestInCache(payload);
-    callback(payload.channels[0]);
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0]);
   };
 
   return createEventSubscriber(client, 'onChannelJoined', 'v3.channel.didJoin', filter);

package/src/channel/events/onChannelLeft.ts

@@ -3,6 +3,8 @@ import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { onChannelLeft } from '@amityco/ts-sdk'
@@ -22,8 +24,10 @@ export const onChannelLeft = (callback: Amity.Listener<Amity.Channel>) => {
   const client = getActiveClient();
 
   const filter = (payload: Amity.ChannelPayload) => {
-    ingestInCache(payload);
-    callback(payload.channels[0]);
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0]);
   };
 
   return createEventSubscriber(client, 'onChannelLeft', 'v3.channel.didLeave', filter);

package/src/channel/events/onChannelMemberAdded.ts

@@ -0,0 +1,36 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onChannelMemberAdded } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberAdded((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been added to any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelMemberAdded = (
+  callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.ChannelMembershipPayload) => {
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0], data.channelUsers[0]);
+  };
+
+  return createEventSubscriber(client, 'onChannelMemberAdded', 'v3.channel.didAddUsers', filter);
+};

package/src/channel/events/onChannelMemberRemoved.ts

@@ -0,0 +1,41 @@
+import { getActiveClient } from '~/client/api';
+import { createEventSubscriber } from '~/core/events';
+
+import { ingestInCache } from '~/cache/api/ingestInCache';
+
+import { prepareChannelPayload } from '../utils';
+
+/**
+ * ```js
+ * import { onChannelMemberRemoved } from '@amityco/ts-sdk'
+ * const dispose = onChannelMemberRemoved((channel, member) => {
+ *   // ...
+ * })
+ * ```
+ *
+ * Fired when any {@link Amity.User} has been removed from any {@link Amity.Channel}
+ *
+ * @param callback The function to call when the event was fired
+ * @returns an {@link Amity.Unsubscriber} function to stop listening
+ *
+ * @category Channel Events
+ */
+export const onChannelMemberRemoved = (
+  callback: (channel: Amity.Channel, member: Amity.Membership<'channel'>) => void,
+) => {
+  const client = getActiveClient();
+
+  const filter = (payload: Amity.ChannelMembershipPayload) => {
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0], data.channelUsers[0]);
+  };
+
+  return createEventSubscriber(
+    client,
+    'onChannelMemberRemoved',
+    'v3.channel.didRemoveUsers',
+    filter,
+  );
+};

package/src/channel/events/onChannelUpdated.ts

@@ -3,6 +3,8 @@ import { createEventSubscriber } from '~/core/events';
 
 import { ingestInCache } from '~/cache/api/ingestInCache';
 
+import { prepareChannelPayload } from '../utils';
+
 /**
  * ```js
  * import { onChannelUpdated } from '@amityco/ts-sdk'
@@ -22,8 +24,10 @@ export const onChannelUpdated = (callback: Amity.Listener<Amity.Channel>) => {
   const client = getActiveClient();
 
   const filter = (payload: Amity.ChannelPayload) => {
-    ingestInCache(payload);
-    callback(payload.channels[0]);
+    const data = prepareChannelPayload(payload);
+
+    ingestInCache(data);
+    callback(data.channels[0]);
   };
 
   return createEventSubscriber(client, 'onChannelUpdated', 'v3.channel.didUpdate', filter);

package/src/channel/observers/index.ts

@@ -1 +1,3 @@
 export * from './observeChannel';
+export * from './observeChannels';
+export * from './liveChannels';

package/src/channel/observers/liveChannels.ts

@@ -0,0 +1,178 @@
+/* eslint-disable no-use-before-define */
+import { getResolver } from '~/core/model';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { getActiveClient } from '~/client/api';
+import {
+  createQuery,
+  runQuery,
+  queryOptions,
+  filterByPropEquality,
+  sortByLastCreated,
+  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';
+
+/**
+ * ```js
+ * import { liveChannels } from '@amityco/ts-sdk'
+ *
+ * let channels = []
+ * const unsub = liveChannels({
+ *   displayName: Amity.Channel['displayName'],
+ * }, response => merge(channels, response.data))
+ * ```
+ *
+ * Observe all mutations on a list of {@link Amity.Channel}s
+ *
+ * @param params for querying channels
+ * @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 channels
+ *
+ * @category Channel Live Collection
+ */
+export const liveChannels = (
+  params: Amity.ChannelLiveCollection,
+  callback: Amity.LiveCollectionCallback<Amity.Channel>,
+  config?: Amity.LiveCollectionConfig,
+) => {
+  const { log, cache } = getActiveClient();
+
+  if (!cache) {
+    console.log(ENABLE_CACHE_MESSAGE);
+  }
+
+  const timestamp = Date.now();
+  log(`liveChannels(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[] = [];
+  const cacheKey = ['channel', 'collection', {}];
+
+  const responder = (data: Amity.ChannelLiveCollectionCache) => {
+    let channels: Amity.Channel[] =
+      data.data
+        .map(channelId => pullFromCache<Amity.Channel>(['channel', 'get', channelId])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [];
+
+    channels = filterByPropEquality(channels, 'isDeleted', params.isDeleted);
+    channels = filterByPropEquality(channels, 'displayName', params.displayName);
+
+    if (params.types) {
+      channels = channels.filter(c => params.types?.includes(c.type));
+    }
+
+    if (params.tags) {
+      channels = channels.filter(c => c.tags?.some(t => params.tags?.includes(t)));
+    }
+
+    if (params.excludeTags) {
+      channels = channels.filter(c => !c.tags?.some(t => params.excludeTags?.includes(t)));
+    }
+
+    const sortBy = params.sortBy || 'lastCreated';
+
+    if (sortBy === 'lastCreated' || sortBy === 'firstCreated') {
+      channels = channels.sort(sortBy === 'lastCreated' ? sortByLastCreated : sortByFirstCreated);
+    }
+
+    /*
+     * The server returns channels with empty | null displayName's first before
+     * returning sorted list of channels with displayNames
+     *
+     * This section needs to be updated as displayNames can be null as well
+     */
+    if (sortBy === 'displayName') {
+      channels = channels
+        // this needs to be aligned with the backend data type
+        .map(c => (c.displayName ? c : { ...c, displayName: '' }))
+        // @ts-ignore
+        .sort(sortByDisplayName);
+    }
+
+    callback({
+      onNextPage: onFetch,
+      data: channels,
+      hasNextPage: !!data.params?.page,
+      loading: data.loading,
+      error: data.error,
+    });
+  };
+
+  const realtimeRouter = (channel: Amity.Channel, action: Amity.ChannelActionType) => {
+    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) {
+      collection.data = collection.data.filter(c => c !== channel.channelId);
+    }
+
+    pushToCache(cacheKey, collection);
+    responder(collection);
+  };
+
+  const onFetch = () => {
+    const collection = pullFromCache<Amity.ChannelLiveCollectionCache>(cacheKey)?.data;
+
+    const channels = collection?.data ?? [];
+
+    if (channels.length > 0 && !collection?.params.page) return;
+
+    const query = createQuery(queryChannels, {
+      ...queryParams,
+      page: collection?.params.page ?? { limit },
+    });
+
+    runQuery(
+      query,
+      ({ data: result, error, loading, nextPage: page }) => {
+        const data = {
+          loading,
+          error,
+          params: { page },
+          data: channels,
+        };
+
+        if (result) {
+          data.data = [...new Set([...channels, ...result.map(getResolver('channel'))])];
+        }
+
+        pushToCache(cacheKey, data);
+
+        responder(data);
+      },
+      queryOptions(policy),
+    );
+  };
+
+  disposers.push(
+    onChannelCreated(channel => realtimeRouter(channel, 'onCreate')),
+    onChannelDeleted(channel => realtimeRouter(channel, 'onDelete')),
+    onChannelUpdated(channel => realtimeRouter(channel, 'onUpdate')),
+  );
+
+  onFetch();
+
+  return () => {
+    log(`liveChannels(tmpid: ${timestamp}) > dispose`);
+    disposers.forEach(fn => fn());
+  };
+};

package/src/channel/observers/observeChannel.ts

@@ -9,8 +9,8 @@ import {
   onChannelDeleted,
   onChannelJoined,
   onChannelLeft,
-  onMemberAdded,
-  onMemberRemoved,
+  onChannelMemberAdded,
+  onChannelMemberRemoved,
 } from '../events';
 
 /**
@@ -29,17 +29,7 @@ import {
  *
  * @category Channel Observer
  */
-export const observeChannel = <
-  Events extends [
-    'onFetch',
-    'onUpdate',
-    'onDelete',
-    'onJoin',
-    'onLeft',
-    'onMemberAdded',
-    'onMemberRemoved',
-  ],
->(
+export const observeChannel = <Events extends [Exclude<Amity.ChannelActionType, 'onCreate'>]>(
   channelId: string,
   callback: Amity.ObjectListener<Amity.Snapshot<Amity.Channel>, Events>,
 ): Amity.Unsubscriber => {
@@ -67,8 +57,12 @@ export const observeChannel = <
     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')),
-    onMemberAdded(data => router({ data, loading: false, origin: 'event' }, 'onMemberAdded')),
-    onMemberRemoved(data => router({ data, loading: false, origin: 'event' }, 'onMemberRemoved')),
+    onChannelMemberAdded(data =>
+      router({ data, loading: false, origin: 'event' }, 'onMemberAdded'),
+    ),
+    onChannelMemberRemoved(data =>
+      router({ data, loading: false, origin: 'event' }, 'onMemberRemoved'),
+    ),
   );
 
   runQuery(createQuery(getChannel, channelId), result => result.data && router(result, 'onFetch'));