stream-chat 9.50.2 → 10.0.0-rc.1

package/src/channel_batch_updater.ts

@@ -1,211 +1 @@
-import type { StreamChat } from './client';
-import type {
-  APIResponse,
-  BatchChannelDataUpdate,
-  NewMemberPayload,
-  UpdateChannelsBatchFilters,
-  UpdateChannelsBatchResponse,
-} from './types';
-
-/**
- * ChannelBatchUpdater - A class that provides convenience methods for batch channel operations
- */
-export class ChannelBatchUpdater {
-  client: StreamChat;
-
-  constructor(client: StreamChat) {
-    this.client = client;
-  }
-
-  // Member operations
-
-  /**
-   * addMembers - Add members to channels matching the filter
-   *
-   * @param {UpdateChannelsBatchFilters} filter Filter to select channels
-   * @param {string[] | NewMemberPayload[]} members Members to add
-   * @return {Promise<APIResponse & UpdateChannelsBatchResponse>} The server response
-   */
-  async addMembers(
-    filter: UpdateChannelsBatchFilters,
-    members: string[] | NewMemberPayload[],
-  ): Promise<APIResponse & UpdateChannelsBatchResponse> {
-    return await this.client.updateChannelsBatch({
-      operation: 'addMembers',
-      filter,
-      members,
-    });
-  }
-
-  /**
-   * removeMembers - Remove members from channels matching the filter
-   *
-   * @param {UpdateChannelsBatchFilters} filter Filter to select channels
-   * @param {string[]} members Member IDs to remove
-   * @return {Promise<APIResponse & UpdateChannelsBatchResponse>} The server response
-   */
-  async removeMembers(
-    filter: UpdateChannelsBatchFilters,
-    members: string[],
-  ): Promise<APIResponse & UpdateChannelsBatchResponse> {
-    return await this.client.updateChannelsBatch({
-      operation: 'removeMembers',
-      filter,
-      members,
-    });
-  }
-
-  /**
-   * inviteMembers - Invite members to channels matching the filter
-   *
-   * @param {UpdateChannelsBatchFilters} filter Filter to select channels
-   * @param {string[] | NewMemberPayload[]} members Members to invite
-   * @return {Promise<APIResponse & UpdateChannelsBatchResponse>} The server response
-   */
-  async inviteMembers(
-    filter: UpdateChannelsBatchFilters,
-    members: string[] | NewMemberPayload[],
-  ): Promise<APIResponse & UpdateChannelsBatchResponse> {
-    return await this.client.updateChannelsBatch({
-      operation: 'inviteMembers',
-      filter,
-      members,
-    });
-  }
-
-  /**
-   * addModerators - Add moderators to channels matching the filter
-   *
-   * @param {UpdateChannelsBatchFilters} filter Filter to select channels
-   * @param {string[]} members Member IDs to promote to moderator
-   * @return {Promise<APIResponse & UpdateChannelsBatchResponse>} The server response
-   */
-  async addModerators(
-    filter: UpdateChannelsBatchFilters,
-    members: string[],
-  ): Promise<APIResponse & UpdateChannelsBatchResponse> {
-    return await this.client.updateChannelsBatch({
-      operation: 'addModerators',
-      filter,
-      members,
-    });
-  }
-
-  /**
-   * demoteModerators - Remove moderator role from members in channels matching the filter
-   *
-   * @param {UpdateChannelsBatchFilters} filter Filter to select channels
-   * @param {string[]} members Member IDs to demote
-   * @return {Promise<APIResponse & UpdateChannelsBatchResponse>} The server response
-   */
-  async demoteModerators(
-    filter: UpdateChannelsBatchFilters,
-    members: string[],
-  ): Promise<APIResponse & UpdateChannelsBatchResponse> {
-    return await this.client.updateChannelsBatch({
-      operation: 'demoteModerators',
-      filter,
-      members,
-    });
-  }
-
-  /**
-   * assignRoles - Assign roles to members in channels matching the filter
-   *
-   * @param {UpdateChannelsBatchFilters} filter Filter to select channels
-   * @param {NewMemberPayload[]} members Members with role assignments
-   * @return {Promise<APIResponse & UpdateChannelsBatchResponse>} The server response
-   */
-  async assignRoles(
-    filter: UpdateChannelsBatchFilters,
-    members: NewMemberPayload[],
-  ): Promise<APIResponse & UpdateChannelsBatchResponse> {
-    return await this.client.updateChannelsBatch({
-      operation: 'assignRoles',
-      filter,
-      members,
-    });
-  }
-
-  // Visibility operations
-
-  /**
-   * hide - Hide channels matching the filter
-   *
-   * @param {UpdateChannelsBatchFilters} filter Filter to select channels
-   * @return {Promise<APIResponse & UpdateChannelsBatchResponse>} The server response
-   */
-  async hide(
-    filter: UpdateChannelsBatchFilters,
-  ): Promise<APIResponse & UpdateChannelsBatchResponse> {
-    return await this.client.updateChannelsBatch({
-      operation: 'hide',
-      filter,
-    });
-  }
-
-  /**
-   * show - Show channels matching the filter
-   *
-   * @param {UpdateChannelsBatchFilters} filter Filter to select channels
-   * @return {Promise<APIResponse & UpdateChannelsBatchResponse>} The server response
-   */
-  async show(
-    filter: UpdateChannelsBatchFilters,
-  ): Promise<APIResponse & UpdateChannelsBatchResponse> {
-    return await this.client.updateChannelsBatch({
-      operation: 'show',
-      filter,
-    });
-  }
-
-  /**
-   * archive - Archive channels matching the filter
-   *
-   * @param {UpdateChannelsBatchFilters} filter Filter to select channels
-   * @return {Promise<APIResponse & UpdateChannelsBatchResponse>} The server response
-   */
-  async archive(
-    filter: UpdateChannelsBatchFilters,
-  ): Promise<APIResponse & UpdateChannelsBatchResponse> {
-    return await this.client.updateChannelsBatch({
-      operation: 'archive',
-      filter,
-    });
-  }
-
-  /**
-   * unarchive - Unarchive channels matching the filter
-   *
-   * @param {UpdateChannelsBatchFilters} filter Filter to select channels
-   * @return {Promise<APIResponse & UpdateChannelsBatchResponse>} The server response
-   */
-  async unarchive(
-    filter: UpdateChannelsBatchFilters,
-  ): Promise<APIResponse & UpdateChannelsBatchResponse> {
-    return await this.client.updateChannelsBatch({
-      operation: 'unarchive',
-      filter,
-    });
-  }
-
-  // Data operations
-
-  /**
-   * updateData - Update data on channels matching the filter
-   *
-   * @param {UpdateChannelsBatchFilters} filter Filter to select channels
-   * @param {BatchChannelDataUpdate} data Data to update
-   * @return {Promise<APIResponse & UpdateChannelsBatchResponse>} The server response
-   */
-  async updateData(
-    filter: UpdateChannelsBatchFilters,
-    data: BatchChannelDataUpdate,
-  ): Promise<APIResponse & UpdateChannelsBatchResponse> {
-    return await this.client.updateChannelsBatch({
-      operation: 'updateData',
-      filter,
-      data,
-    });
-  }
-}
+// ChannelBatchUpdater functionality has been moved to the server-side SDK.

package/src/channel_manager.ts

@@ -1,12 +1,14 @@
 import type { QueryChannelsResponseWithChannels, StreamChat } from './client';
 import type {
   ChannelFilters,
-  ChannelOptions,
   ChannelSort,
   ChannelStateOptions,
   Event,
-  QueryChannelsAPIResponse,
+  EventPayload,
+  QueryChannelsRequest,
+  QueryChannelsResponse,
 } from './types';
+import { chatLoggerSystem } from './logger';
 import type { ValueOrPatch } from './store';
 import { isPatch, StateStore } from './store';
 import type { Channel } from './channel';
@@ -29,15 +31,15 @@ import {
 } from './constants';
 import { WithSubscriptions } from './utils/WithSubscriptions';
 
+const logger = chatLoggerSystem.getLogger('channel-manager');
+
 export type ChannelManagerPagination = {
-  filters: ChannelFilters;
   hasNext: boolean;
   isLoading: boolean;
   isLoadingNext: boolean;
-  options: ChannelOptions;
-  responseFilters?: ChannelFilters;
-  responseSort?: ChannelSort;
-  sort: ChannelSort;
+  options?: QueryChannelsRequest;
+  responseFilters?: QueryChannelsRequest['filter_conditions'];
+  responseSort?: QueryChannelsRequest['sort'];
 };
 
 export type ChannelManagerState = {
@@ -56,9 +58,7 @@ export type ChannelManagerState = {
 export type ChannelSetterParameterType = ValueOrPatch<ChannelManagerState['channels']>;
 export type ChannelSetterType = (arg: ChannelSetterParameterType) => void;
 
-export type GenericEventHandlerType<T extends unknown[]> = (
-  ...args: T
-) => void | (() => void) | ((...args: T) => Promise<void>) | Promise<void>;
+export type GenericEventHandlerType<T extends unknown[]> = (...args: T) => any;
 export type EventHandlerType = GenericEventHandlerType<[Event]>;
 export type EventHandlerOverrideType = GenericEventHandlerType<
   [ChannelSetterType, Event]
@@ -92,10 +92,9 @@ export type ChannelManagerEventHandlerOverrides = Partial<
   Record<ChannelManagerEventHandlerNames, EventHandlerOverrideType>
 >;
 
-export type ExecuteChannelsQueryPayload = Pick<
-  ChannelManagerPagination,
-  'filters' | 'sort' | 'options'
-> & { stateOptions: ChannelStateOptions };
+export type ExecuteChannelsQueryPayload = Pick<ChannelManagerPagination, 'options'> & {
+  stateOptions: ChannelStateOptions;
+};
 
 export const channelManagerEventToHandlerMapping: {
   [key in ChannelManagerEventTypes]: ChannelManagerEventHandlerNames;
@@ -139,9 +138,7 @@ export type ChannelManagerOptions = {
 export type QueryChannelsRequestOutput = Channel[] | QueryChannelsResponseWithChannels;
 
 export type QueryChannelsRequestType = (
-  filters: ChannelFilters,
-  sort?: ChannelSort,
-  options?: ChannelOptions,
+  options?: QueryChannelsRequest,
   stateOptions?: ChannelStateOptions,
 ) => Promise<QueryChannelsRequestOutput>;
 
@@ -160,18 +157,11 @@ export const DEFAULT_CHANNEL_MANAGER_PAGINATION_OPTIONS = {
   offset: 0,
 };
 
-const mapPredefinedFilterSortToChannelSort = (
-  sort: NonNullable<QueryChannelsAPIResponse['predefined_filter']>['sort'],
-): ChannelSort =>
-  (sort ?? []).map(({ direction = 1, field }) => ({
-    [field]: direction,
-  })) as ChannelSort;
-
 const getResponsePaginationParams = ({
   queryChannelsResponse,
   sort,
 }: {
-  queryChannelsResponse?: Pick<QueryChannelsAPIResponse, 'predefined_filter'>;
+  queryChannelsResponse?: Pick<QueryChannelsResponse, 'predefined_filter'>;
   sort: ChannelSort;
 }): Pick<ChannelManagerPagination, 'responseFilters' | 'responseSort'> => {
   const predefinedFilter = queryChannelsResponse?.predefined_filter;
@@ -182,18 +172,13 @@ const getResponsePaginationParams = ({
 
   return {
     responseFilters: predefinedFilter.filter as ChannelFilters,
-    responseSort:
-      predefinedFilter.sort !== undefined
-        ? mapPredefinedFilterSortToChannelSort(predefinedFilter.sort)
-        : sort,
+    responseSort: predefinedFilter.sort ?? sort,
   };
 };
 
-const getResponseFiltersAndSort = (
-  pagination: ChannelManagerPagination,
-): Pick<ChannelManagerPagination, 'filters' | 'sort'> => ({
-  filters: pagination.responseFilters ?? pagination.filters,
-  sort: pagination.responseSort ?? pagination.sort,
+const getResponseFiltersAndSort = (pagination: ChannelManagerPagination) => ({
+  filters: pagination.responseFilters ?? pagination.options?.filter_conditions,
+  sort: pagination.responseSort ?? pagination.options?.sort,
 });
 
 const omitResponsePaginationParams = (pagination: ChannelManagerPagination) => {
@@ -245,8 +230,6 @@ export class ChannelManager extends WithSubscriptions {
         isLoading: false,
         isLoadingNext: false,
         hasNext: false,
-        filters: {},
-        sort: {},
         options: DEFAULT_CHANNEL_MANAGER_PAGINATION_OPTIONS,
       },
       initialized: false,
@@ -255,7 +238,8 @@ export class ChannelManager extends WithSubscriptions {
     this.setEventHandlerOverrides(eventHandlerOverrides);
     this.setOptions(options);
     this.queryChannelsRequest =
-      queryChannelsOverride ?? ((...params) => this.client.queryChannels(...params));
+      queryChannelsOverride ??
+      ((...params) => this.client.queryChannelsAndHydrate(...params));
     this.eventHandlers = new Map(
       Object.entries<EventHandlerType>({
         channelDeletedHandler: this.channelDeletedHandler,
@@ -287,15 +271,22 @@ export class ChannelManager extends WithSubscriptions {
     });
     const {
       channels,
-      pagination: { filters, options, sort },
+      pagination: { options },
     } = this.state.getLatestValue();
     this.client.offlineDb?.executeQuerySafely(
       (db) =>
+        // TODO: filters/sort must be passed explicitly (even though they live inside `options`)
+        // because `convertFilterSortToQuery` keys the offline query off the top-level filters/sort
+        // args, not `options.filter_conditions`/`options.sort`. Omitting them here writes reorders
+        // to a mismatched cache key, so the persisted channel order goes stale until a full requery.
+        // Proper fix: make `convertFilterSortToQuery` derive filters/sort from `options` so no call
+        // site has to pass them redundantly (requires a DB schema-version bump to flush stale
+        // `channelQueries` rows keyed by the old format).
         db.upsertCidsForQuery({
           cids: channels.map((channel) => channel.cid),
-          filters,
+          filters: options?.filter_conditions,
           options,
-          sort,
+          sort: options?.sort,
         }),
       { method: 'upsertCidsForQuery' },
     );
@@ -329,18 +320,16 @@ export class ChannelManager extends WithSubscriptions {
     payload: ExecuteChannelsQueryPayload,
     retryCount = 0,
   ): Promise<void> => {
-    const { filters, sort, options, stateOptions } = payload;
+    const { options, stateOptions } = payload;
     const { offset, limit } = {
       ...DEFAULT_CHANNEL_MANAGER_PAGINATION_OPTIONS,
       ...options,
     };
     try {
-      const queryChannelsResponse = await this.queryChannelsRequest(
-        filters,
-        sort,
-        options,
-        { ...stateOptions, withResponse: true },
-      );
+      const queryChannelsResponse = await this.queryChannelsRequest(options, {
+        ...stateOptions,
+        withResponse: true,
+      });
       const channels = isQueryChannelsResponseWithChannels(queryChannelsResponse)
         ? queryChannelsResponse.channels
         : queryChannelsResponse;
@@ -351,7 +340,7 @@ export class ChannelManager extends WithSubscriptions {
         queryChannelsResponse: isQueryChannelsResponseWithChannels(queryChannelsResponse)
           ? queryChannelsResponse
           : undefined,
-        sort,
+        sort: options?.sort ?? [],
       });
       const paginationWithoutResponseParams = omitResponsePaginationParams(pagination);
 
@@ -376,18 +365,22 @@ export class ChannelManager extends WithSubscriptions {
         (db) =>
           db.upsertCidsForQuery({
             cids: channels.map((channel) => channel.cid),
-            filters: pagination.filters,
+            filters: pagination.options?.filter_conditions,
             options,
-            sort: pagination.sort,
+            sort: pagination.options?.sort,
           }),
         { method: 'upsertCidsForQuery' },
       );
-    } catch (err) {
+    } catch (error) {
       if (retryCount >= DEFAULT_QUERY_CHANNELS_RETRY_COUNT) {
-        console.warn(err);
+        logger
+          .withExtraTags('executeChannelsQuery')
+          .error('Failed to query channels after the maximum number of retries.', {
+            error,
+          });
 
         const wrappedError = new Error(
-          `Maximum number of retries reached in queryChannels. Last error message is: ${err}`,
+          `Maximum number of retries reached in queryChannels. Last error message is: ${error}`,
         );
 
         const state = this.state.getLatestValue();
@@ -413,13 +406,11 @@ export class ChannelManager extends WithSubscriptions {
   };
 
   public queryChannels = async (
-    filters: ChannelFilters,
-    sort: ChannelSort = [],
-    options: ChannelOptions = {},
+    request?: QueryChannelsRequest,
     stateOptions: ChannelStateOptions = {},
   ) => {
     const {
-      pagination: { isLoading, filters: filtersFromState },
+      pagination: { isLoading, options: optionsFromState },
       initialized,
     } = this.state.getLatestValue();
 
@@ -428,12 +419,18 @@ export class ChannelManager extends WithSubscriptions {
       !this.options.abortInFlightQuery &&
       // TODO: Figure a proper way to either deeply compare these or
       //       create hashes from each.
-      JSON.stringify(filtersFromState) === JSON.stringify(filters)
+      JSON.stringify(optionsFromState?.filter_conditions) ===
+        JSON.stringify(request?.filter_conditions)
     ) {
       return;
     }
 
-    const executeChannelsQueryPayload = { filters, sort, options, stateOptions };
+    const executeChannelsQueryPayload = {
+      filters: request?.filter_conditions,
+      sort: request?.sort,
+      options: request,
+      stateOptions,
+    };
 
     try {
       this.stateOptions = stateOptions;
@@ -443,9 +440,7 @@ export class ChannelManager extends WithSubscriptions {
           ...omitResponsePaginationParams(currentState.pagination),
           isLoading: true,
           isLoadingNext: false,
-          filters,
-          sort,
-          options,
+          options: request,
         },
         error: undefined,
       }));
@@ -454,9 +449,7 @@ export class ChannelManager extends WithSubscriptions {
         if (!initialized) {
           const channelsFromDB = await this.client.offlineDb.getChannelsForQuery({
             userId: this.client.user.id,
-            filters,
-            options,
-            sort,
+            options: request,
           });
 
           if (channelsFromDB) {
@@ -481,7 +474,7 @@ export class ChannelManager extends WithSubscriptions {
       }
       await this.executeChannelsQuery(executeChannelsQueryPayload);
     } catch (error) {
-      this.client.logger('error', (error as Error).message);
+      logger.withExtraTags('queryChannels').error('Failed to query channels.', { error });
       this.state.next((currentState) => ({
         ...currentState,
         pagination: { ...currentState.pagination, isLoading: false },
@@ -492,7 +485,7 @@ export class ChannelManager extends WithSubscriptions {
 
   public loadNext = async () => {
     const { pagination, initialized } = this.state.getLatestValue();
-    const { filters, sort, options, isLoadingNext, hasNext } = pagination;
+    const { options, isLoadingNext, hasNext } = pagination;
 
     if (!initialized || isLoadingNext || !hasNext) {
       return;
@@ -507,8 +500,6 @@ export class ChannelManager extends WithSubscriptions {
         pagination: { ...pagination, isLoading: false, isLoadingNext: true },
       });
       const queryChannelsResponse = await this.queryChannelsRequest(
-        filters,
-        sort,
         options,
         this.stateOptions,
       );
@@ -530,7 +521,9 @@ export class ChannelManager extends WithSubscriptions {
         },
       });
     } catch (error) {
-      this.client.logger('error', (error as Error).message);
+      logger
+        .withExtraTags('loadNext')
+        .error('Failed to load the next page of channels.', { error });
       this.state.next((currentState) => ({
         ...currentState,
         pagination: {
@@ -543,7 +536,8 @@ export class ChannelManager extends WithSubscriptions {
     }
   };
 
-  private notificationAddedToChannelHandler = async (event: Event) => {
+  private notificationAddedToChannelHandler = async (event_: Event) => {
+    const event = event_ as EventPayload<'notification.added_to_channel'>;
     const { id, type, members } = event?.channel ?? {};
 
     if (
@@ -573,7 +567,7 @@ export class ChannelManager extends WithSubscriptions {
       return;
     }
 
-    const { sort } = getResponseFiltersAndSort(pagination);
+    const { sort = [] } = getResponseFiltersAndSort(pagination);
 
     this.setChannels(
       promoteChannel({
@@ -584,7 +578,11 @@ export class ChannelManager extends WithSubscriptions {
     );
   };
 
-  private channelDeletedHandler = (event: Event) => {
+  private channelDeletedHandler = (event_: Event) => {
+    const event = event_ as EventPayload<
+      'channel.deleted' | 'channel.hidden' | 'notification.removed_from_channel'
+    >;
+
     const { channels } = this.state.getLatestValue();
     if (!channels) {
       return;
@@ -605,12 +603,14 @@ export class ChannelManager extends WithSubscriptions {
 
   private channelHiddenHandler = this.channelDeletedHandler;
 
-  private newMessageHandler = (event: Event) => {
+  private newMessageHandler = (event_: Event) => {
+    const event = event_ as EventPayload<'message.new'>;
+
     const { pagination, channels } = this.state.getLatestValue();
     if (!channels) {
       return;
     }
-    const { filters, sort } = getResponseFiltersAndSort(pagination);
+    const { filters, sort = [] } = getResponseFiltersAndSort(pagination);
 
     const channelType = event.channel_type;
     const channelId = event.channel_id;
@@ -631,9 +631,9 @@ export class ChannelManager extends WithSubscriptions {
 
     if (
       // filter is defined, target channel is archived and filter option is set to false
-      (considerArchivedChannels && isTargetChannelArchived && !filters.archived) ||
+      (considerArchivedChannels && isTargetChannelArchived && !filters?.archived) ||
       // filter is defined, target channel isn't archived and filter option is set to true
-      (considerArchivedChannels && !isTargetChannelArchived && filters.archived) ||
+      (considerArchivedChannels && !isTargetChannelArchived && filters?.archived) ||
       // sort option is defined, target channel is pinned
       (considerPinnedChannels && isTargetChannelPinned) ||
       // list order is locked
@@ -655,7 +655,9 @@ export class ChannelManager extends WithSubscriptions {
     );
   };
 
-  private notificationNewMessageHandler = async (event: Event) => {
+  private notificationNewMessageHandler = async (event_: Event) => {
+    const event = event_ as EventPayload<'notification.message_new'>;
+
     const { id, type } = event?.channel ?? {};
 
     if (!id || !type) {
@@ -669,15 +671,15 @@ export class ChannelManager extends WithSubscriptions {
     });
 
     const { channels, pagination } = this.state.getLatestValue();
-    const { filters, sort } = getResponseFiltersAndSort(pagination);
+    const { filters, sort = [] } = getResponseFiltersAndSort(pagination);
 
     const considerArchivedChannels = shouldConsiderArchivedChannels(filters);
     const isTargetChannelArchived = isChannelArchived(channel);
 
     if (
       !channels ||
-      (considerArchivedChannels && isTargetChannelArchived && !filters.archived) ||
-      (considerArchivedChannels && !isTargetChannelArchived && filters.archived) ||
+      (considerArchivedChannels && isTargetChannelArchived && !filters?.archived) ||
+      (considerArchivedChannels && !isTargetChannelArchived && filters?.archived) ||
       !this.options.allowNotLoadedChannelPromotionForEvent?.['notification.message_new']
     ) {
       return;
@@ -692,7 +694,8 @@ export class ChannelManager extends WithSubscriptions {
     );
   };
 
-  private channelVisibleHandler = async (event: Event) => {
+  private channelVisibleHandler = async (event_: Event) => {
+    const event = event_ as EventPayload<'channel.visible' | 'channel.hidden'>;
     const { channel_type: channelType, channel_id: channelId } = event;
 
     if (!channelType || !channelId) {
@@ -706,15 +709,15 @@ export class ChannelManager extends WithSubscriptions {
     });
 
     const { channels, pagination } = this.state.getLatestValue();
-    const { filters, sort } = getResponseFiltersAndSort(pagination);
+    const { filters, sort = [] } = getResponseFiltersAndSort(pagination);
 
     const considerArchivedChannels = shouldConsiderArchivedChannels(filters);
     const isTargetChannelArchived = isChannelArchived(channel);
 
     if (
       !channels ||
-      (considerArchivedChannels && isTargetChannelArchived && !filters.archived) ||
-      (considerArchivedChannels && !isTargetChannelArchived && filters.archived) ||
+      (considerArchivedChannels && isTargetChannelArchived && !filters?.archived) ||
+      (considerArchivedChannels && !isTargetChannelArchived && filters?.archived) ||
       !this.options.allowNotLoadedChannelPromotionForEvent?.['channel.visible']
     ) {
       return;
@@ -731,12 +734,13 @@ export class ChannelManager extends WithSubscriptions {
 
   private notificationRemovedFromChannelHandler = this.channelDeletedHandler;
 
-  private memberUpdatedHandler = (event: Event) => {
+  private memberUpdatedHandler = (event_: Event) => {
+    const event = event_ as EventPayload<'member.updated'>;
     const { pagination, channels } = this.state.getLatestValue();
-    const { filters, sort } = getResponseFiltersAndSort(pagination);
+    const { filters, sort = [] } = getResponseFiltersAndSort(pagination);
     if (
       !event.member?.user ||
-      event.member.user.id !== this.client.userID ||
+      event.member.user.id !== this.client.userId ||
       !event.channel_type ||
       !event.channel_id
     ) {