stream-chat 9.50.3 → 9.52.0

package/src/messageComposer/middleware/textComposer/mentions.ts

@@ -9,7 +9,11 @@ import {
   userSuggestionToMentionEntity,
   userSuggestionToUserResponse,
 } from './mentionUtils';
-import { BaseSearchSource, type SearchSourceOptions } from '../../../search';
+import {
+  BaseSearchSource,
+  type SearchQueryOptions,
+  type SearchSourceOptions,
+} from '../../../search';
 import { mergeWith } from '../../../utils/mergeWith';
 import type {
   ChannelMentionSuggestion,
@@ -92,6 +96,13 @@ export const calculateLevenshtein = (query: string, name: string) => {
 };
 
 export type MentionsSearchSourceOptions = SearchSourceOptions & {
+  /** Static base filters for the app-wide user query (mentionAllAppUsers). */
+  userFilters?: UserFilters;
+  userSort?: UserSort;
+  /** Static base filters for the channel member query. */
+  memberFilters?: MemberFilters;
+  memberSort?: MemberSort;
+  searchOptions?: Omit<UserOptions, 'limit' | 'offset'>;
   mentionAllAppUsers?: boolean;
   suggestionFactoryMappers?: MentionSuggestionFactoryMapperOverrides;
   textComposerText?: string;
@@ -299,20 +310,34 @@ export class MentionsSearchSource extends BaseSearchSource<MentionSuggestion> {
   userSort: UserSort | undefined;
   memberSort: MemberSort | undefined; // todo: document there are filters and sort options for users and members
   searchOptions: Omit<UserOptions, 'limit' | 'offset'> | undefined;
-  config: MentionsSearchSourceOptions;
+  config: Pick<
+    MentionsSearchSourceOptions,
+    'mentionAllAppUsers' | 'suggestionFactoryMappers' | 'textComposerText' | 'trigger'
+  >;
 
   constructor(channel: Channel, options?: MentionsSearchSourceOptions) {
     const {
       mentionAllAppUsers,
+      memberFilters,
+      memberSort,
+      searchOptions,
       suggestionFactoryMappers,
       textComposerText,
       transliterate,
       trigger,
+      userFilters,
+      userSort,
       ...restOptions
     } = options || {};
-    super(restOptions);
+    // suggestions are shown for a bare trigger, so the empty query must be allowed
+    super({ ...restOptions, allowEmptySearchString: true });
     this.client = channel.getClient();
     this.channel = channel;
+    this.userFilters = userFilters;
+    this.userSort = userSort;
+    this.memberFilters = memberFilters;
+    this.memberSort = memberSort;
+    this.searchOptions = searchOptions;
     this.config = {
       mentionAllAppUsers,
       suggestionFactoryMappers,
@@ -425,11 +450,6 @@ export class MentionsSearchSource extends BaseSearchSource<MentionSuggestion> {
     };
   }
 
-  canExecuteQuery = (newSearchString?: string) => {
-    const hasNewSearchQuery = typeof newSearchString !== 'undefined';
-    return this.isActive && !this.isLoading && (hasNewSearchQuery || this.hasNext);
-  };
-
   protected updatePaginationStateFromQuery() {
     const userPaginationState = this.latestUserPaginationState ?? { itemCount: 0 };
 
@@ -472,10 +492,13 @@ export class MentionsSearchSource extends BaseSearchSource<MentionSuggestion> {
         : []),
     ].filter(({ name }) => this.matchesPrefixSearchQuery(name, searchQuery));
 
-  getRoleMentionSuggestions = async (query: string): Promise<RoleMentionSuggestion[]> => {
+  getRoleMentionSuggestions = async (
+    query: string,
+    queryOptions: SearchQueryOptions = {},
+  ): Promise<RoleMentionSuggestion[]> => {
     if (!this.isMentionTypeAllowed('role')) return [];
     if (!query) return [];
-    const { roles } = await this.client.searchRoles({ query });
+    const { roles } = await this.client.searchRoles({ query }, queryOptions);
     return [...(roles?.map((role) => role.name) ?? [])]
       .sort((left, right) => left.localeCompare(right))
       .map((role) => this.toRoleMentionSuggestion(role, query));
@@ -558,23 +581,40 @@ export class MentionsSearchSource extends BaseSearchSource<MentionSuggestion> {
     };
   };
 
-  queryUsers = async (searchQuery: string, offset = 0) => {
+  queryUsers = async (
+    searchQuery: string,
+    offset = 0,
+    queryOptions: SearchQueryOptions = {},
+  ) => {
     const { filters, sort, options } = this.prepareQueryUsersParams(searchQuery, offset);
-    const { users } = await this.client.queryUsers(filters, sort, options);
+    const { users } = await this.client.queryUsers(filters, sort, options, queryOptions);
     return users;
   };
 
-  queryMembers = async (searchQuery: string, offset = 0) => {
+  queryMembers = async (
+    searchQuery: string,
+    offset = 0,
+    queryOptions: SearchQueryOptions = {},
+  ) => {
     const { filters, sort, options } = this.prepareQueryMembersParams(
       searchQuery,
       offset,
     );
-    const response = await this.channel.queryMembers(filters, sort, options);
+    const response = await this.channel.queryMembers(
+      filters,
+      sort,
+      options,
+      queryOptions,
+    );
 
     return response.members.map((member) => member.user) as UserResponse[];
   };
 
-  getUserSuggestionsPage = async (searchQuery: string, userOffset = 0) => {
+  getUserSuggestionsPage = async (
+    searchQuery: string,
+    userOffset = 0,
+    queryOptions: SearchQueryOptions = {},
+  ) => {
     if (!this.isMentionTypeAllowed('user')) {
       return {
         items: [],
@@ -587,7 +627,7 @@ export class MentionsSearchSource extends BaseSearchSource<MentionSuggestion> {
       this.allMembersLoadedWithInitialChannelQuery || !searchQuery;
 
     if (this.config.mentionAllAppUsers) {
-      users = await this.queryUsers(searchQuery, userOffset);
+      users = await this.queryUsers(searchQuery, userOffset, queryOptions);
     } else if (shouldSearchLocally) {
       const localUsers = this.searchMembersLocally(searchQuery);
       const items = localUsers
@@ -601,7 +641,7 @@ export class MentionsSearchSource extends BaseSearchSource<MentionSuggestion> {
             : undefined,
       };
     } else {
-      users = await this.queryMembers(searchQuery, userOffset);
+      users = await this.queryMembers(searchQuery, userOffset, queryOptions);
     }
 
     const items = users.map((user) => this.toUserSuggestion(user, searchQuery));
@@ -623,7 +663,11 @@ export class MentionsSearchSource extends BaseSearchSource<MentionSuggestion> {
     } satisfies UserGroupSearchCursor);
   };
 
-  getUserGroupSuggestionsPage = async (searchQuery: string, cursor?: string) => {
+  getUserGroupSuggestionsPage = async (
+    searchQuery: string,
+    cursor?: string,
+    queryOptions: SearchQueryOptions = {},
+  ) => {
     if (!this.isMentionTypeAllowed('user_group')) {
       return {
         items: [],
@@ -647,7 +691,7 @@ export class MentionsSearchSource extends BaseSearchSource<MentionSuggestion> {
       ...(userGroupCursor?.id_gt ? { id_gt: userGroupCursor.id_gt } : {}),
       ...(userGroupCursor?.name_gt ? { name_gt: userGroupCursor.name_gt } : {}),
     };
-    const { user_groups } = await this.client.searchUserGroups(options);
+    const { user_groups } = await this.client.searchUserGroups(options, queryOptions);
 
     return {
       items: user_groups.map((userGroup) =>
@@ -657,20 +701,28 @@ export class MentionsSearchSource extends BaseSearchSource<MentionSuggestion> {
     };
   };
 
-  async query(searchQuery: string) {
+  async query(searchQuery: string, queryOptions: SearchQueryOptions = {}) {
     const userOffset = this.offset ?? 0;
     const isFirstPage = userOffset === 0 && typeof this.userGroupCursor === 'undefined';
     const previousUserPaginationState = this.latestUserPaginationState;
     const previousUserGroupCursor = this.userGroupCursor;
     const [userResultsState, userGroupResultsState, roleSuggestionsState] =
       await Promise.allSettled([
-        this.getUserSuggestionsPage(searchQuery, userOffset),
-        this.getUserGroupSuggestionsPage(searchQuery, previousUserGroupCursor),
+        this.getUserSuggestionsPage(searchQuery, userOffset, queryOptions),
+        this.getUserGroupSuggestionsPage(
+          searchQuery,
+          previousUserGroupCursor,
+          queryOptions,
+        ),
         isFirstPage
-          ? this.getRoleMentionSuggestions(searchQuery)
+          ? this.getRoleMentionSuggestions(searchQuery, queryOptions)
           : Promise.resolve([] as RoleMentionSuggestion[]),
       ]);
 
+    // On abort the requests above reject and the fallback branches below would write
+    // empty results into the pagination cursors, corrupting them for the newer query.
+    if (queryOptions.signal?.aborted) return { items: [] };
+
     const userResults =
       userResultsState.status === 'fulfilled'
         ? userResultsState.value

package/src/messageComposer/types.ts

@@ -119,6 +119,11 @@ export type LocalAttachmentUploadMetadata = {
    */
   previewUri?: string;
   uploadState: AttachmentLoadingState;
+  /**
+   * Mirrors {@link UploadRecord.uploadConfirmationPending}: every byte has been sent, but the server has
+   * not confirmed yet - not returned response to the upload request. Render an indeterminate indicator rather than a full bar.
+   */
+  uploadConfirmationPending?: boolean;
   uploadPermissionCheck?: UploadPermissionCheckResult; // added new
   /** 0–100 while uploading when progress tracking is enabled; undefined otherwise or when indeterminate */
   uploadProgress?: number;

package/src/middleware.ts

@@ -58,6 +58,17 @@ export class MiddlewareExecutor<TValue, THandlers extends string> {
     this.id = generateUUIDv4();
   }
 
+  /**
+   * The middleware currently installed, in execution order.
+   *
+   * Read-only: use `use` / `insert` / `replace` / `setOrder` / `remove` to change the chain. It
+   * exists so components can ask what the chain is capable of - a middleware may declare
+   * behaviour its host has to account for, and the host has no other way to find out.
+   */
+  get installedMiddleware(): ReadonlyArray<Middleware<TValue, THandlers>> {
+    return this.middleware;
+  }
+
   use(middleware: Middleware<TValue, THandlers> | Middleware<TValue, THandlers>[]) {
     this.middleware = this.middleware.concat(middleware);
     return this;

package/src/offline-support/offline_support_api.ts

@@ -40,9 +40,24 @@ export abstract class AbstractOfflineDB implements OfflineDBApi {
   public syncManager: OfflineDBSyncManager;
   public state: StateStore<OfflineDBState>;
 
-  constructor({ client }: { client: StreamChat }) {
+  constructor({
+    client,
+    syncMaxEventCount,
+  }: {
+    client: StreamChat;
+    /**
+     * Optional positive cap forwarded to the {@link OfflineDBSyncManager}, which
+     * owns sync. `undefined` or any non-positive value means "no limit". See
+     * {@link OfflineDBSyncManager.syncMaxEventCount}.
+     */
+    syncMaxEventCount?: number;
+  }) {
     this.client = client;
-    this.syncManager = new OfflineDBSyncManager({ client, offlineDb: this });
+    this.syncManager = new OfflineDBSyncManager({
+      client,
+      offlineDb: this,
+      syncMaxEventCount,
+    });
     this.state = new StateStore<OfflineDBState>({
       initialized: false,
       userId: this.client.userID,
@@ -1035,6 +1050,10 @@ export abstract class AbstractOfflineDB implements OfflineDBApi {
     }
 
     if (type === 'message.read' || type === 'notification.mark_read') {
+      // We make sure not to update channel reads (which is what's stored in
+      // the offline DB in any case) whenever we receive a read event for a
+      // a thread specifically.
+      if (event.thread) return [];
       return this.handleRead({ event, unreadMessages: 0, execute });
     }
 

package/src/offline-support/offline_sync_manager.ts

@@ -20,16 +20,29 @@ export class OfflineDBSyncManager {
     new Map();
   private client: StreamChat;
   private offlineDb: AbstractOfflineDB;
+  /**
+   * Optional positive cap on the number of events a single `/sync` response may
+   * contain before this manager skips event replay into local storage and relies
+   * on the reconnect-time channel refresh (queryChannels + `channel.watch()`) to
+   * bring visible surfaces up to date.
+   *
+   * `undefined` or any non-positive value means "no limit" and event replay always
+   * runs with whatever maximum the server decides to return.
+   */
+  public readonly syncMaxEventCount?: number;
 
   constructor({
     client,
     offlineDb,
+    syncMaxEventCount,
   }: {
     client: StreamChat;
     offlineDb: AbstractOfflineDB;
+    syncMaxEventCount?: number;
   }) {
     this.client = client;
     this.offlineDb = offlineDb;
+    this.syncMaxEventCount = syncMaxEventCount;
   }
 
   /**
@@ -173,14 +186,29 @@ export class OfflineDBSyncManager {
           await this.offlineDb.resetDB();
         } else {
           const result = await this.client.sync(cids, lastSyncedAtDate.toISOString());
-          const queryPromises = result.events.map((event) =>
-            this.offlineDb.handleEvent({ event, execute: false }),
-          );
-          const queriesArray = await Promise.all(queryPromises);
-          const queries = queriesArray.flat() as ExecuteBatchDBQueriesType;
-
-          if (queries.length) {
-            await this.offlineDb.executeSqlBatch(queries);
+
+          // Opt-in positive cap owned by this manager; undefined/non-positive = no limit.
+          const { syncMaxEventCount } = this;
+          const exceedsLimit =
+            typeof syncMaxEventCount === 'number' &&
+            syncMaxEventCount > 0 &&
+            result.events.length > syncMaxEventCount;
+          if (exceedsLimit) {
+            this.client.logger(
+              'warn',
+              `Skipping sync event replay: received ${result.events.length} events, which exceeds the configured limit of ${syncMaxEventCount}. Visible channels are refreshed on reconnect instead.`,
+              { tags: ['sync', 'offline'] },
+            );
+          } else {
+            const queryPromises = result.events.map((event) =>
+              this.offlineDb.handleEvent({ event, execute: false }),
+            );
+            const queriesArray = await Promise.all(queryPromises);
+            const queries = queriesArray.flat() as ExecuteBatchDBQueriesType;
+
+            if (queries.length) {
+              await this.offlineDb.executeSqlBatch(queries);
+            }
           }
         }
       }

package/src/search/BaseSearchSource.ts

@@ -9,10 +9,24 @@ import type {
 import type { APIError } from '../errors';
 import { isAPIError, isErrorRetryable } from '../errors';
 
+/**
+ * Passed to a search source's `query()`. Carries a cancellation handle and makes no
+ * claim that the query performs a request: a source may resolve from local data and
+ * ignore the signal. Where a source does issue requests, forward this straight through
+ * as the request options.
+ */
+export type SearchQueryOptions = {
+  /** Aborted once a newer query supersedes this one. */
+  signal?: AbortSignal;
+};
+
 export type DebounceOptions = {
-  debounceMs: number;
+  /** Applies to both short and long queries unless overridden by the options below. */
+  debounceMs?: number;
+  shortQueryDebounceMs?: number;
+  longQueryDebounceMs?: number;
+  shortQueryMaxLength?: number;
 };
-type DebouncedExecQueryFunction = DebouncedFunc<(searchString?: string) => Promise<void>>;
 
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 interface ISearchSource<T = any> {
@@ -54,18 +68,44 @@ export interface SearchSourceSync<T = any> extends ISearchSource<T> {
   search(text?: string): void;
 }
 
-const DEFAULT_SEARCH_SOURCE_OPTIONS: Required<SearchSourceOptions> = {
-  debounceMs: 300,
+// Debounce defaults are resolved by resolveDebounceOptions, not here.
+const DEFAULT_SEARCH_SOURCE_OPTIONS: Required<
+  Omit<SearchSourceOptions, keyof DebounceOptions>
+> = {
   pageSize: 10,
   allowEmptySearchString: false,
   resetOnNewSearchQuery: true,
 } as const;
 
-abstract class BaseSearchSourceBase<T> implements ISearchSource<T> {
+/**
+ * An explicit `debounceMs` applies to both buckets, so integrators who already tuned it
+ * keep exactly their configured interval. Only when it is absent do the 500/300 defaults
+ * kick in.
+ */
+const resolveDebounceOptions = ({
+  debounceMs,
+  shortQueryDebounceMs,
+  longQueryDebounceMs,
+  shortQueryMaxLength,
+}: DebounceOptions) => ({
+  shortQueryDebounceMs: shortQueryDebounceMs ?? debounceMs ?? 500,
+  longQueryDebounceMs: longQueryDebounceMs ?? debounceMs ?? 300,
+  shortQueryMaxLength: shortQueryMaxLength ?? 2,
+});
+
+abstract class BaseSearchSourceBase<
+  T,
+  R extends void | Promise<void>,
+> implements ISearchSource<T> {
   state: StateStore<SearchSourceState<T>>;
   pageSize: number;
   protected allowEmptySearchString: boolean;
   protected resetOnNewSearchQuery: boolean;
+  // assigned by setDebounceOptions, which the constructor always calls
+  protected shortQueryDebounceMs!: number;
+  protected longQueryDebounceMs!: number;
+  protected shortQueryMaxLength!: number;
+  protected searchDebounced!: DebouncedFunc<(searchString?: string) => R>;
   abstract readonly type: SearchSourceType;
 
   protected constructor(options?: SearchSourceOptions) {
@@ -77,8 +117,44 @@ abstract class BaseSearchSourceBase<T> implements ISearchSource<T> {
     this.allowEmptySearchString = allowEmptySearchString;
     this.resetOnNewSearchQuery = resetOnNewSearchQuery;
     this.state = new StateStore<SearchSourceState<T>>(this.initialState);
+    // Field initializers run before this body, so setDebounceOptions is already
+    // assigned; it only captures getDebounceMs lazily.
+    this.setDebounceOptions(options ?? {});
+  }
+
+  abstract executeQuery(newSearchString?: string): R;
+
+  setDebounceOptions = (options: DebounceOptions = {}) => {
+    const resolved = resolveDebounceOptions(options);
+    this.shortQueryDebounceMs = resolved.shortQueryDebounceMs;
+    this.longQueryDebounceMs = resolved.longQueryDebounceMs;
+    this.shortQueryMaxLength = resolved.shortQueryMaxLength;
+    this.searchDebounced = debounce(this.executeQuery.bind(this), (searchString) =>
+      this.getDebounceMs(searchString),
+    );
+  };
+
+  /**
+   * Short queries match too much and are slow server-side, so they get a longer debounce.
+   * Resolved per call, which is what lets the interval switch as the user keeps typing.
+   */
+  protected getDebounceMs = (searchString?: string) => {
+    const { length } = searchString ?? this.searchQuery;
+    return length <= this.shortQueryMaxLength
+      ? this.shortQueryDebounceMs
+      : this.longQueryDebounceMs;
+  };
+
+  /**
+   * A new search query preempts an in-flight one; pagination waits for it to finish
+   * and needs a next page to fetch.
+   */
+  protected canDispatchQuery(hasNewSearchQuery: boolean) {
+    return hasNewSearchQuery || (!this.isLoading && this.hasNext);
   }
 
+  search = (searchQuery?: string) => this.searchDebounced(searchQuery);
+
   get lastQueryError() {
     return this.state.getLatestValue().lastQueryError;
   }
@@ -99,7 +175,7 @@ abstract class BaseSearchSourceBase<T> implements ISearchSource<T> {
     return this.state.getLatestValue().isLoading;
   }
 
-  get initialState() {
+  get initialState(): SearchSourceState<T> {
     return {
       hasNext: true,
       isActive: false,
@@ -143,8 +219,7 @@ abstract class BaseSearchSourceBase<T> implements ISearchSource<T> {
     const searchString = newSearchString ?? this.searchQuery;
     return !!(
       this.isActive &&
-      !this.isLoading &&
-      (this.hasNext || hasNewSearchQuery) &&
+      this.canDispatchQuery(hasNewSearchQuery) &&
       (this.allowEmptySearchString || searchString)
     );
   };
@@ -217,34 +292,48 @@ abstract class BaseSearchSourceBase<T> implements ISearchSource<T> {
 }
 
 export abstract class BaseSearchSource<T>
-  extends BaseSearchSourceBase<T>
+  extends BaseSearchSourceBase<T, Promise<void>>
   implements SearchSource<T>
 {
-  protected searchDebounced!: DebouncedExecQueryFunction;
+  /** Aborts the in-flight request, if any, once a newer query is dispatched. */
+  protected queryAbortController: AbortController | null = null;
 
-  constructor(options?: SearchSourceOptions) {
-    const { debounceMs } = { ...DEFAULT_SEARCH_SOURCE_OPTIONS, ...options };
-    super(options);
-    this.setDebounceOptions({ debounceMs });
-  }
-
-  protected abstract query(searchQuery: string): Promise<QueryReturnValue<T>>;
+  protected abstract query(
+    searchQuery: string,
+    options?: SearchQueryOptions,
+  ): Promise<QueryReturnValue<T>>;
 
   protected abstract filterQueryResults(items: T[]): T[] | Promise<T[]>;
 
-  setDebounceOptions = ({ debounceMs }: DebounceOptions) => {
-    this.searchDebounced = debounce(this.executeQuery.bind(this), debounceMs);
-  };
+  /** Aborts the in-flight request, if any. Returns true when one was aborted. */
+  protected abortInFlightQuery() {
+    if (!this.queryAbortController) return false;
+    this.queryAbortController.abort();
+    this.queryAbortController = null;
+    return true;
+  }
+
+  resetState() {
+    // otherwise an in-flight response would repopulate the state we just cleared
+    this.abortInFlightQuery();
+    super.resetState();
+  }
 
   async executeQuery(newSearchString?: string) {
+    // Checked before anything is dispatched, so that the abort below always has a
+    // successor that will clear isLoading.
     if (!this.canExecuteQuery(newSearchString)) return;
 
+    // cancel the previous request before dispatching the new one
+    this.abortInFlightQuery();
+    const { signal } = (this.queryAbortController = new AbortController());
+
     const { hasNewSearchQuery, searchString } =
       this.prepareStateForQuery(newSearchString);
 
     let stateUpdate: Partial<SearchSourceState<T>> = {};
     try {
-      const results = await this.query(searchString);
+      const results = await this.query(searchString, { signal });
       if (!results) return;
 
       const { items } = results;
@@ -256,37 +345,34 @@ export abstract class BaseSearchSource<T>
         stateUpdate.hasNext = false;
       }
     } finally {
-      this.state.next(this.getStateAfterQuery(stateUpdate, hasNewSearchQuery));
+      // A newer query owns the state now - publishing here would clobber it with a
+      // stale result (and with the abort error).
+      if (!signal.aborted) {
+        this.state.next(this.getStateAfterQuery(stateUpdate, hasNewSearchQuery));
+      }
     }
   }
 
-  search = (searchQuery?: string) => this.searchDebounced(searchQuery);
-
   cancelScheduledQuery() {
     this.searchDebounced.cancel();
+    // Nothing will dispatch a successor query, so release the loading state the
+    // aborted query owned - its own finally block skips the state write.
+    if (this.abortInFlightQuery() && this.isLoading) {
+      this.state.partialNext({ isLoading: false });
+    }
   }
 }
 
+// Queries are resolved locally, so there is nothing to cancel here - only the
+// dynamic debounce applies.
 export abstract class BaseSearchSourceSync<T>
-  extends BaseSearchSourceBase<T>
+  extends BaseSearchSourceBase<T, void>
   implements SearchSourceSync<T>
 {
-  protected searchDebounced!: DebouncedExecQueryFunction;
-
-  constructor(options?: SearchSourceOptions) {
-    const { debounceMs } = { ...DEFAULT_SEARCH_SOURCE_OPTIONS, ...options };
-    super(options);
-    this.setDebounceOptions({ debounceMs });
-  }
-
   protected abstract query(searchQuery: string): QueryReturnValue<T>;
 
   protected abstract filterQueryResults(items: T[]): T[];
 
-  setDebounceOptions = ({ debounceMs }: DebounceOptions) => {
-    this.searchDebounced = debounce(this.executeQuery.bind(this), debounceMs);
-  };
-
   executeQuery(newSearchString?: string) {
     if (!this.canExecuteQuery(newSearchString)) return;
 
@@ -311,8 +397,6 @@ export abstract class BaseSearchSourceSync<T>
     }
   }
 
-  search = (searchQuery?: string) => this.searchDebounced(searchQuery);
-
   cancelScheduledQuery() {
     this.searchDebounced.cancel();
   }

package/src/search/ChannelMemberSearchSource.ts

@@ -1,4 +1,4 @@
-import { BaseSearchSource } from './BaseSearchSource';
+import { BaseSearchSource, type SearchQueryOptions } from './BaseSearchSource';
 import { FilterBuilder, type FilterBuilderOptions } from '../pagination';
 import type { Channel } from '../channel';
 import type {
@@ -15,6 +15,13 @@ export type ChannelMemberSearchSourceFilterBuilderContext<
   C extends CustomContext = CustomContext,
 > = { searchQuery?: string } & C;
 
+export type ChannelMemberSearchSourceOptions = SearchSourceOptions & {
+  /** Static base filters merged under the dynamically generated ones. */
+  filters?: MemberFilters;
+  sort?: MemberSort;
+  searchOptions?: Omit<QueryMembersOptions, 'limit' | 'offset'>;
+};
+
 export class ChannelMemberSearchSource<
   TFilterContext extends CustomContext = CustomContext,
 > extends BaseSearchSource<ChannelMemberResponse> {
@@ -30,14 +37,19 @@ export class ChannelMemberSearchSource<
 
   constructor(
     channel: Channel,
-    options?: SearchSourceOptions,
+    options?: ChannelMemberSearchSourceOptions,
     filterBuilderOptions: FilterBuilderOptions<
       MemberFilters,
       ChannelMemberSearchSourceFilterBuilderContext<TFilterContext>
     > = {},
   ) {
-    super(options);
+    const { filters, sort, searchOptions, ...restOptions } = options || {};
+    // members are listed with an empty query, so the initial load must be allowed
+    super({ ...restOptions, allowEmptySearchString: true });
     this.channel = channel;
+    this.filters = filters;
+    this.sort = sort;
+    this.searchOptions = searchOptions;
     this.filterBuilder = new FilterBuilder<
       MemberFilters,
       ChannelMemberSearchSourceFilterBuilderContext<TFilterContext>
@@ -60,13 +72,7 @@ export class ChannelMemberSearchSource<
     });
   }
 
-  canExecuteQuery = (newSearchString?: string) => {
-    const hasNewSearchQuery = typeof newSearchString !== 'undefined';
-
-    return this.isActive && !this.isLoading && (this.hasNext || hasNewSearchQuery);
-  };
-
-  protected async query(searchQuery: string) {
+  protected async query(searchQuery: string, queryOptions: SearchQueryOptions = {}) {
     const filters = this.filterBuilder.buildFilters({
       baseFilters: this.filters,
       context: {
@@ -75,7 +81,12 @@ export class ChannelMemberSearchSource<
     });
     const sort = this.sort ?? [];
     const options = { ...this.searchOptions, limit: this.pageSize, offset: this.offset };
-    const { members } = await this.channel.queryMembers(filters ?? {}, sort, options);
+    const { members } = await this.channel.queryMembers(
+      filters ?? {},
+      sort,
+      options,
+      queryOptions,
+    );
     return { items: members };
   }