stream-chat 9.52.1 → 9.54.0

package/dist/types/channel_batch_updater.d.ts

@@ -1,5 +1,5 @@
 import type { StreamChat } from './client';
-import type { APIResponse, BatchChannelDataUpdate, NewMemberPayload, UpdateChannelsBatchFilters, UpdateChannelsBatchResponse } from './types';
+import type { APIResponse, BatchChannelDataUpdate, ChannelBatchDataUpdateOptions, NewMemberPayload, UpdateChannelsBatchFilters, UpdateChannelsBatchResponse } from './types';
 /**
  * ChannelBatchUpdater - A class that provides convenience methods for batch channel operations
  */
@@ -85,9 +85,16 @@ export declare class ChannelBatchUpdater {
     /**
      * updateData - Update data on channels matching the filter
      *
+     * `data.custom` replaces the channel's whole custom object. To patch
+     * individual custom keys, pass an options object with `custom_set` or
+     * `custom_unset`. The client sends those fields at the request root rather
+     * than inside `data`. The options object can also include `data` to update
+     * channel fields in the same request.
+     *
      * @param {UpdateChannelsBatchFilters} filter Filter to select channels
-     * @param {BatchChannelDataUpdate} data Data to update
+     * @param {BatchChannelDataUpdate | ChannelBatchDataUpdateOptions} update Data or update options
      * @return {Promise<APIResponse & UpdateChannelsBatchResponse>} The server response
      */
     updateData(filter: UpdateChannelsBatchFilters, data: BatchChannelDataUpdate): Promise<APIResponse & UpdateChannelsBatchResponse>;
+    updateData(filter: UpdateChannelsBatchFilters, options: ChannelBatchDataUpdateOptions): Promise<APIResponse & UpdateChannelsBatchResponse>;
 }

package/dist/types/client.d.ts

@@ -105,6 +105,10 @@ export declare class StreamChat {
     wsConnection: StableWSConnection | null;
     wsFallback?: WSConnectionFallback;
     wsPromise: ConnectAPIResponse | null;
+    private _wsPromiseSettled;
+    private _wsConnectId;
+    private _resolveWsPromise?;
+    private _rejectWsPromise?;
     consecutiveFailures: number;
     insightMetrics: InsightMetrics;
     defaultWSTimeoutWithFallback: number;
@@ -224,6 +228,15 @@ export declare class StreamChat {
      * Creates a new WebSocket connection with the current user. Returns empty promise, if there is an active connection
      */
     openConnection: () => ConnectAPIResponse | undefined;
+    /**
+     * Rejects the shared `wsPromise`, invalidates any in-flight connect attempt
+     */
+    private _rejectPendingWsPromise;
+    /**
+     * Keep a single pending `wsPromise` across close/reopen so callers that already
+     * `await this.wsPromise` are not stranded when `openConnection` starts a new connect.
+     */
+    private _bindWsPromise;
     /**
      * @deprecated Please use client.openConnction instead.
      * @private
@@ -1140,9 +1153,7 @@ export declare class StreamChat {
         created_at?: string;
         deleted_at?: string;
         deleted_reply_count?: number;
-        i18n?: import("./types").RequireAtLeastOne<Record<`${import("./types").TranslationLanguages}_text`, string>> & {
-            language: import("./types").TranslationLanguages;
-        };
+        i18n?: import("./types").TranslatedField;
         latest_reactions?: ReactionResponse[];
         member?: import("./types").ChannelMemberResponse;
         mentioned_users?: UserResponse[];
@@ -1878,9 +1889,7 @@ export declare class StreamChat {
         created_at?: string;
         deleted_at?: string;
         deleted_reply_count?: number;
-        i18n?: import("./types").RequireAtLeastOne<Record<`${import("./types").TranslationLanguages}_text`, string>> & {
-            language: import("./types").TranslationLanguages;
-        };
+        i18n?: import("./types").TranslatedField;
         latest_reactions?: ReactionResponse[];
         member?: import("./types").ChannelMemberResponse;
         mentioned_users?: UserResponse[];
@@ -2183,6 +2192,10 @@ export declare class StreamChat {
     /**
      *  Update Channels Batch
      *
+     *  For the `updateData` operation, `data.custom` replaces the channel's whole
+     *  custom object, while the root-level `custom_set` / `custom_unset` patch
+     *  individual keys and leave the rest untouched.
+     *
      *  @param {UpdateChannelsBatchOptions} payload for updating channels in batch
      *  @return {Promise<APIResponse & UpdateChannelsBatchResponse>} The server response
      */

package/dist/types/poll.d.ts

@@ -29,10 +29,13 @@ export declare class Poll {
     readonly state: StateStore<PollState>;
     id: string;
     private client;
+    private optimisticVotes;
+    private closeConfirmed;
     constructor({ client, poll }: PollInitOptions);
     private getInitialStateFromPollResponse;
     private upsertOfflineDb;
     reinitializeState: (poll: PollInitOptions["poll"]) => void;
+    private updateFromVoteEvent;
     get data(): PollState;
     handlePollUpdated: (event: Event) => void;
     handlePollClosed: (event: Event) => void;
@@ -42,15 +45,30 @@ export declare class Poll {
     query: (id: string) => Promise<PollResponse>;
     update: (data: Exclude<PollData, "id">) => Promise<import("./types").APIResponse & import("./types").UpdatePollAPIResponse>;
     partialUpdate: (partialPollObject: PartialPollUpdate) => Promise<import("./types").APIResponse & import("./types").UpdatePollAPIResponse>;
-    close: () => Promise<import("./types").APIResponse & import("./types").UpdatePollAPIResponse>;
+    /**
+     * Closes the poll. The poll is marked as closed optimistically and the change is
+     * reverted if the request fails, unless the server confirmed the close meanwhile.
+     * Does nothing if the poll is already closed.
+     */
+    close: () => Promise<(import("./types").APIResponse & import("./types").UpdatePollAPIResponse) | undefined>;
     delete: () => Promise<import("./types").APIResponse>;
     createOption: (option: PollOptionData) => Promise<import("./types").APIResponse & import("./types").CreatePollOptionAPIResponse>;
     updateOption: (option: PollOptionData) => Promise<import("./types").APIResponse & import("./types").CreatePollOptionAPIResponse>;
     deleteOption: (optionId: string) => Promise<import("./types").APIResponse>;
+    /**
+     * Casts a vote for an option. The vote is shown right away through a local placeholder vote,
+     * which the server's vote replaces once the WS events of all pending vote changes arrived.
+     * If the request fails, the change is reverted.
+     */
     castVote: (optionId: string, messageId: string) => Promise<(import("./types").APIResponse & import("./types").CastVoteAPIResponse) | undefined>;
-    removeVote: (voteId: string, messageId: string) => Promise<import("./types").APIResponse & {
+    /**
+     * Removes a vote. The vote is removed right away and restored if the request fails. Vote
+     * requests are sent in order, so removing a vote whose cast is not confirmed yet uses the vote
+     * id from the cast's response; if that cast failed, there is nothing to remove.
+     */
+    removeVote: (voteId: string, messageId: string) => Promise<(import("./types").APIResponse & {
         vote: PollVote;
-    }>;
+    }) | undefined>;
     addAnswer: (answerText: string, messageId: string) => Promise<import("./types").APIResponse & import("./types").CastVoteAPIResponse>;
     removeAnswer: (answerId: string, messageId: string) => Promise<import("./types").APIResponse & {
         vote: PollVote;
@@ -59,6 +77,6 @@ export declare class Poll {
     queryOptionVotes: (params: PollOptionVotesQueryParams) => Promise<import("./types").APIResponse & import("./types").PollVotesAPIResponse>;
 }
 export declare function extractPollData(pollResponse: PollResponse): PollData;
-export declare function mapPollStateToResponse(poll: Poll): PollResponse;
+export declare function mapPollStateToResponse(poll: Poll, state?: PollState): PollResponse;
 export declare function extractPollEnrichedData(pollResponse: PollResponse): Omit<PollEnrichData, 'own_votes' | 'latest_answers'>;
 export {};

package/dist/types/poll_optimistic_votes.d.ts

@@ -0,0 +1,63 @@
+import type { StreamChat } from './client';
+import type { Poll, PollState } from './poll';
+import type { PollResponse, PollVote } from './types';
+type OptionId = string;
+/**
+ * Optimistic updates for the current user's votes on a poll. Vote changes are shown right away.
+ * While any of them is not confirmed by its WS event, vote events are only stored, as the server
+ * state they carry does not contain the pending changes yet. Once all are confirmed (a failed
+ * request counts as confirmed), the server's vote state is shown, which also reverts failed changes.
+ * Vote requests are sent one after another, so the server applies them in the order they were made.
+ * A lost WS event is recovered from after CATCH_UP_TIMEOUT_MS (see applySucceededChanges).
+ */
+export declare class OptimisticPollVotes {
+    private serverVoteState;
+    private pendingCount;
+    private succeededChanges;
+    private readonly requestTag;
+    private catchUpTimeout?;
+    private readonly client;
+    private readonly poll;
+    constructor({ client, poll }: {
+        client: StreamChat;
+        poll: Poll;
+    });
+    get serverOwnVotes(): Record<string, PollVote>;
+    withServerVotes: (pollState: PollState) => PollState;
+    /**
+     * Casts a vote for an option, shown right away through a placeholder vote. In polls with unique
+     * votes, it replaces the existing own votes.
+     */
+    castVote: (optionId: OptionId, messageId: string) => Promise<(import("./types").APIResponse & import("./types").CastVoteAPIResponse) | undefined>;
+    removeVote: (voteId: string, messageId: string) => Promise<(import("./types").APIResponse & {
+        vote: PollVote;
+    }) | undefined>;
+    private send;
+    handleVoteEvent: (poll: PollResponse, { confirmsOwnVote, ownVotesByOptionId, }: {
+        confirmsOwnVote: boolean;
+        ownVotesByOptionId: Record<OptionId, PollVote>;
+    }) => Partial<PollState>;
+    reset: (pollState: PollState) => void;
+    private track;
+    private settleWithoutEvent;
+    private createPlaceholderVote;
+    /**
+     * The server id of a vote to remove, once everything sent before the removal has finished. Casts
+     * and removals of an option alternate, so the option's last succeeded change tells: a cast is the
+     * vote being removed (e.g. a placeholder), a removal means the cast in between failed. Without
+     * one, the server's own vote of the option is the vote being removed.
+     */
+    private getServerVoteId;
+    private takeServerVoteState;
+    private scheduleCatchUp;
+    /**
+     * A WS event of an own vote change got lost, so the server's own votes are stale. All requests
+     * have finished (the timeout starts once nothing is left to send and a new request cancels it),
+     * so applying the succeeded changes in order gives the server's own votes (changes whose events
+     * did arrive end up the same). They are shown with the vote counts of the last WS event, which
+     * contain the other users' votes too.
+     */
+    private applySucceededChanges;
+}
+export declare function getMaxVotedOptionIds(voteCountsByOption: PollResponse['vote_counts_by_option']): string[];
+export {};

package/dist/types/types.d.ts

@@ -48,6 +48,7 @@ export type TranslateResponse = {
 export type AppSettingsAPIResponse = APIResponse & {
     app?: {
         id?: string | number;
+        activity_metrics_config?: Record<string, number>;
         allow_multi_user_devices?: boolean;
         feed_audit_logs_enabled?: boolean;
         moderation_onboarding_complete?: boolean | null;
@@ -91,8 +92,10 @@ export type AppSettingsAPIResponse = APIResponse & {
         auto_translation_enabled?: boolean;
         before_message_send_hook_url?: string;
         before_message_send_hook_attempt_timeout_ms?: number;
+        before_message_send_hook_system_messages?: boolean;
         campaign_enabled?: boolean;
         cdn_expiration_seconds?: number;
+        chat_primary_use_case?: string;
         custom_action_handler_url?: string;
         datadog_info?: {
             api_key: string;
@@ -117,13 +120,18 @@ export type AppSettingsAPIResponse = APIResponse & {
         image_upload_config?: FileUploadConfig;
         allowed_flag_reasons?: string[];
         max_aggregated_activities_length?: number;
+        member_custom_on_mentioned_users_enabled?: boolean;
+        member_custom_on_messages_enabled?: boolean;
+        member_custom_on_typing_events_enabled?: boolean;
         moderation_bulk_submit_action_enabled?: boolean;
         moderation_dashboard_preferences?: Record<string, unknown> | null;
         moderation_audio_call_moderation_enabled?: boolean;
         moderation_enabled?: boolean;
         moderation_flood_rules_enabled?: boolean;
+        moderation_keyframe_video_enabled?: boolean;
         moderation_llm_configurability_enabled?: boolean;
         moderation_multitenant_blocklist_enabled?: boolean;
+        moderation_s3_image_access_role_arn?: string;
         moderation_video_call_moderation_enabled?: boolean;
         moderation_webhook_url?: string;
         multi_tenant_enabled?: boolean;
@@ -160,6 +168,7 @@ export type AppSettingsAPIResponse = APIResponse & {
         use_hook_v2?: boolean;
         user_response_time_enabled?: boolean;
         user_search_disallowed_roles?: string[] | null;
+        video_primary_use_case?: string;
         video_provider?: string;
         webhook_events?: Array<string>;
         webhook_url?: string;
@@ -659,9 +668,7 @@ export type MessageResponseBase = MessageBase & {
     created_at?: string;
     deleted_at?: string;
     deleted_reply_count?: number;
-    i18n?: RequireAtLeastOne<Record<`${TranslationLanguages}_text`, string>> & {
-        language: TranslationLanguages;
-    };
+    i18n?: TranslatedField;
     latest_reactions?: ReactionResponse[];
     member?: ChannelMemberResponse;
     mentioned_users?: UserResponse[];
@@ -2415,6 +2422,9 @@ export type TestSNSDataInput = {
 export type TokenOrProvider = null | string | TokenProvider | undefined;
 export type TokenProvider = () => Promise<string>;
 export type TranslationLanguages = 'af' | 'am' | 'ar' | 'az' | 'bg' | 'bn' | 'bs' | 'cs' | 'da' | 'de' | 'el' | 'en' | 'es' | 'es-MX' | 'et' | 'fa' | 'fa-AF' | 'fi' | 'fr' | 'fr-CA' | 'ha' | 'he' | 'hi' | 'hr' | 'hu' | 'id' | 'it' | 'ja' | 'ka' | 'ko' | 'lt' | 'lv' | 'ms' | 'nl' | 'no' | 'pl' | 'ps' | 'pt' | 'ro' | 'ru' | 'sk' | 'sl' | 'so' | 'sq' | 'sr' | 'sv' | 'sw' | 'ta' | 'th' | 'tl' | 'tr' | 'uk' | 'ur' | 'vi' | 'zh' | 'zh-TW' | (string & {});
+export type TranslatedField = RequireAtLeastOne<Record<`${TranslationLanguages}_text`, string>> & {
+    language: TranslationLanguages;
+};
 export type TypingStartEvent = Event;
 export type ReservedUpdatedMessageFields = keyof typeof RESERVED_UPDATED_MESSAGE_FIELDS;
 export type UpdatedMessage = Omit<MessageResponse, ReservedUpdatedMessageFields | 'mentioned_groups'> & {
@@ -2687,7 +2697,9 @@ export type PollResponse = CustomPollData & PollEnrichData & {
     allow_answers?: boolean;
     allow_user_suggested_options?: boolean;
     description?: string;
+    description_i18n?: TranslatedField;
     is_closed?: boolean;
+    name_i18n?: TranslatedField;
     voting_visibility?: VotingVisibility;
 };
 export type PollOption = {
@@ -2697,6 +2709,7 @@ export type PollOption = {
     text: string;
     updated_at: string;
     vote_count: number;
+    text_i18n?: TranslatedField;
     votes?: PollVote[];
 };
 export declare enum VotingVisibility {
@@ -2760,6 +2773,7 @@ export type PollOptionResponse = CustomPollData & {
     text: string;
     updated_at: string;
     vote_count: number;
+    text_i18n?: TranslatedField;
     votes?: PollVote[];
 };
 export type PollVote = {
@@ -2774,6 +2788,7 @@ export type PollVote = {
 export type PollAnswer = Exclude<PollVote, 'option_id'> & {
     answer_text: string;
     is_answer: boolean;
+    answer_text_i18n?: TranslatedField;
 };
 export type PollVotesAPIResponse = {
     votes: (PollVote | PollAnswer)[];
@@ -3713,7 +3728,32 @@ export type UpdateChannelsBatchOptions = {
     filter: UpdateChannelsBatchFilters;
     members?: string[] | Array<NewMemberPayload>;
     data?: BatchChannelDataUpdate;
+    /**
+     * `updateData` only. Merges these keys into each matched channel's existing
+     * custom object, leaving every other custom key untouched — unlike
+     * `data.custom`, which replaces the whole object. Keys are dot-paths, so
+     * `a.b` sets key `b` inside object `a` (the parent object must already
+     * exist). Cannot be combined with `data.custom`.
+     *
+     * Lives at the request root, not inside `data`.
+     */
+    custom_set?: Record<string, unknown>;
+    /**
+     * `updateData` only. Deletes these keys from each matched channel's existing
+     * custom object, leaving every other custom key untouched. Keys are
+     * dot-paths; deleting a key that does not exist is a no-op. Cannot be
+     * combined with `data.custom`.
+     *
+     * Lives at the request root, not inside `data`.
+     */
+    custom_unset?: string[];
 };
+/**
+ * Options for {@link ChannelBatchUpdater.updateData}. `custom_set` and
+ * `custom_unset` are sent at the request root, while `data` contains the
+ * channel fields to update.
+ */
+export type ChannelBatchDataUpdateOptions = Pick<UpdateChannelsBatchOptions, 'data' | 'custom_set' | 'custom_unset'>;
 export type UpdateChannelsBatchFilters = QueryFilters<{
     cids?: RequireOnlyOne<Pick<QueryFilter<string>, '$in' | '$eq'>> | PrimitiveFilter<string[]>;
     types?: RequireOnlyOne<Pick<QueryFilter<string>, '$in' | '$eq'>> | PrimitiveFilter<string[]>;

package/dist/types/utils.d.ts

@@ -134,9 +134,7 @@ export declare const toDeletedMessage: ({ message, deletedAt, hardDelete, }: {
         [key: string]: number;
     } | null | undefined;
     reply_count?: number | undefined;
-    i18n?: (import("./types").RequireAtLeastOne<Record<`${import("./types").TranslationLanguages}_text`, string>> & {
-        language: import("./types").TranslationLanguages;
-    }) | undefined;
+    i18n?: import("./types").TranslatedField | undefined;
     html?: string | undefined;
     user?: (UserResponse | null) | undefined;
     id: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stream-chat",
-  "version": "9.52.1",
+  "version": "9.54.0",
   "description": "JS SDK for the Stream Chat API",
   "homepage": "https://getstream.io/chat/",
   "author": {

package/src/channel_batch_updater.ts

@@ -2,11 +2,17 @@ import type { StreamChat } from './client';
 import type {
   APIResponse,
   BatchChannelDataUpdate,
+  ChannelBatchDataUpdateOptions,
   NewMemberPayload,
   UpdateChannelsBatchFilters,
   UpdateChannelsBatchResponse,
 } from './types';
 
+const isChannelBatchDataUpdateOptions = (
+  update: BatchChannelDataUpdate | ChannelBatchDataUpdateOptions,
+): update is ChannelBatchDataUpdateOptions =>
+  'data' in update || 'custom_set' in update || 'custom_unset' in update;
+
 /**
  * ChannelBatchUpdater - A class that provides convenience methods for batch channel operations
  */
@@ -194,18 +200,38 @@ export class ChannelBatchUpdater {
   /**
    * updateData - Update data on channels matching the filter
    *
+   * `data.custom` replaces the channel's whole custom object. To patch
+   * individual custom keys, pass an options object with `custom_set` or
+   * `custom_unset`. The client sends those fields at the request root rather
+   * than inside `data`. The options object can also include `data` to update
+   * channel fields in the same request.
+   *
    * @param {UpdateChannelsBatchFilters} filter Filter to select channels
-   * @param {BatchChannelDataUpdate} data Data to update
+   * @param {BatchChannelDataUpdate | ChannelBatchDataUpdateOptions} update Data or update options
    * @return {Promise<APIResponse & UpdateChannelsBatchResponse>} The server response
    */
   async updateData(
     filter: UpdateChannelsBatchFilters,
     data: BatchChannelDataUpdate,
+  ): Promise<APIResponse & UpdateChannelsBatchResponse>;
+  async updateData(
+    filter: UpdateChannelsBatchFilters,
+    options: ChannelBatchDataUpdateOptions,
+  ): Promise<APIResponse & UpdateChannelsBatchResponse>;
+  async updateData(
+    filter: UpdateChannelsBatchFilters,
+    update: BatchChannelDataUpdate | ChannelBatchDataUpdateOptions,
   ): Promise<APIResponse & UpdateChannelsBatchResponse> {
+    const { data, custom_set, custom_unset } = isChannelBatchDataUpdateOptions(update)
+      ? update
+      : { data: update };
+
     return await this.client.updateChannelsBatch({
       operation: 'updateData',
       filter,
-      data,
+      ...(data && { data }),
+      ...(custom_set && { custom_set }),
+      ...(custom_unset && { custom_unset }),
     });
   }
 }

package/src/client.ts

@@ -393,6 +393,10 @@ export class StreamChat {
   wsConnection: StableWSConnection | null;
   wsFallback?: WSConnectionFallback;
   wsPromise: ConnectAPIResponse | null;
+  private _wsPromiseSettled = true;
+  private _wsConnectId = 0;
+  private _resolveWsPromise?: (value: Awaited<ConnectAPIResponse>) => void;
+  private _rejectWsPromise?: (reason?: unknown) => void;
   consecutiveFailures: number;
   insightMetrics: InsightMetrics;
   defaultWSTimeoutWithFallback: number;
@@ -713,18 +717,25 @@ export class StreamChat {
 
     const wsPromise = this.openConnection();
 
-    this.setUserPromise = Promise.all([setTokenPromise, wsPromise]).then(
+    const setUserPromise = Promise.all([setTokenPromise, wsPromise]).then(
       (result) => result[1], // We only return connection promise;
     );
+    this.setUserPromise = setUserPromise;
 
     try {
-      return await this.setUserPromise;
+      return await setUserPromise;
     } catch (err) {
-      if (this.persistUserOnConnectionFailure) {
-        // cleanup client to allow the user to retry connectUser again
-        this.closeConnection();
-      } else {
-        this.disconnectUser();
+      // disconnectUser() rejects an in-flight handshake so this catch can run *after* something else has taken over.
+      // Cleaning up then would tear down whatever replaced us. setUserPromise catches a
+      // newer connectUser(); userID additionally catches connectAnonymousUser(), which
+      // never sets setUserPromise, and a bare disconnectUser() that already cleaned up.
+      if (this.setUserPromise === setUserPromise && this.userID === user.id) {
+        if (this.persistUserOnConnectionFailure) {
+          // cleanup client to allow the user to retry connectUser again
+          this.closeConnection();
+        } else {
+          this.disconnectUser();
+        }
       }
       throw err;
     }
@@ -852,9 +863,58 @@ export class StreamChat {
     }
 
     this.clientID = `${this.userID}--${randomId()}`;
-    this.wsPromise = this.connect();
+    const wsPromise = this._bindWsPromise(this.connect());
     this._startCleaning();
-    return this.wsPromise;
+    return wsPromise;
+  };
+
+  /**
+   * Rejects the shared `wsPromise`, invalidates any in-flight connect attempt
+   */
+  private _rejectPendingWsPromise = (reason: Error) => {
+    if (!this._wsPromiseSettled) {
+      // invalidate in-flight attempts so a late settle cannot revive this promise
+      this._wsConnectId += 1;
+      this._wsPromiseSettled = true;
+      // Avoid unhandled promise rejection errors
+      this.wsPromise?.catch(() => {
+        // noop - real awaiters still observe the rejection
+      });
+      this._rejectWsPromise?.(reason);
+    }
+  };
+
+  /**
+   * Keep a single pending `wsPromise` across close/reopen so callers that already
+   * `await this.wsPromise` are not stranded when `openConnection` starts a new connect.
+   */
+  private _bindWsPromise = (connectPromise: ConnectAPIResponse): ConnectAPIResponse => {
+    const connectId = ++this._wsConnectId;
+
+    let pending = this.wsPromise;
+    if (this._wsPromiseSettled || !pending) {
+      this._wsPromiseSettled = false;
+      pending = new Promise((resolve, reject) => {
+        this._resolveWsPromise = resolve;
+        this._rejectWsPromise = reject;
+      });
+      this.wsPromise = pending;
+    }
+
+    connectPromise.then(
+      (value) => {
+        if (connectId !== this._wsConnectId) return;
+        this._wsPromiseSettled = true;
+        this._resolveWsPromise?.(value);
+      },
+      (error) => {
+        if (connectId !== this._wsConnectId) return;
+        this._wsPromiseSettled = true;
+        this._rejectWsPromise?.(error);
+      },
+    );
+
+    return pending;
   };
 
   /**
@@ -1059,6 +1119,11 @@ export class StreamChat {
 
     this.anonymous = false;
 
+    this._rejectPendingWsPromise(
+      new Error('Connection was closed because disconnectUser() was called'),
+    );
+    this.wsPromise = null;
+
     const closePromise = this.closeConnection(timeout);
 
     for (const channel of Object.values(this.activeChannels)) {
@@ -1751,7 +1816,12 @@ export class StreamChat {
       } as Event);
     }
 
-    this.wsPromise = Promise.resolve();
+    // If state recovery happens afer a failed connect (for example on persistUserOnConnectionFailure: true) we need to flip the wsPromise from rejected to resolved
+    // Otherwise all API calls that wait for the promise will fail
+    // If promise is not yet settled - we leave it for the connect sequence to resolve the promise
+    if (this._wsPromiseSettled) {
+      this.wsPromise = Promise.resolve();
+    }
     this.setUserPromise = Promise.resolve();
   };
 
@@ -5306,6 +5376,10 @@ export class StreamChat {
   /**
    *  Update Channels Batch
    *
+   *  For the `updateData` operation, `data.custom` replaces the channel's whole
+   *  custom object, while the root-level `custom_set` / `custom_unset` patch
+   *  individual keys and leave the rest untouched.
+   *
    *  @param {UpdateChannelsBatchOptions} payload for updating channels in batch
    *  @return {Promise<APIResponse & UpdateChannelsBatchResponse>} The server response
    */

package/src/messageComposer/middleware/messageComposer/linkPreviews.ts

@@ -32,12 +32,15 @@ export const createLinkPreviewsCompositionMiddleware = (
               LinkPreviewsManager.getPreviewData(preview),
             );
 
-      const attachments: Attachment[] = (state.message.attachments ?? []).concat(
+      const messageAttachments: Attachment[] = (state.message.attachments ?? []).concat(
         linkPreviews,
       );
+      const localAttachments: Attachment[] = (
+        state.localMessage.attachments ?? []
+      ).concat(linkPreviews);
 
       // prevent introducing attachments array into the payload sent to the server
-      if (!attachments.length) return forward();
+      if (!messageAttachments.length && !localAttachments.length) return forward();
 
       const sendOptions = { ...state.sendOptions };
       const skip_enrich_url =
@@ -47,16 +50,23 @@ export const createLinkPreviewsCompositionMiddleware = (
         sendOptions.skip_enrich_url = true;
       }
 
+      // Each payload gets the `attachments` key only when there is something to put in it,
+      // matching the attachments middleware. An empty array is not "nothing to say": on an edit
+      // the API reads it as "remove every attachment".
       return next({
         ...state,
-        message: {
-          ...state.message,
-          attachments,
-        },
-        localMessage: {
-          ...state.localMessage,
-          attachments,
-        },
+        message: messageAttachments.length
+          ? {
+              ...state.message,
+              attachments: messageAttachments,
+            }
+          : state.message,
+        localMessage: localAttachments.length
+          ? {
+              ...state.localMessage,
+              attachments: localAttachments,
+            }
+          : state.localMessage,
         sendOptions,
       });
     },