stream-chat 9.52.0 → 9.52.1

package/dist/types/channel.d.ts

@@ -491,14 +491,16 @@ export declare class Channel {
      */
     markRead(data?: MarkReadOptions): Promise<EventAPIResponse | null>;
     /**
-     * markReadRequest - Send the mark read event for this user, only works if the `read_events` setting is enabled
+     * markReadRequest - Send the mark read event for this user, only works if the `read_events` setting is
+     * enabled and the user holds the `read-events` capability on this channel
      *
      * @param {MarkReadOptions} data
      * @return {Promise<EventAPIResponse | null>} Description
      */
     markAsReadRequest(data?: MarkReadOptions): Promise<EventAPIResponse | null>;
     /**
-     * markUnread - Mark the channel as unread from messageID, only works if the `read_events` setting is enabled
+     * markUnread - Mark the channel as unread from messageID, only works if the `read_events` setting is
+     * enabled and the user holds the `read-events` capability on this channel
      *
      * @param {MarkUnreadOptions} data
      * @return {APIResponse} An API response

package/dist/types/utils.d.ts

@@ -12,6 +12,15 @@ import type { AxiosRequestConfig } from 'axios';
  *
  */
 export declare function logChatPromiseExecution<T>(promise: Promise<T>, name: string): void;
+/**
+ * The default no-op client logger.
+ */
+export declare const noopLogger: Logger;
+/**
+ * Invokes a single event listener in isolation, so that a faulty listener cannot
+ * abort the dispatch loop or the bookkeeping that follows it.
+ */
+export declare const invokeEventListener: <T>(listener: (event: T) => unknown, event: T, logger: Logger) => void;
 export declare const sleep: (m: number) => Promise<void>;
 export declare function isFunction(value: unknown): value is (...args: unknown[]) => unknown;
 export declare const chatCodes: {
@@ -28,11 +37,6 @@ export declare const channelHasReadEvents: (channel?: Channel) => boolean;
  * channelTracksReadLocally - Whether a channel maintains a client local unread count.
  */
 export declare const channelTracksReadLocally: (channel?: Channel) => boolean;
-/**
- * userHasReadReceipts - Whether the current user allows read receipts, per their privacy settings.
- * Read receipts are treated as enabled unless the user has explicitly disabled them.
- */
-export declare const userHasReadReceipts: (client: StreamChat) => boolean;
 export declare function addFileToFormData(uri: string | NodeJS.ReadableStream | Buffer | File, name?: string, contentType?: string): FormData;
 export declare function normalizeQuerySort<T extends Record<string, AscDesc | undefined>>(sort: T | T[]): {
     direction: AscDesc;

package/package.json

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

package/src/channel.ts

@@ -6,6 +6,7 @@ import { MessageReceiptsTracker } from './messageDelivery';
 import {
   channelHasReadEvents,
   generateChannelTempCid,
+  invokeEventListener,
   logChatPromiseExecution,
   messageSetPagination,
   normalizeQuerySort,
@@ -1221,7 +1222,8 @@ export class Channel {
   }
 
   /**
-   * markReadRequest - Send the mark read event for this user, only works if the `read_events` setting is enabled
+   * markReadRequest - Send the mark read event for this user, only works if the `read_events` setting is
+   * enabled and the user holds the `read-events` capability on this channel
    *
    * @param {MarkReadOptions} data
    * @return {Promise<EventAPIResponse | null>} Description
@@ -1229,7 +1231,13 @@ export class Channel {
   async markAsReadRequest(data: MarkReadOptions = {}) {
     this._checkInitialized();
 
-    if (!this.getConfig()?.read_events && !this.getClient()._isUsingServerAuth()) {
+    // Server-side auth acts on behalf of a user with no own capabilities, so only the client-side
+    // flow is gated. Channels the user has no `read-events` capability on do not track read state
+    // on the backend at all - see `markReadLocally` for the client-local unread count.
+    if (
+      !this.getClient()._isUsingServerAuth() &&
+      (!this.getConfig()?.read_events || !channelHasReadEvents(this))
+    ) {
       return null;
     }
 
@@ -1239,7 +1247,8 @@ export class Channel {
   }
 
   /**
-   * markUnread - Mark the channel as unread from messageID, only works if the `read_events` setting is enabled
+   * markUnread - Mark the channel as unread from messageID, only works if the `read_events` setting is
+   * enabled and the user holds the `read-events` capability on this channel
    *
    * @param {MarkUnreadOptions} data
    * @return {APIResponse} An API response
@@ -1247,7 +1256,11 @@ export class Channel {
   async markUnread(data: MarkUnreadOptions) {
     this._checkInitialized();
 
-    if (!this.getConfig()?.read_events && !this.getClient()._isUsingServerAuth()) {
+    // Gated the same way as `markAsReadRequest` - see the comment there.
+    if (
+      !this.getClient()._isUsingServerAuth() &&
+      (!this.getConfig()?.read_events || !channelHasReadEvents(this))
+    ) {
       return Promise.resolve(null);
     }
 
@@ -2354,22 +2367,17 @@ export class Channel {
   }
 
   _callChannelListeners = (event: Event) => {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const channel = this;
-    // gather and call the listeners
-    const listeners = [];
-    if (channel.listeners.all) {
-      listeners.push(...channel.listeners.all);
-    }
-    if (channel.listeners[event.type]) {
-      listeners.push(...channel.listeners[event.type]);
-    }
+    // snapshot before dispatching: `on` pushes into these arrays in place, so a
+    // listener that subscribes while handling an event must not be invoked for it
+    const listeners = [
+      ...(this.listeners.all ?? []),
+      ...(this.listeners[event.type] ?? []),
+    ];
 
-    // call the event and send it to the listeners
+    const { logger } = this._client;
     for (const listener of listeners) {
-      if (typeof listener !== 'string') {
-        listener(event);
-      }
+      if (typeof listener === 'string') continue;
+      invokeEventListener(listener, event, logger);
     }
   };
 

package/src/client.ts

@@ -29,10 +29,12 @@ import {
   axiosParamsSerializer,
   chatCodes,
   generateChannelTempCid,
+  invokeEventListener,
   isFunction,
   isOnline,
   isOwnUserBaseProperty,
   messageSetPagination,
+  noopLogger,
   normalizeQuerySort,
   randomId,
   retryInterval,
@@ -575,7 +577,7 @@ export class StreamChat {
      *    channel: object
      * }
      */
-    this.logger = isFunction(inputOptions.logger) ? inputOptions.logger : () => null;
+    this.logger = isFunction(inputOptions.logger) ? inputOptions.logger : noopLogger;
     this.recoverStateOnReconnect = this.options.recoverStateOnReconnect;
     this.threads = new ThreadManager({ client: this });
     this.polls = new PollManager({ client: this });
@@ -1700,20 +1702,15 @@ export class StreamChat {
   }
 
   _callClientListeners = (event: Event) => {
-    // eslint-disable-next-line @typescript-eslint/no-this-alias
-    const client = this;
-    // gather and call the listeners
-    const listeners: Array<(event: Event) => void> = [];
-    if (client.listeners.all) {
-      listeners.push(...client.listeners.all);
-    }
-    if (client.listeners[event.type]) {
-      listeners.push(...client.listeners[event.type]);
-    }
+    // snapshot before dispatching: `on` pushes into these arrays in place, so a
+    // listener that subscribes while handling an event must not be invoked for it
+    const listeners = [
+      ...(this.listeners.all ?? []),
+      ...(this.listeners[event.type] ?? []),
+    ];
 
-    // call the event and send it to the listeners
     for (const listener of listeners) {
-      listener(event);
+      invokeEventListener(listener, event, this.logger);
     }
   };
 

package/src/messageDelivery/MessageDeliveryReporter.ts

@@ -10,7 +10,7 @@ import type {
   MarkReadOptions,
 } from '../types';
 import { type APIErrorResponse } from '../types';
-import { throttle, userHasReadReceipts } from '../utils';
+import { throttle } from '../utils';
 import { isAPIError, isErrorRetryable } from '../errors';
 
 const MAX_DELIVERED_MESSAGE_COUNT_IN_PAYLOAD = 100 as const;
@@ -279,8 +279,6 @@ export class MessageDeliveryReporter {
    * @param options
    */
   public markRead = async (collection: Channel | Thread, options?: MarkReadOptions) => {
-    if (!userHasReadReceipts(this.client)) return null;
-
     let result: EventAPIResponse | null = null;
     if (isChannel(collection)) {
       result = await collection.markAsReadRequest(options);
@@ -291,7 +289,10 @@ export class MessageDeliveryReporter {
       });
     }
 
-    this.removeCandidateFor(collection);
+    // A read implies delivery, so the candidate is only dropped once the request actually went
+    // out. `markAsReadRequest` returns null for channels that do not track read state on the
+    // backend, and those candidates must survive for the next delivery report.
+    if (result) this.removeCandidateFor(collection);
     return result;
   };
 

package/src/utils.ts

@@ -41,6 +41,36 @@ export function logChatPromiseExecution<T>(promise: Promise<T>, name: string) {
   });
 }
 
+/**
+ * The default no-op client logger.
+ */
+export const noopLogger: Logger = () => null;
+
+const logError = <T>(logger: Logger, error: unknown, event: T) => {
+  const message = 'Unhandled error in event listener';
+  logger('error', message, { error, event });
+  if (logger === noopLogger) console.error(message, error, event);
+};
+
+/**
+ * Invokes a single event listener in isolation, so that a faulty listener cannot
+ * abort the dispatch loop or the bookkeeping that follows it.
+ */
+export const invokeEventListener = <T>(
+  listener: (event: T) => unknown,
+  event: T,
+  logger: Logger,
+) => {
+  try {
+    const result = listener(event);
+    if (result && typeof (result as PromiseLike<unknown>).then === 'function') {
+      Promise.resolve(result).catch((error) => logError(logger, error, event));
+    }
+  } catch (error) {
+    logError(logger, error, event);
+  }
+};
+
 export const sleep = (m: number): Promise<void> => new Promise((r) => setTimeout(r, m));
 
 export function isFunction(value: unknown): value is (...args: unknown[]) => unknown {
@@ -126,13 +156,6 @@ export const channelTracksReadLocally = (channel?: Channel) =>
   !channelHasReadEvents(channel) &&
   !!channel?.getClient().options.isLocalUnreadCountEnabled;
 
-/**
- * userHasReadReceipts - Whether the current user allows read receipts, per their privacy settings.
- * Read receipts are treated as enabled unless the user has explicitly disabled them.
- */
-export const userHasReadReceipts = (client: StreamChat) =>
-  client.user?.privacy_settings?.read_receipts?.enabled ?? true;
-
 export function addFileToFormData(
   uri: string | NodeJS.ReadableStream | Buffer | File,
   name?: string,