stream-chat 9.50.2 → 9.51.0

package/src/channel.ts

@@ -62,6 +62,7 @@ import type {
   QueryMembersOptions,
   Reaction,
   ReactionAPIResponse,
+  RequestOptions,
   SearchAPIResponse,
   SearchMessageSortBase,
   SearchOptions,
@@ -377,6 +378,7 @@ export class Channel {
    * @param {MemberSort} [sort] Sort options, for instance [{created_at: -1}].
    * When using multiple fields, make sure you use array of objects to guarantee field order, for instance [{name: -1}, {created_at: 1}]
    * @param {{ limit?: number; offset?: number }} [options] Option object, {limit: 10, offset:10}
+   * @param {RequestOptions} [requestOptions] Carries an abort signal. Not sent in the request.
    *
    * @return {Promise<ChannelMemberAPIResponse>} Query Members response
    */
@@ -384,6 +386,7 @@ export class Channel {
     filterConditions: MemberFilters,
     sort: MemberSort = [],
     options: QueryMembersOptions = {},
+    requestOptions: RequestOptions = {},
   ) {
     let id: string | undefined;
     const type = this.type;
@@ -406,6 +409,7 @@ export class Channel {
           ...options,
         },
       },
+      requestOptions,
     );
   }
 

package/src/client.ts

@@ -219,6 +219,7 @@ import type {
   ReminderAPIResponse,
   RemoveUserGroupMembersOptions,
   RemoveUserGroupMembersResponse,
+  RequestOptions,
   ReviewFlagReportOptions,
   ReviewFlagReportResponse,
   SdkIdentifier,
@@ -1312,6 +1313,9 @@ export class StreamChat {
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
     } catch (e: any /**TODO: generalize error types  */) {
       e.client_request_id = requestConfig.headers?.['x-client-request-id'];
+      // An aborted request is a deliberate cancellation, not a failure - logging it
+      // and counting it towards the token-refresh backoff would be misleading.
+      if (axios.isCancel(e)) throw e;
       this._logApiError(type, url, e);
       this.consecutiveFailures += 1;
       if (e.response) {
@@ -1333,16 +1337,22 @@ export class StreamChat {
     }
   };
 
-  get<T>(url: string, params?: AxiosRequestConfig['params']) {
-    return this.doAxiosRequest<T>('get', url, null, { params });
+  get<T>(
+    url: string,
+    params?: AxiosRequestConfig['params'],
+    // `params` is omitted deliberately: _enrichAxiosOptions spreads `config` after the
+    // enriched params, so a `config.params` would drop api_key/user_id/connection_id.
+    config?: Omit<AxiosRequestConfig, 'params'>,
+  ) {
+    return this.doAxiosRequest<T>('get', url, null, { params, config });
   }
 
   put<T>(url: string, data?: unknown) {
     return this.doAxiosRequest<T>('put', url, data);
   }
 
-  post<T>(url: string, data?: unknown) {
-    return this.doAxiosRequest<T>('post', url, data);
+  post<T>(url: string, data?: unknown, config?: Omit<AxiosRequestConfig, 'params'>) {
+    return this.doAxiosRequest<T>('post', url, data, { config });
   }
 
   patch<T>(url: string, data?: unknown) {
@@ -1837,6 +1847,7 @@ export class StreamChat {
    * @param {UserSort} sort Sort options, for instance [{last_active: -1}].
    * When using multiple fields, make sure you use array of objects to guarantee field order, for instance [{last_active: -1}, {created_at: 1}]
    * @param {UserOptions} options Option object, {presence: true}
+   * @param {RequestOptions} [requestOptions] Carries an abort signal. Not sent in the request.
    *
    * @return {Promise<{ users: Array<UserResponse> }>} User Query Response
    */
@@ -1844,6 +1855,7 @@ export class StreamChat {
     filterConditions: UserFilters,
     sort: UserSort = [],
     options: UserOptions = {},
+    requestOptions: RequestOptions = {},
   ) {
     const defaultOptions = {
       presence: false,
@@ -1867,6 +1879,7 @@ export class StreamChat {
           ...options,
         },
       },
+      requestOptions,
     );
 
     this.state.updateUsers(data.users);
@@ -1918,13 +1931,17 @@ export class StreamChat {
    * searchUserGroups - Search user groups by prefix for autocomplete
    *
    * @param {SearchUserGroupsOptions} options The search options
-   *
+   * @param {RequestOptions} [requestOptions] Carries an abort signal. Not sent in the request.
    * @return {Promise<SearchUserGroupsResponse>} User Group Search Response
    */
-  async searchUserGroups(options: SearchUserGroupsOptions) {
+  async searchUserGroups(
+    options: SearchUserGroupsOptions,
+    requestOptions: RequestOptions = {},
+  ) {
     return await this.get<SearchUserGroupsResponse>(
       this.baseURL + '/usergroups/search',
       options,
+      requestOptions,
     );
   }
 
@@ -2061,6 +2078,7 @@ export class StreamChat {
    * @param {ChannelSort} [sort] Sort options, for instance {created_at: -1}.
    * When using multiple fields, make sure you use array of objects to guarantee field order, for instance [{last_updated: -1}, {created_at: 1}]
    * @param {ChannelOptions} [options] Options object. Can include predefined_filter, filter_values, and sort_values for using predefined filters.
+   * @param {RequestOptions} [requestOptions] Carries an abort signal. Not sent in the request.
    *
    * @return {Promise<QueryChannelsAPIResponse>} full search channels response
    */
@@ -2068,6 +2086,7 @@ export class StreamChat {
     filterConditions: ChannelFilters,
     sort: ChannelSort = [],
     options: ChannelOptions = {},
+    requestOptions: RequestOptions = {},
   ): Promise<QueryChannelsAPIResponse> {
     const defaultOptions: ChannelOptions = {
       state: true,
@@ -2101,7 +2120,11 @@ export class StreamChat {
           ...restOptions,
         };
 
-    return await this.post<QueryChannelsAPIResponse>(this.baseURL + '/channels', payload);
+    return await this.post<QueryChannelsAPIResponse>(
+      this.baseURL + '/channels',
+      payload,
+      requestOptions,
+    );
   }
 
   /**
@@ -2147,6 +2170,7 @@ export class StreamChat {
    * - stateOptions.skipInitialization - Skips the initialization of the state for the channels matching the ids in the list.
    * - stateOptions.skipHydration - Skips returning the channels as instances of the Channel class and rather returns the raw query response.
    * - stateOptions.withResponse - Returns the full query response with hydrated channels. This is a compatibility bridge for internal callers that need response-level metadata while the default return value remains `Channel[]`.
+   * - stateOptions.signal - Aborts the request. See AbortController.
    *
    * @return {Promise<Array<Channel>>} search channels response
    */
@@ -2172,6 +2196,8 @@ export class StreamChat {
       filterConditions,
       sort,
       options,
+      // stateOptions is never serialized, so it carries the abort signal
+      { signal: stateOptions.signal },
     );
     const channels = queryChannelsResponse.channels;
 
@@ -2317,6 +2343,7 @@ export class StreamChat {
    * @param {ChannelFilters} filterConditions MongoDB style filter conditions
    * @param {MessageFilters | string} query search query or object MongoDB style filters
    * @param {SearchOptions} [options] Option object, {user_id: 'tommaso'}
+   * @param {RequestOptions} [requestOptions] Carries an abort signal. Not sent in the request.
    *
    * @return {Promise<SearchAPIResponse>} search messages response
    */
@@ -2324,6 +2351,7 @@ export class StreamChat {
     filterConditions: ChannelFilters,
     query: string | MessageFilters,
     options: SearchOptions = {},
+    requestOptions: RequestOptions = {},
   ) {
     if (options.offset && options.next) {
       throw Error(`Cannot specify offset with next`);
@@ -2346,7 +2374,11 @@ export class StreamChat {
     // Make sure we wait for the connect promise if there is a pending one
     await this.wsPromise;
 
-    return await this.get<SearchAPIResponse>(this.baseURL + '/search', { payload });
+    return await this.get<SearchAPIResponse>(
+      this.baseURL + '/search',
+      { payload },
+      requestOptions,
+    );
   }
 
   /**
@@ -3806,6 +3838,12 @@ export class StreamChat {
       ...axiosRequestConfigRest
     } = this.options.axiosRequestConfig || {};
 
+    // Most specific wins, and it is spread last so that a config carrying an explicit
+    // `signal: undefined` cannot clobber a client-wide one or an armed
+    // nextRequestAbortController.
+    const resolvedSignal =
+      options.config?.signal ?? axiosRequestConfigRest.signal ?? signal;
+
     return {
       params: {
         user_id: this.userID,
@@ -3821,9 +3859,9 @@ export class StreamChat {
         ...options.headers,
         ...(axiosRequestConfigHeaders || {}),
       },
-      ...(signal ? { signal } : {}),
       ...options.config,
-      ...(axiosRequestConfigRest || {}),
+      ...axiosRequestConfigRest,
+      ...(resolvedSignal ? { signal: resolvedSignal } : {}),
     };
   }
 
@@ -3993,8 +4031,12 @@ export class StreamChat {
    *
    * @returns {Promise<APIResponse>}
    */
-  searchRoles(options: SearchRolesOptions) {
-    return this.get<SearchRolesAPIResponse>(`${this.baseURL}/roles/search`, options);
+  searchRoles(options: SearchRolesOptions, requestOptions: RequestOptions = {}) {
+    return this.get<SearchRolesAPIResponse>(
+      `${this.baseURL}/roles/search`,
+      options,
+      requestOptions,
+    );
   }
 
   /** deleteRole - deletes a custom role

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/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,

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;
   }
 
   /**
@@ -111,14 +124,27 @@ export class OfflineDBSyncManager {
    */
   private invokeSyncStatusListeners = async (status: boolean) => {
     this.syncStatus = status;
-    this.syncStatusListeners.forEach((l) => l(status));
+    this.syncStatusListeners.forEach((l) => {
+      try {
+        l(status);
+      } catch (error) {
+        console.log('Error in a sync status listener.', error);
+      }
+    });
 
     if (status) {
-      const promises = Array.from(this.scheduledSyncStatusCallbacks.values()).map((cb) =>
-        cb(),
+      const promises = Array.from(this.scheduledSyncStatusCallbacks.values()).map(
+        async (cb) => {
+          try {
+            await cb();
+          } catch (error) {
+            console.log('Error executing a scheduled sync status callback.', error);
+          }
+        },
       );
+      // Every callback is isolated above, so Promise.all never rejects and clear()
+      // always runs (no double-execution on the next sync).
       await Promise.all(promises);
-
       this.scheduledSyncStatusCallbacks.clear();
     }
   };
@@ -160,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);
+            }
           }
         }
       }
@@ -198,9 +239,27 @@ export class OfflineDBSyncManager {
 
   /**
    * Executes any tasks that were queued while offline and then performs a sync.
+   *
+   * Each step is isolated so a failure in one does not prevent the other, and
+   * neither can escape to the callers (init + the connection.changed handler).
+   * This guarantees the subsequent invokeSyncStatusListeners(true) always runs,
+   * so syncStatus recovers to true and gated channel queries are unblocked.
+   * Failed syncs degrade to "possibly stale data until the next query" rather
+   * than freezing all future queries. See issue #1816.
    */
   private syncAndExecutePendingTasks = async () => {
-    await this.offlineDb.executePendingTasks();
-    await this.sync();
+    try {
+      await this.offlineDb.executePendingTasks();
+    } catch (error) {
+      console.log('Error executing pending tasks during sync.', error);
+    }
+    // Note: sync() has its own try/catch, but its catch block calls resetDB(),
+    // which can itself throw on a corrupted DB and re-reject. This outer guard
+    // absorbs that case.
+    try {
+      await this.sync();
+    } catch (error) {
+      console.log('Error while syncing the DB.', error);
+    }
   };
 }