@amityco/ts-sdk 6.29.2 → 6.29.3-9895419.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amityco/ts-sdk",
-  "version": "6.29.2",
+  "version": "6.29.3-9895419.0",
   "license": "CC-BY-ND-4.0",
   "author": "amity.co <developers@amity.co> (https://amity.co)",
   "description": "Amity Social Cloud Typescript SDK",

package/src/@types/core/model.ts

@@ -52,6 +52,9 @@ declare global {
 
       ad: Amity.InternalAd;
       advertiser: Amity.InternalAdvertiser;
+
+      pinTarget: Amity.InternalPinTarget;
+      pin: Amity.InternalPin;
     };
 
     type Model = ValueOf<Models>;
@@ -108,6 +111,9 @@ declare global {
 
       ad: Pick<Amity.InternalAd, 'adId'>;
       advertiser: Pick<Amity.Advertiser, 'advertiserId'>;
+
+      pinTarget: Pick<Amity.InternalPinTarget, 'targetId'>;
+      pin: Pick<Amity.InternalPin, 'referenceId'>;
     };
   }
 }

package/src/@types/core/payload.ts

@@ -20,9 +20,15 @@ declare global {
       story: Amity.StoryPayload;
       globalStoryFeed: Amity.GlobalStoryFeedPayload;
       reaction: Amity.ReactionPayload;
+      pinnedPost: Amity.PinnedPostPayload;
     };
 
     type UserPayload = {
+      users: Amity.RawUser[];
+      files: Amity.File<'image'>[];
+    };
+
+    type ProcessedUserPayload = {
       users: Amity.InternalUser[];
       files: Amity.File<'image'>[];
     };
@@ -49,12 +55,12 @@ declare global {
       roles: Amity.Role[];
     };
 
-    type ChannelPayload<T extends Amity.ChannelType = any> = {
+    type ChannelPayload<T extends Amity.ChannelType = any> = Amity.UserPayload & {
       channels: Amity.RawChannel<T>[];
       channelUsers: Amity.RawMembership<'channel'>[];
       messagePreviews: Amity.MessagePreviewPayload[];
       messageFeedsInfo?: Amity.messageFeedsInfoPayload[];
-    } & Amity.UserPayload;
+    };
 
     /**
      * Items that extend from `Amity.Channel`
@@ -63,10 +69,11 @@ declare global {
      */
     type ProcessedChannelPayload<T extends Amity.ChannelType = any> = Omit<
       ChannelPayload,
-      'channels' | 'channelUsers' | 'messagePreviews' | 'messageFeedsInfo'
+      'channels' | 'channelUsers' | 'messagePreviews' | 'messageFeedsInfo' | 'users'
     > & {
       channels: Amity.InternalChannel<T>[];
       channelUsers: Amity.Membership<'channel'>[];
+      users: Amity.InternalUser[];
     };
 
     type UserMarkerResponse = Omit<Amity.UserMarker, 'hasMentioned'> & Amity.IsMentioned;
@@ -210,7 +217,8 @@ declare global {
       channels: Amity.RawChannel[];
       channelUsers: Amity.RawMembership<'channel'>[];
       messagePreviews: Amity.MessagePreviewPayload[];
-    } & Amity.UserPayload;
+      users: Amity.RawUser[];
+    } & Omit<Amity.UserPayload, 'users'>;
 
     /**
      * Items that extend from `Amity.ChannelMembershipPayload`
@@ -386,7 +394,9 @@ declare global {
       followCounts: Amity.FollowCount[];
     };
 
-    type FollowersPayload = Amity.FollowStatusPayload & UserPayload;
+    // TODO: apply Amity.RawUser type
+    type FollowersPayload = Amity.FollowStatusPayload &
+      Omit<Amity.UserPayload, 'users'> & { users: Amity.InternalUser[] };
 
     type FollowInfoPayload = FollowInfoMePayload & Amity.FollowStatusPayload;
 
@@ -395,9 +405,9 @@ declare global {
       followCounts: Amity.FollowCount[];
     };
 
+    // TODO: apply Amity.RawUser type
     type BlockedUserPayload = Amity.FollowStatusPayload[] &
-      Amity.UserPayload &
-      Amity.BlockedUserPaged;
+      Omit<Amity.UserPayload, 'users'> & { users: Amity.InternalUser[] } & Amity.BlockedUserPaged;
 
     type MessagePreviewPayload<T extends Amity.MessageContentType = any> = {
       messageId: string;

package/src/@types/domains/channel.ts

@@ -129,6 +129,7 @@ declare global {
       sortBy?: 'firstCreated' | 'lastCreated';
       search?: string;
       page?: Amity.Page;
+      includeDeleted?: boolean;
     };
 
     type SearchChannelMembers = Amity.LiveCollectionParams<Omit<QueryChannelMembers, 'sortBy'>>;
@@ -145,6 +146,18 @@ declare global {
       >
     >;
 
+    type SearchChannelMembersLiveCollection = Amity.LiveCollectionParams<
+      Omit<
+        SearchChannelMembers,
+        'page'
+        /**
+         * @remarks
+         * search will be deprecated in the next major version, please use `searchMembers()` instead.
+         *  | 'search'
+         */
+      >
+    >;
+
     type ChannelMembersLiveCollectionCache = Amity.LiveCollectionCache<
       Amity.Membership<'channel'>['userId'],
       Pick<QueryChannelMembers, 'page'>

package/src/@types/domains/comment.ts

@@ -15,13 +15,13 @@ declare global {
       | 'onReactionAdded'
       | 'onReactionRemoved';
 
-    type InternalComment<T extends CommentContentType = any> = {
+    type RawComment<T extends CommentContentType = any> = {
       commentId: string;
       userId: string;
-      parentId?: InternalComment['commentId'];
-      rootId: InternalComment['commentId'];
+      parentId?: RawComment['commentId'];
+      rootId: RawComment['commentId'];
       childrenNumber: number;
-      children: InternalComment['commentId'][];
+      children: RawComment['commentId'][];
       segmentNumber: number;
       editedAt: Amity.timestamp;
       attachments?: Amity.Attachment[];
@@ -37,6 +37,8 @@ declare global {
       Amity.Subscribable &
       Amity.Mentionable<'user'>;
 
+    type InternalComment<T extends CommentContentType = any> = RawComment<T>;
+
     type CommentTarget = {
       type: InternalComment['targetType'] | 'unknown';
       communityId?: Amity.Community['communityId'];

package/src/@types/domains/community.ts

@@ -23,6 +23,40 @@ export const DefaultCommunityPostSetting = 'ONLY_ADMIN_CAN_POST';
 
 declare global {
   namespace Amity {
+    const enum CommunitySortByEnum {
+      FirstCreated = 'firstCreated',
+      LastCreated = 'lastCreated',
+      /** @deprecated sortBy displayName is not available */
+      DisplayName = 'displayName',
+    }
+
+    type CommunitySortBy = `${Amity.CommunitySortByEnum}`;
+
+    const enum SearchCommunitySortByEnum {
+      FirstCreated = 'firstCreated',
+      LastCreated = 'lastCreated',
+      DisplayName = 'displayName',
+    }
+
+    type SearchCommunitySortBy = `${Amity.SearchCommunitySortByEnum}`;
+
+    const enum CommunityMemberSortByEnum {
+      FirstCreated = 'firstCreated',
+      LastCreated = 'lastCreated',
+      /** @deprecated sortBy displayName is not available */
+      DisplayName = 'displayName',
+    }
+
+    type CommunityMemberSortBy = `${Amity.CommunityMemberSortByEnum}`;
+
+    const enum SearchCommunityMemberSortByEnum {
+      FirstCreated = 'firstCreated',
+      LastCreated = 'lastCreated',
+      DisplayName = 'displayName',
+    }
+
+    type SearchCommunityMemberSortBy = `${Amity.SearchCommunityMemberSortByEnum}`;
+
     type CommunityActionType =
       | 'onCreate'
       | 'onUpdate'
@@ -81,11 +115,7 @@ declare global {
       categoryId?: Amity.InternalCategory['categoryId'];
       includeDeleted?: boolean;
       tags?: Amity.Taggable['tags'];
-      sortBy?:
-        | 'firstCreated'
-        | 'lastCreated'
-        /** @deprecated sortBy displayName is not available */
-        | 'displayName';
+      sortBy?: Amity.CommunitySortBy | Amity.CommunitySortByEnum;
       page?: string;
       limit?: number;
     };
@@ -96,7 +126,7 @@ declare global {
       categoryId?: Amity.InternalCategory['categoryId'];
       includeDeleted?: boolean;
       tags?: Amity.Taggable['tags'];
-      sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+      sortBy?: Amity.SearchCommunitySortBy | Amity.SearchCommunitySortByEnum;
       page?: string;
       limit?: number;
     };
@@ -121,25 +151,23 @@ declare global {
       communityId: string;
       memberships?: ('banned' | 'member')[];
       roles?: string[];
-      sortBy?:
-        | 'firstCreated'
-        | 'lastCreated'
-        /** @deprecated sortBy displayName is not available */
-        | 'displayName';
+      sortBy?: Amity.CommunityMemberSortByEnum | Amity.CommunityMemberSortBy;
       /** @deprecated use searchCommunityMembers instead */
       search?: Amity.InternalUser['displayName'] | Amity.InternalUser['userId'];
       page?: string;
       limit?: number;
+      includeDeleted?: boolean;
     };
 
     type QuerySearchCommunityMembers = {
       communityId: string;
       memberships?: ('banned' | 'member')[];
       roles?: string[];
-      sortBy?: 'firstCreated' | 'lastCreated' | 'displayName';
+      sortBy?: Amity.SearchCommunityMemberSortByEnum | Amity.SearchCommunityMemberSortBy;
       search?: Amity.InternalUser['displayName'] | Amity.InternalUser['userId'];
       page?: string;
       limit?: number;
+      includeDeleted?: boolean;
     };
 
     type CommunityMemberLiveCollection = Amity.LiveCollectionParams<

package/src/@types/domains/group.ts

@@ -2,14 +2,18 @@ export {};
 
 declare global {
   namespace Amity {
-    type GroupType = 'channel' | 'community';
+    enum GroupTypeEnum {
+      CHANNEL = 'channel',
+      COMMUNITY = 'community',
+    }
+    type GroupType = `${GroupTypeEnum}`;
     type GroupMembership = 'member' | 'none' | 'banned' | 'muted';
 
     type Group = {
       membersCount: number;
     };
 
-    type Member<T extends GroupType> = {
+    type Member<T extends Amity.GroupType> = {
       userId: Amity.InternalUser['userId'];
     } & (T extends 'channel'
       ? {
@@ -26,16 +30,20 @@ declare global {
       : never) &
       Amity.Timestamps;
 
-    type MemberWithUser<T extends GroupType> = Member<T> & { user: Amity.InternalUser | undefined };
+    type MemberWithUser<T extends Amity.GroupType> = Member<T> & {
+      readonly user?: Amity.InternalUser;
+    };
 
-    type RawMembership<T extends GroupType, WithUser = false> = {
+    type RawMembership<T extends Amity.GroupType> = {
       isBanned: boolean;
       isMuted: boolean;
       muteTimeout: string;
       lastActivity: Amity.timestamp;
-    } & (WithUser extends true ? MemberWithUser<T> : Member<T>) &
+    } & Amity.Member<T> &
       Amity.Accredited;
 
-    type Membership<T extends Amity.GroupType> = Amity.RawMembership<T, true>;
+    type Membership<T extends Amity.GroupType> = Amity.RawMembership<T> & {
+      readonly user?: Amity.InternalUser;
+    };
   }
 }

package/src/@types/domains/pin.ts

@@ -0,0 +1,27 @@
+export {};
+
+declare global {
+  namespace Amity {
+    type RawPin = {
+      referenceId: string; // postId
+      referenceType: string; // post
+      placement: string; // 'default' | 'announcement'
+      pinnedBy: string; // userId
+      pinnedAt: Date;
+    };
+
+    type RawPinTarget = {
+      targetId: string; // communityId | messageFeedId
+      targetType: string; // community | messageFeed
+      lastPinsUpdatedAt: Date;
+    };
+
+    type InternalPin = RawPin;
+
+    type InternalPinTarget = RawPinTarget;
+
+    type Pin = InternalPin;
+
+    type PinTarget = InternalPinTarget;
+  }
+}

package/src/@types/domains/pinnedPost.ts

@@ -0,0 +1,35 @@
+export {};
+
+declare global {
+  namespace Amity {
+    // Raw response from BE, not contain all linked objects
+    type PinnedPostPayload<T extends Amity.PostContentType = any> = {
+      pinTargets: Amity.RawPinTarget[];
+      pins: Amity.RawPin[];
+      posts: Amity.RawPost<T>[];
+      postChildren: Amity.RawPost<T>[];
+      comments: Amity.RawComment[];
+      videoStreamings: Amity.RawStream[];
+      polls: Amity.RawPoll[];
+    } & Amity.CommunityPayload;
+
+    type PinnedPostLiveCollection = Amity.LiveCollectionParams<{
+      communityId: Amity.Community['communityId'];
+      placement?: string | null;
+      sortBy: 'lastPinned' | 'lastCreated';
+    }>;
+
+    type PinnedPostLiveCollectionCache = Omit<
+      Amity.LiveCollectionCache<Amity.InternalPin['referenceId'], Amity.Page>,
+      'params'
+    >;
+
+    type PinnedPost = {
+      post: Amity.Post | undefined;
+      placement: Amity.Pin['placement'];
+      target: Amity.PinTarget | undefined;
+      pinnedBy: Amity.User;
+      pinnedAt: Date;
+    };
+  }
+}

package/src/@types/domains/poll.ts

@@ -16,7 +16,7 @@ declare global {
 
     type PollStatus = 'closed' | 'open';
 
-    type Poll = {
+    type RawPoll = {
       pollId: string;
       question: string;
       answers: PollAnswer[];
@@ -28,5 +28,9 @@ declare global {
       userId: Amity.InternalUser['userId'];
     } & Amity.Timestamps &
       Amity.SoftDelete;
+
+    type InternalPoll = RawPoll;
+
+    type Poll = InternalPoll;
   }
 }

package/src/@types/domains/post.ts

@@ -26,15 +26,15 @@ declare global {
       | 'onReactionAdded'
       | 'onReactionRemoved';
 
-    type InternalPost<T extends PostContentType = any> = {
+    type RawPost<T extends PostContentType = any> = {
       postId: string;
-      postedUserId: Amity.InternalUser['userId']; // API-FIX: it should be "userId"
-      parentId: Amity.InternalPost['postId'];
-      parentPostId: Amity.InternalPost['postId'];
+      postedUserId: Amity.RawUser['userId'];
+      parentId: Amity.RawPost['postId'];
+      parentPostId: Amity.RawPost['postId'];
       targetType: PostTargetType;
       targetId: string;
       feedId: Amity.Feed['feedId'];
-      children: Amity.InternalPost['postId'][];
+      children: Amity.RawPost['postId'][];
       comments: Amity.InternalComment['commentId'][];
       commentsCount: number; // API-FIX: backend doesn't follow its own convention
       hasFlaggedChildren: false;
@@ -51,6 +51,8 @@ declare global {
       Amity.AnalyticPostData &
       Amity.Mentionable<'user'>;
 
+    type InternalPost<T extends PostContentType = any> = RawPost<T>;
+
     type PostLinkObject = {
       latestComments: (Amity.Comment | null)[];
       creator: Amity.User | undefined;

package/src/@types/domains/stream.ts

@@ -44,7 +44,7 @@ declare global {
       stopTime: number;
     };
 
-    type InternalStream = {
+    type RawStream = {
       streamId: string;
       title: string;
       thumbnailFileId?: Amity.File<'image'>['fileId'];
@@ -65,6 +65,8 @@ declare global {
       Amity.Timestamps &
       Amity.SoftDelete;
 
+    type InternalStream = RawStream;
+
     type StreamLinkedObject = {
       moderation?: Amity.StreamModeration;
     };

package/src/@types/domains/user.ts

@@ -2,6 +2,23 @@ export {};
 
 declare global {
   namespace Amity {
+    enum UserSortByEnum {
+      FirstCreated = 'firstCreated',
+      LastCreated = 'lastCreated',
+      /** @deprecated sortBy displayName is not available */
+      DisplayName = 'displayName',
+    }
+
+    type UserSortBy = `${Amity.UserSortByEnum}`;
+
+    enum SearchUserSortByEnum {
+      FirstCreated = 'firstCreated',
+      LastCreated = 'lastCreated',
+      DisplayName = 'displayName',
+    }
+
+    type SearchUserSortBy = `${Amity.SearchUserSortByEnum}`;
+
     type UserActionType =
       | 'onFetch'
       | 'onUpdate'
@@ -10,14 +27,27 @@ declare global {
       | 'onUnflagged'
       | 'onFlagCleared';
 
-    type InternalUser = {
+    type RawUser = {
       _id: string;
       userId: string;
-      isGlobalBanned: boolean;
+      userInternalId: string;
+      userPublicId: string;
       displayName?: string;
-      avatarFileId?: Amity.File<'image'>['fileId'];
+      avatarFileId?: string;
       avatarCustomUrl?: string;
       description?: string;
+      isBrand: boolean;
+      isGlobalBan: boolean;
+    } & Amity.Metadata &
+      Amity.Taggable &
+      Amity.Flaggable &
+      Amity.Accredited &
+      Amity.Timestamps &
+      Amity.SoftDelete &
+      Amity.Subscribable;
+
+    type InternalUser = Amity.RawUser & {
+      isGlobalBanned: boolean;
     } & Amity.Metadata &
       Amity.Taggable &
       Amity.Flaggable &
@@ -31,16 +61,29 @@ declare global {
     };
 
     type QueryUsers = {
+      /** @deprecated use searchUsers instead */
       displayName?: Amity.InternalUser['displayName'];
       filter?: 'all' | 'flagged';
-      sortBy?: 'displayName' | 'firstCreated' | 'lastCreated';
+      sortBy?: Amity.UserSortBy | Amity.UserSortByEnum;
       limit?: number;
       page?: string;
     };
 
-    type UserLiveCollection = Amity.LiveCollectionParams<Omit<QueryUsers, 'page'>>;
+    type QuerySearchUsers = {
+      displayName?: Amity.InternalUser['displayName'];
+      filter?: 'all' | 'flagged';
+      sortBy?: Amity.SearchUserSortBy | Amity.SearchUserSortByEnum;
+      limit?: number;
+      page?: string;
+    };
+
+    type UserLiveCollection = Amity.LiveCollectionParams<Omit<Amity.QueryUsers, 'page'>>;
+
+    type SearchUserLiveCollection = Amity.LiveCollectionParams<
+      Omit<Amity.QuerySearchUsers, 'sortBy'>
+    >;
 
-    type UserSearchLiveCollection = Amity.LiveCollectionParams<Omit<QueryUsers, 'sortBy'>>;
+    type UserSearchLiveCollection = Amity.SearchUserLiveCollection;
 
     type UserLiveCollectionCache = Amity.LiveCollectionCache<
       Amity.InternalUser['userId'],

package/src/channelRepository/channelMembership/observers/getMembers/ChannelMemberLiveCollectionController.ts

@@ -143,6 +143,12 @@ export class ChannelMemberLiveCollectionController extends LiveCollectionControl
       channelMembers = filterBySearchTerm(channelMembers, this.query.search);
     }
 
+    if (typeof this.query.includeDeleted === 'boolean') {
+      channelMembers = channelMembers.filter(
+        member => member.user?.isDeleted === this.query.includeDeleted,
+      );
+    }
+
     // sort, 'lastCreated' is the default sort order
     const sortBy = this.query.sortBy ? this.query.sortBy : 'lastCreated';
     channelMembers = channelMembers.sort(

package/src/channelRepository/channelMembership/observers/searchMembers/SearchChannelMemberLiveCollectionController.ts

@@ -0,0 +1,142 @@
+/* eslint-disable no-use-before-define */
+import hash from 'object-hash';
+import { pullFromCache, pushToCache } from '~/cache/api';
+import { SearchChannelMemberPaginationController } from './SearchChannelMemberPaginationController';
+import { SearchChannelMemberQueryStreamController } from './SearchChannelMemberQueryStreamController';
+import { LiveCollectionController } from '~/core/liveCollection/LiveCollectionController';
+import {
+  onChannelJoined,
+  onChannelLeft,
+  onChannelMemberAdded,
+  onChannelMemberRemoved,
+  onChannelMemberBanned,
+  onChannelMemberUnbanned,
+  onChannelMemberRoleAdded,
+  onChannelMemberRoleRemoved,
+} from '~/channelRepository/events';
+import { filterByPropIntersection, filterBySearchTerm } from '~/core/query';
+import { prepareChannelPayload } from '~/channelRepository/utils';
+
+export class SearchChannelMemberLiveCollectionController extends LiveCollectionController<
+  'channelUser',
+  Amity.SearchChannelMembersLiveCollection,
+  Amity.Membership<'channel'>,
+  SearchChannelMemberPaginationController
+> {
+  private queryStreamController: SearchChannelMemberQueryStreamController;
+
+  private query: Amity.SearchChannelMembersLiveCollection;
+
+  constructor(
+    query: Amity.SearchChannelMembersLiveCollection,
+    callback: Amity.LiveCollectionCallback<Amity.Membership<'channel'>>,
+  ) {
+    const queryStreamId = hash(query);
+    const cacheKey = ['channelUsers', 'collection', queryStreamId];
+    const paginationController = new SearchChannelMemberPaginationController(query);
+
+    super(paginationController, queryStreamId, cacheKey, callback);
+
+    this.query = query;
+    this.queryStreamController = new SearchChannelMemberQueryStreamController(
+      this.query,
+      this.cacheKey,
+      this.notifyChange.bind(this),
+      prepareChannelPayload,
+    );
+
+    this.callback = callback.bind(this);
+    this.loadPage({ initial: true });
+  }
+
+  protected setup() {
+    const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) {
+      pushToCache(this.cacheKey, {
+        data: [],
+        params: {},
+      });
+    }
+  }
+
+  protected async persistModel(queryPayload: Amity.ChannelMembershipPayload & Amity.Pagination) {
+    await this.queryStreamController.saveToMainDB(queryPayload);
+  }
+
+  protected persistQueryStream({
+    response,
+    direction,
+    refresh,
+  }: Amity.LiveCollectionPersistQueryStreamParams<'channelUser'>) {
+    this.queryStreamController.appendToQueryStream(response, direction, refresh);
+  }
+
+  startSubscription() {
+    return this.queryStreamController.subscribeRTE([
+      { fn: onChannelJoined, action: 'onJoin' },
+      { fn: onChannelLeft, action: 'onLeft' },
+      { fn: onChannelMemberAdded, action: 'onMemberAdded' },
+      { fn: onChannelMemberRemoved, action: 'onMemberRemoved' },
+      { fn: onChannelMemberBanned, action: 'onChannelMemberBanned' },
+      { fn: onChannelMemberUnbanned, action: 'onChannelMemberUnbanned' },
+      { fn: onChannelMemberRoleAdded, action: 'onChannelMemberRoleAdded' },
+      { fn: onChannelMemberRoleRemoved, action: 'onChannelMemberRoleRemoved' },
+    ]);
+  }
+
+  notifyChange({ origin, loading, error }: Amity.LiveCollectionNotifyParams) {
+    const collection = pullFromCache<Amity.ChannelMembersLiveCollectionCache>(this.cacheKey)?.data;
+    if (!collection) return;
+
+    const data = this.applyFilter(
+      collection.data
+        .map(id => pullFromCache<Amity.Membership<'channel'>>(['channelUsers', 'get', id])!)
+        .filter(Boolean)
+        .map(({ data }) => data) ?? [],
+    );
+
+    if (!this.shouldNotify(data) && origin === 'event') return;
+
+    this.callback({
+      onNextPage: () => this.loadPage({ direction: Amity.LiveCollectionPageDirection.NEXT }),
+      data,
+      hasNextPage: !!this.paginationController.getNextToken(),
+      loading,
+      error,
+    });
+  }
+
+  applyFilter(data: Amity.Membership<'channel'>[]) {
+    let channelMembers = filterByPropIntersection(data, 'roles', this.query.roles);
+
+    if (this.query.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 => {
+        if (this.query.memberships?.includes('muted') && member.isMuted) {
+          return true;
+        }
+
+        if (member.membership !== 'none') {
+          return this.query.memberships?.includes(member.membership);
+        }
+
+        return false;
+      });
+    }
+
+    if (this.query.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, this.query.search);
+    }
+
+    return channelMembers;
+  }
+}