stream-chat 9.50.3 → 9.52.0

package/src/search/ChannelSearchSource.ts

@@ -1,4 +1,4 @@
-import { BaseSearchSource } from './BaseSearchSource';
+import { BaseSearchSource, type SearchQueryOptions } from './BaseSearchSource';
 import type { FilterBuilderOptions } from '../pagination';
 import { FilterBuilder } from '../pagination';
 import type { Channel } from '../channel';
@@ -12,6 +12,13 @@ export type ChannelSearchSourceFilterBuilderContext<
   C extends CustomContext = CustomContext,
 > = { searchQuery?: string } & C;
 
+export type ChannelSearchSourceOptions = SearchSourceOptions & {
+  /** Static base filters merged under the dynamically generated ones. */
+  filters?: ChannelFilters;
+  sort?: ChannelSort;
+  searchOptions?: Omit<ChannelOptions, 'limit' | 'offset'>;
+};
+
 export class ChannelSearchSource<
   TFilterContext extends CustomContext = CustomContext,
 > extends BaseSearchSource<Channel> {
@@ -27,14 +34,18 @@ export class ChannelSearchSource<
 
   constructor(
     client: StreamChat,
-    options?: SearchSourceOptions,
+    options?: ChannelSearchSourceOptions,
     filterBuilderOptions: FilterBuilderOptions<
       ChannelFilters,
       ChannelSearchSourceFilterBuilderContext<TFilterContext>
     > = {},
   ) {
-    super(options);
+    const { filters, sort, searchOptions, ...restOptions } = options || {};
+    super(restOptions);
     this.client = client;
+    this.filters = filters;
+    this.sort = sort;
+    this.searchOptions = searchOptions;
     this.filterBuilder = new FilterBuilder<
       ChannelFilters,
       ChannelSearchSourceFilterBuilderContext<TFilterContext>
@@ -51,7 +62,7 @@ export class ChannelSearchSource<
     });
   }
 
-  protected async query(searchQuery: string) {
+  protected async query(searchQuery: string, queryOptions: SearchQueryOptions = {}) {
     const filters = this.filterBuilder.buildFilters({
       baseFilters: {
         ...(this.client.userID ? { members: { $in: [this.client.userID] } } : {}),
@@ -63,7 +74,7 @@ export class ChannelSearchSource<
     });
     const sort = this.sort ?? {};
     const options = { ...this.searchOptions, limit: this.pageSize, offset: this.offset };
-    const items = await this.client.queryChannels(filters, sort, options);
+    const items = await this.client.queryChannels(filters, sort, options, queryOptions);
     return { items };
   }
 

package/src/search/MessageSearchSource.ts

@@ -1,4 +1,4 @@
-import { BaseSearchSource } from './BaseSearchSource';
+import { BaseSearchSource, type SearchQueryOptions } from './BaseSearchSource';
 import type {
   ChannelFilters,
   ChannelOptions,
@@ -54,6 +54,18 @@ export type MessageSearchSourceFilterBuilderOptions<
   >;
 }>;
 
+export type MessageSearchSourceOptions = SearchSourceOptions & {
+  /** Static base filters for the channel scope of the message search. */
+  messageSearchChannelFilters?: ChannelFilters;
+  /** Static base filters for the message search itself. */
+  messageSearchFilters?: MessageFilters;
+  messageSearchSort?: SearchMessageSort;
+  /** Static base filters for the follow-up query that hydrates unknown channels. */
+  channelQueryFilters?: ChannelFilters;
+  channelQuerySort?: ChannelSort;
+  channelQueryOptions?: Omit<ChannelOptions, 'limit' | 'offset'>;
+};
+
 export class MessageSearchSource<
   TContexts extends MessageSearchSourceContexts = {},
 > extends BaseSearchSource<MessageResponse> {
@@ -86,11 +98,26 @@ export class MessageSearchSource<
 
   constructor(
     client: StreamChat,
-    options?: SearchSourceOptions,
+    options?: MessageSearchSourceOptions,
     filterBuilderOptions?: MessageSearchSourceFilterBuilderOptions<TContexts>,
   ) {
-    super(options);
+    const {
+      messageSearchChannelFilters,
+      messageSearchFilters,
+      messageSearchSort,
+      channelQueryFilters,
+      channelQuerySort,
+      channelQueryOptions,
+      ...restOptions
+    } = options || {};
+    super(restOptions);
     this.client = client;
+    this.messageSearchChannelFilters = messageSearchChannelFilters;
+    this.messageSearchFilters = messageSearchFilters;
+    this.messageSearchSort = messageSearchSort;
+    this.channelQueryFilters = channelQueryFilters;
+    this.channelQuerySort = channelQuerySort;
+    this.channelQueryOptions = channelQueryOptions;
 
     this.messageSearchChannelFilterBuilder = new FilterBuilder<
       ChannelFilters,
@@ -129,7 +156,7 @@ export class MessageSearchSource<
     });
   }
 
-  protected async query(searchQuery: string) {
+  protected async query(searchQuery: string, queryOptions: SearchQueryOptions = {}) {
     if (!this.client.userID || this.next === null) return { items: [] };
 
     const channelFilters = this.messageSearchChannelFilterBuilder.buildFilters({
@@ -170,9 +197,13 @@ export class MessageSearchSource<
       channelFilters,
       messageFilters,
       options,
+      queryOptions,
     );
     const items = results.map(({ message }) => message);
 
+    // a newer query already replaced this one - skip the cid scan and the hydration request
+    if (queryOptions.signal?.aborted) return { items, next };
+
     const cids = Array.from(
       items.reduce((acc, message) => {
         if (message.cid && !this.client.activeChannels[message.cid]) acc.add(message.cid);
@@ -194,6 +225,7 @@ export class MessageSearchSource<
           ...this.channelQuerySort,
         },
         this.channelQueryOptions,
+        queryOptions,
       );
     }
 

package/src/search/UserSearchSource.ts

@@ -1,4 +1,4 @@
-import { BaseSearchSource } from './BaseSearchSource';
+import { BaseSearchSource, type SearchQueryOptions } from './BaseSearchSource';
 import { FilterBuilder, type FilterBuilderOptions } from '../pagination';
 import type { StreamChat } from '../client';
 import type { UserFilters, UserOptions, UserResponse, UserSort } from '../types';
@@ -10,6 +10,13 @@ export type UserSearchSourceFilterBuilderContext<
   C extends CustomContext = CustomContext,
 > = { searchQuery?: string } & C;
 
+export type UserSearchSourceOptions = SearchSourceOptions & {
+  /** Static base filters merged under the dynamically generated ones. */
+  filters?: UserFilters;
+  sort?: UserSort;
+  searchOptions?: Omit<UserOptions, 'limit' | 'offset'>;
+};
+
 export class UserSearchSource<
   TFilterContext extends CustomContext = CustomContext,
 > extends BaseSearchSource<UserResponse> {
@@ -25,14 +32,18 @@ export class UserSearchSource<
 
   constructor(
     client: StreamChat,
-    options?: SearchSourceOptions,
+    options?: UserSearchSourceOptions,
     filterBuilderOptions: FilterBuilderOptions<
       UserFilters,
       UserSearchSourceFilterBuilderContext<TFilterContext>
     > = {},
   ) {
-    super(options);
+    const { filters, sort, searchOptions, ...restOptions } = options || {};
+    super(restOptions);
     this.client = client;
+    this.filters = filters;
+    this.sort = sort;
+    this.searchOptions = searchOptions;
     this.filterBuilder = new FilterBuilder<
       UserFilters,
       UserSearchSourceFilterBuilderContext<TFilterContext>
@@ -55,7 +66,7 @@ export class UserSearchSource<
     });
   }
 
-  protected async query(searchQuery: string) {
+  protected async query(searchQuery: string, queryOptions: SearchQueryOptions = {}) {
     const filters = this.filterBuilder.buildFilters({
       baseFilters: this.filters,
       context: { searchQuery } as UserSearchSourceFilterBuilderContext<TFilterContext>,
@@ -68,7 +79,7 @@ export class UserSearchSource<
       sort = { id: 1, ...this.sort };
     }
     const options = { ...this.searchOptions, limit: this.pageSize, offset: this.offset };
-    const { users } = await this.client.queryUsers(filters, sort, options);
+    const { users } = await this.client.queryUsers(filters, sort, options, queryOptions);
     return { items: users };
   }
 

package/src/search/types.ts

@@ -11,8 +11,21 @@ export type SearchSourceState<T = any> = {
 };
 
 export type SearchSourceOptions = {
-  /** The number of milliseconds to debounce the search query. The default interval is 300ms. */
+  /**
+   * Legacy single debounce interval. When set, it applies to both short and long queries,
+   * unless overridden by `shortQueryDebounceMs` / `longQueryDebounceMs`.
+   */
   debounceMs?: number;
+  /**
+   * Debounce interval for queries no longer than `shortQueryMaxLength`. Such queries have
+   * low selectivity and are expensive server-side, so they are debounced harder.
+   * Defaults to 500ms.
+   */
+  shortQueryDebounceMs?: number;
+  /** Debounce interval for queries longer than `shortQueryMaxLength`. Defaults to 300ms. */
+  longQueryDebounceMs?: number;
+  /** Query length (inclusive) that still counts as short. Defaults to 2. */
+  shortQueryMaxLength?: number;
   pageSize?: number;
   /** When true, the source can execute queries with an empty search string. Defaults to false. */
   allowEmptySearchString?: boolean;

package/src/types.ts

@@ -1189,7 +1189,13 @@ export type ChannelQueryOptions = {
   watchers?: PaginationOptions;
 };
 
-export type ChannelStateOptions = {
+/**
+ * Composed with RequestOptions because `queryChannels` carries the abort signal in this
+ * bag; neither the state flags nor the signal are serialized into the request. Declaring
+ * the composition keeps passing a RequestOptions here intentional rather than incidental
+ * structural compatibility.
+ */
+export type ChannelStateOptions = RequestOptions & {
   offlineMode?: boolean;
   skipInitialization?: string[];
   skipHydration?: boolean;
@@ -1573,6 +1579,12 @@ export type SearchOptions = {
   sort?: SearchMessageSort;
 };
 
+/** Per-request options that are never part of the serialized request payload. */
+export type RequestOptions = {
+  /** Aborts the request. See AbortController. */
+  signal?: AbortSignal;
+};
+
 export type StreamChatOptions = AxiosRequestConfig & {
   /**
    * Used to disable warnings that are triggered by using connectUser or connectAnonymousUser server-side.

package/src/uploadManager.ts

@@ -1,10 +1,44 @@
+import axios from 'axios';
+
 import type { StreamChat } from './client';
 import type { UploadRequestOptions } from './messageComposer/configuration/types';
 import { StateStore } from './store';
 import type { AttachmentManager } from '.';
 
+/**
+ * Whether an upload ended because it was aborted rather than because it failed.
+ *
+ * {@link UploadManager.deleteUploadRecord} and {@link UploadManager.cancelAllUploads} abort the
+ * request through its `AbortController`, which is what happens when an attachment is removed
+ * from the composer mid-upload or the client disconnects. Axios reports that as a
+ * `CanceledError` (`axios.isCancel`); a custom `doUploadRequest` on another transport
+ * conventionally throws a `DOMException` named `AbortError`.
+ *
+ * Callers use this to keep a deliberate cancellation from being reported as an error.
+ */
+export const isUploadCancellation = (error: unknown) =>
+  axios.isCancel(error) || (error instanceof Error && error.name === 'AbortError');
+
 export type UploadRecord = {
   id: string;
+  /**
+   * `true` once every byte has been handed to the transport but the server has not responded
+   * yet.
+   *
+   * Upload progress measures bytes *written to the connection*, not bytes the server
+   * acknowledged, so it reaches 100% the moment the request body is flushed — then the
+   * connection sits idle while the CDN ingests the file and the response travels back. On a
+   * large file over a slow link that window is long, and a UI that renders 100% as "done"
+   * claims the upload is confirmed while it is not.
+   *
+   * Nothing measurable happens during that window, so it is the point at which a determinate
+   * progress bar should hand over to an indeterminate one. Confirmation is the record being
+   * removed, not progress reaching 100.
+   *
+   * Requires `AttachmentManagerConfig.trackUploadProgress`; without progress reporting there is
+   * no way to tell when the flush happened, and this stays `false`.
+   */
+  uploadConfirmationPending?: boolean;
   uploadProgress?: number;
 };
 
@@ -126,6 +160,7 @@ export class UploadManager {
       const trackProgress = attachmentManager.config.trackUploadProgress;
       try {
         this.upsertUpload({
+          uploadConfirmationPending: false,
           id,
           uploadProgress: trackProgress ? 0 : undefined,
         });
@@ -135,6 +170,16 @@ export class UploadManager {
               this.updateUpload({
                 id,
                 uploadProgress: progress,
+                // Only a number says anything about the flush, so a report without one leaves
+                // the flag alone: `undefined` means the transport cannot measure this upload,
+                // not that bytes were un-sent. Lowering it there would drop a UI that had
+                // already gone indeterminate back to a determinate one with nothing to show.
+                //
+                // The record is removed in the `finally` below, so a record that still exists
+                // while reporting 100% can only mean "flushed, awaiting the response".
+                ...(typeof progress === 'number'
+                  ? { uploadConfirmationPending: progress >= 100 }
+                  : {}),
               });
             }
           : undefined;

package/src/utils.ts

@@ -1,6 +1,7 @@
 import FormData from 'form-data';
 import type {
   AscDesc,
+  Attachment,
   ChannelFilters,
   ChannelQueryOptions,
   ChannelSort,
@@ -382,6 +383,77 @@ export function unformatMessage(message: LocalMessage): MessageResponse {
   } as MessageResponse;
 }
 
+/**
+ * Whether a URL points at something the API and other devices can actually fetch.
+ */
+const isRemoteUrl = (url?: string) => !!url && /^https?:\/\//i.test(url.trim());
+
+/**
+ * Strips composer-internal state from a message's attachments, and drops any whose upload never
+ * resolved.
+ *
+ * `localMetadata` is how `AttachmentManager` tracks an upload (its id, the `File`, the local
+ * preview); it must never reach the API. An attachment that still carries it and has no remote
+ * URL was never settled — which is what happens when
+ * `createSendWithPendingUploadsAttachmentsMiddleware` is installed by a UI SDK that does not
+ * implement the rest of the flow (awaiting those uploads before sending). Sending it would store
+ * an attachment pointing at nothing, so it is dropped and logged instead.
+ *
+ * Returns the same message object when there was nothing to change.
+ */
+export const sanitizeOutgoingAttachments = <T extends { attachments?: Attachment[] }>({
+  client,
+  message,
+}: {
+  client: StreamChat;
+  message: T;
+}): T => {
+  const attachments = message.attachments;
+  if (!attachments?.length) return message;
+
+  const unresolved: Attachment[] = [];
+  let changed = false;
+
+  const sanitized = attachments.reduce<Attachment[]>((acc, attachment) => {
+    const { localMetadata, ...rest } = attachment as Attachment & {
+      localMetadata?: Record<string, unknown>;
+    };
+
+    if (!localMetadata) {
+      acc.push(attachment);
+      return acc;
+    }
+
+    changed = true;
+
+    // Any of these pointing at a remote URL means the attachment resolved to something the API
+    // can store and other devices can load.
+    const hasRemoteSource =
+      isRemoteUrl(rest.asset_url) ||
+      isRemoteUrl(rest.image_url) ||
+      isRemoteUrl(rest.og_scrape_url) ||
+      isRemoteUrl(rest.title_link);
+
+    if (hasRemoteSource) {
+      acc.push(rest as Attachment);
+    } else {
+      unresolved.push(rest as Attachment);
+    }
+
+    return acc;
+  }, []);
+
+  if (unresolved.length) {
+    const text = `Dropped ${unresolved.length} attachment(s) whose upload never completed. Composing with pending uploads requires awaiting them before sending.`;
+    const extraData = { attachments: unresolved, message, tags: ['attachments'] };
+
+    client.logger('warn', text, extraData);
+    console.warn(text, extraData);
+  }
+
+  return changed ? { ...message, attachments: sanitized } : message;
+};
+
 export const localMessageToNewMessagePayload = (localMessage: LocalMessage): Message => {
   /* eslint-disable @typescript-eslint/no-unused-vars */
   const {
@@ -723,11 +795,13 @@ export interface DebouncedFunc<T extends (...args: any[]) => any> {
   flush(): ReturnType<T> | undefined;
 }
 
-// works exactly the same as lodash.debounce
+// works exactly the same as lodash.debounce, except that the timeout can also be
+// a function of the call arguments, resolved on every call (e.g. to debounce short,
+// low-selectivity search queries harder than long ones)
 // eslint-disable-next-line @typescript-eslint/no-explicit-any
 export const debounce = <T extends (...args: any[]) => any>(
   fn: T,
-  timeout = 0,
+  timeout: number | ((...args: Parameters<T>) => number) = 0,
   { leading = false, trailing = true }: { leading?: boolean; trailing?: boolean } = {},
 ): DebouncedFunc<T> => {
   let runningTimeout: null | NodeJS.Timeout = null;
@@ -750,7 +824,8 @@ export const debounce = <T extends (...args: any[]) => any>(
       runningTimeout = null;
     };
 
-    runningTimeout = setTimeout(timeoutHandler, timeout);
+    const delay = typeof timeout === 'function' ? timeout(...args) : timeout;
+    runningTimeout = setTimeout(timeoutHandler, delay);
     return lastResult;
   };