stream-chat 9.2.0 → 9.4.0

package/dist/types/channel.d.ts

@@ -139,7 +139,7 @@ export declare class Channel {
     sendReaction(messageID: string, reaction: Reaction, options?: {
         enforce_unique?: boolean;
         skip_push?: boolean;
-    }): Promise<ReactionAPIResponse | undefined>;
+    }): Promise<ReactionAPIResponse>;
     /**
      * sendReaction - Send a reaction about a message
      *
@@ -152,10 +152,8 @@ export declare class Channel {
     _sendReaction(messageID: string, reaction: Reaction, options?: {
         enforce_unique?: boolean;
         skip_push?: boolean;
-    }): Promise<ReactionAPIResponse | undefined>;
-    deleteReaction(messageID: string, reactionType: string, user_id?: string): Promise<(APIResponse & {
-        message: MessageResponse;
-    }) | undefined>;
+    }): Promise<ReactionAPIResponse>;
+    deleteReaction(messageID: string, reactionType: string, user_id?: string): Promise<ReactionAPIResponse>;
     /**
      * deleteReaction - Delete a reaction by user and type
      *

package/dist/types/client.d.ts

@@ -227,7 +227,24 @@ export declare class StreamChat {
           'data_template': 'data handlebars template',
           'apn_template': 'apn notification handlebars template under v2'
         },
-        'webhook_url': 'https://acme.com/my/awesome/webhook/'
+        'webhook_url': 'https://acme.com/my/awesome/webhook/',
+        'event_hooks': [
+          {
+            'hook_type': 'webhook',
+            'enabled': true,
+            'event_types': ['message.new'],
+            'webhook_url': 'https://acme.com/my/awesome/webhook/'
+          },
+          {
+            'hook_type': 'sqs',
+            'enabled': true,
+            'event_types': ['message.new'],
+            'sqs_url': 'https://sqs.us-east-1.amazonaws.com/1234567890/my-queue',
+            'sqs_auth_type': 'key',
+            'sqs_key': 'my-access-key',
+            'sqs_secret': 'my-secret-key'
+          }
+        ]
       }
      */
     updateAppSettings(options: AppSettings): Promise<APIResponse>;
@@ -1103,9 +1120,9 @@ export declare class StreamChat {
     partialUpdateMessage(id: string, partialMessageObject: PartialMessageUpdate, partialUserOrUserId?: string | {
         id: string;
     }, options?: UpdateMessageOptions): Promise<UpdateMessageAPIResponse>;
-    deleteMessage(messageID: string, hardDelete?: boolean): Promise<(APIResponse & {
+    deleteMessage(messageID: string, hardDelete?: boolean): Promise<APIResponse & {
         message: MessageResponse;
-    }) | undefined>;
+    }>;
     _deleteMessage(messageID: string, hardDelete?: boolean): Promise<APIResponse & {
         message: MessageResponse;
     }>;

package/dist/types/offline-support/offline_support_api.d.ts

@@ -522,11 +522,9 @@ export declare abstract class AbstractOfflineDB implements OfflineDBApi {
      * It will return the response from the execution if it succeeded.
      * @param task - the pending task we want to execute
      */
-    queueTask: ({ task }: {
+    queueTask: <T>({ task }: {
         task: PendingTask;
-    }) => Promise<(import("..").APIResponse & {
-        message: import("..").MessageResponse;
-    }) | undefined>;
+    }) => Promise<T>;
     /**
      * A utility method that determines if a failed task should be added to the
      * queue based on its error.

package/dist/types/offline-support/types.d.ts

@@ -1,4 +1,4 @@
-import type { AppSettingsAPIResponse, ChannelAPIResponse, ChannelFilters, ChannelMemberResponse, ChannelResponse, ChannelSort, LocalMessage, Message, MessageResponse, PollResponse, ReactionFilters, ReactionResponse, ReactionSort, ReadResponse } from '../types';
+import type { AppSettingsAPIResponse, ChannelAPIResponse, ChannelFilters, ChannelMemberResponse, ChannelResponse, ChannelSort, LocalMessage, MessageResponse, PollResponse, ReactionFilters, ReactionResponse, ReactionSort, ReadResponse } from '../types';
 import type { Channel } from '../channel';
 import type { StreamChat } from '../client';
 export type PrepareBatchDBQueries = [string] | [string, Array<unknown> | Array<Array<unknown>>];
@@ -322,6 +322,16 @@ export type PendingTask = {
     payload: Parameters<Channel['sendMessage']>;
     type: PendingTaskTypes['sendMessage'];
 });
-export type PendingTaskExtraData = {
-    message?: Message;
-};
+export type OfflineErrorType = 'connection:lost';
+export declare class OfflineError extends Error {
+    type: OfflineErrorType;
+    name: string;
+    constructor(message: string, { type, }: {
+        type: OfflineError['type'];
+    });
+    toJSON(): {
+        message: string;
+        stack: string | undefined;
+        name: string;
+    };
+}

package/dist/types/store.d.ts

@@ -2,14 +2,123 @@ export type Patch<T> = (value: T) => T;
 export type ValueOrPatch<T> = T | Patch<T>;
 export type Handler<T> = (nextValue: T, previousValue: T | undefined) => void;
 export type Unsubscribe = () => void;
+export type RemovePreprocessor = Unsubscribe;
+export type Preprocessor<T> = Handler<T>;
 export declare const isPatch: <T>(value: ValueOrPatch<T>) => value is Patch<T>;
 export declare class StateStore<T extends Record<string, unknown>> {
-    private value;
-    private handlerSet;
+    protected value: T;
+    protected handlers: Set<Handler<T>>;
+    protected preprocessors: Set<Preprocessor<T>>;
     constructor(value: T);
-    next: (newValueOrPatch: ValueOrPatch<T>) => void;
+    /**
+     * Allows merging two stores only if their keys differ otherwise there's no way to ensure the data type stability.
+     * @experimental
+     * This method is experimental and may change in future versions.
+     */
+    merge<Q extends StateStore<any>>(stateStore: Q extends StateStore<infer L> ? Extract<keyof T, keyof L> extends never ? Q : never : never): MergedStateStore<T, Q extends StateStore<infer L extends Record<string, unknown>> ? L : never>;
+    next(newValueOrPatch: ValueOrPatch<T>): void;
     partialNext: (partial: Partial<T>) => void;
-    getLatestValue: () => T;
-    subscribe: (handler: Handler<T>) => Unsubscribe;
+    getLatestValue(): T;
+    subscribe(handler: Handler<T>): Unsubscribe;
     subscribeWithSelector: <O extends Readonly<Record<string, unknown>> | Readonly<unknown[]>>(selector: (nextValue: T) => O, handler: Handler<O>) => Unsubscribe;
+    /**
+     * Registers a preprocessor function that will be called before the state is updated.
+     *
+     * Preprocessors are invoked with the new and previous values whenever `next` or `partialNext` methods
+     * are called, allowing you to mutate or react to the new value before it is set. Preprocessors run in the
+     * order they were registered.
+     *
+     * @example
+     * ```ts
+     * const store = new StateStore<{ count: number; isMaxValue: bool; }>({ count: 0, isMaxValue: false });
+     *
+     * store.addPreprocessor((nextValue, prevValue) => {
+     *   if (nextValue.count > 10) {
+     *     nextValue.count = 10; // Clamp the value to a maximum of 10
+     *   }
+     *
+     *   if (nextValue.count === 10) {
+     *     nextValue.isMaxValue = true; // Set isMaxValue to true if count is 10
+     *   } else {
+     *     nextValue.isMaxValue = false; // Reset isMaxValue otherwise
+     *   }
+     * });
+     *
+     * store.partialNext({ count: 15 });
+     *
+     * store.getLatestValue(); // { count: 10, isMaxValue: true }
+     *
+     * store.partialNext({ count: 5 });
+     *
+     * store.getLatestValue(); // { count: 5, isMaxValue: false }
+     * ```
+     *
+     * @param preprocessor - The function to be called with the next and previous values before the state is updated.
+     * @returns A `RemovePreprocessor` function that removes the preprocessor when called.
+     */
+    addPreprocessor(preprocessor: Preprocessor<T>): RemovePreprocessor;
+}
+/**
+ * Represents a merged state store that combines two separate state stores into one.
+ *
+ * The MergedStateStore allows combining two stores with non-overlapping keys.
+ * It extends StateStore with the combined type of both source stores.
+ * Changes to either the original or merged store will propagate to the combined store.
+ *
+ * Note: Direct mutations (next, partialNext, addPreprocessor) are disabled on the merged store.
+ * You should instead call these methods on the original or merged stores.
+ *
+ * @template O The type of the original state store
+ * @template M The type of the merged state store
+ *
+ * @experimental
+ * This class is experimental and may change in future versions.
+ */
+export declare class MergedStateStore<O extends Record<string, unknown>, M extends Record<string, unknown>> extends StateStore<O & M> {
+    readonly original: StateStore<O>;
+    readonly merged: StateStore<M>;
+    private cachedOriginalValue;
+    private cachedMergedValue;
+    constructor({ original, merged }: {
+        original: StateStore<O>;
+        merged: StateStore<M>;
+    });
+    /**
+     * Subscribes to changes in the merged state store.
+     *
+     * This method extends the base subscribe functionality to handle the merged nature of this store:
+     * 1. The first subscriber triggers registration of helper subscribers that listen to both source stores
+     * 2. Changes from either source store are propagated to this merged store
+     * 3. Source store values are cached to prevent unnecessary updates
+     *
+     * When the first subscriber is added, the method sets up listeners on both original and merged stores.
+     * These listeners update the combined store value whenever either source store changes.
+     * All subscriptions (helpers and the actual handler) are tracked so they can be properly cleaned up.
+     *
+     * @param handler - The callback function that will be executed when the state changes
+     * @returns An unsubscribe function that, when called, removes the subscription and any helper subscriptions
+     */
+    subscribe(handler: Handler<O & M>): () => void;
+    /**
+     * Retrieves the latest combined state from both original and merged stores.
+     *
+     * This method extends the base getLatestValue functionality to ensure the merged store
+     * remains in sync with its source stores even when there are no active subscribers.
+     *
+     * When there are no handlers registered, the method:
+     * 1. Fetches the latest values from both source stores
+     * 2. Compares them with the cached values to detect changes
+     * 3. If changes are detected, updates the internal value and caches
+     *    the new source values to maintain consistency
+     *
+     * This approach ensures that calling getLatestValue() always returns the most
+     * up-to-date combined state, even if the merged store hasn't been actively
+     * receiving updates through subscriptions.
+     *
+     * @returns The latest combined state from both original and merged stores
+     */
+    getLatestValue(): O & M;
+    next: () => void;
+    partialNext: () => void;
+    addPreprocessor(): () => void;
 }

package/dist/types/types.d.ts

@@ -90,6 +90,7 @@ export type AppSettingsAPIResponse = APIResponse & {
         disable_auth_checks?: boolean;
         disable_permissions_checks?: boolean;
         enforce_unique_usernames?: 'no' | 'app' | 'team';
+        event_hooks?: Array<EventHook>;
         file_upload_config?: FileUploadConfig;
         geofences?: Array<{
             country_codes: Array<string>;
@@ -1698,6 +1699,7 @@ export type AppSettings = {
     disable_auth_checks?: boolean;
     disable_permissions_checks?: boolean;
     enforce_unique_usernames?: 'no' | 'app' | 'team';
+    event_hooks?: Array<EventHook> | null;
     file_upload_config?: FileUploadConfig;
     firebase_config?: {
         apn_template?: string;
@@ -2354,9 +2356,11 @@ export declare class ErrorFromResponse<T> extends Error {
         status: ErrorFromResponse<T>['status'];
     });
     toJSON(): {
-        message: string;
-        stack: string | undefined;
-        name: string;
+        readonly message: `(${string}) - ${string}`;
+        readonly stack: string | undefined;
+        readonly name: string;
+        readonly code: number | null;
+        readonly status: number;
     };
 }
 export type QueryPollsResponse = {
@@ -2905,4 +2909,26 @@ export type ThreadFilters = QueryFilters<{
 } & {
     last_message_at?: RequireOnlyOne<Pick<QueryFilter<ThreadResponse['last_message_at']>, '$eq' | '$gt' | '$lt' | '$gte' | '$lte'>> | PrimitiveFilter<ThreadResponse['last_message_at']>;
 }>;
+export type HookType = 'webhook' | 'sqs' | 'sns';
+export type EventHook = {
+    id?: string;
+    hook_type?: HookType;
+    enabled?: boolean;
+    event_types?: Array<string>;
+    webhook_url?: string;
+    sqs_queue_url?: string;
+    sqs_region?: string;
+    sqs_auth_type?: string;
+    sqs_key?: string;
+    sqs_secret?: string;
+    sqs_role_arn?: string;
+    sns_topic_arn?: string;
+    sns_region?: string;
+    sns_auth_type?: string;
+    sns_key?: string;
+    sns_secret?: string;
+    sns_role_arn?: string;
+    created_at?: string;
+    updated_at?: string;
+};
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "stream-chat",
-  "version": "9.2.0",
+  "version": "9.4.0",
   "description": "JS SDK for the Stream Chat API",
   "homepage": "https://getstream.io/chat/",
   "author": {
@@ -68,6 +68,7 @@
     "@types/base64-js": "^1.3.0",
     "@types/node": "^22.15.21",
     "@types/sinon": "^10.0.6",
+    "@vitest/coverage-v8": "3.1.4",
     "concurrently": "^9.1.2",
     "conventional-changelog-conventionalcommits": "^8.0.0",
     "dotenv": "^8.2.0",
@@ -77,7 +78,6 @@
     "globals": "^16.0.0",
     "husky": "^9.1.7",
     "lint-staged": "^15.2.2",
-    "nyc": "^15.1.0",
     "prettier": "^3.5.3",
     "semantic-release": "^24.2.3",
     "sinon": "^12.0.1",
@@ -98,8 +98,8 @@
     "test": "yarn test-unit",
     "testwatch": "NODE_ENV=test nodemon ./node_modules/.bin/mocha --timeout 20000 --require test-entry.js test/test.js",
     "test-types": "node test/typescript/index.js && tsc --esModuleInterop true --noEmit true --strictNullChecks true --noImplicitAny true --strict true test/typescript/*.ts",
-    "test-unit": "vitest test/unit/* --run",
-    "test-coverage": "nyc yarn test-unit",
+    "test-unit": "vitest",
+    "test-coverage": "vitest run --coverage",
     "fix-staged": "lint-staged --config .lintstagedrc.fix.json --concurrent 1",
     "semantic-release": "semantic-release",
     "prepare": "husky; yarn run build"

package/src/channel.ts

@@ -207,7 +207,7 @@ export class Channel {
       if (offlineDb) {
         const messageId = message.id;
         if (messageId) {
-          return (await offlineDb.queueTask({
+          return await offlineDb.queueTask<SendMessageAPIResponse>({
             task: {
               channelId: this.id as string,
               channelType: this.type,
@@ -215,7 +215,7 @@ export class Channel {
               payload: [message, options],
               type: 'send-message',
             },
-          })) as SendMessageAPIResponse;
+          });
         }
       }
     } catch (error) {
@@ -410,7 +410,7 @@ export class Channel {
     messageID: string,
     reaction: Reaction,
     options?: { enforce_unique?: boolean; skip_push?: boolean },
-  ): Promise<ReactionAPIResponse | undefined> {
+  ) {
     if (!messageID) {
       throw Error(`Message id is missing`);
     }
@@ -454,7 +454,7 @@ export class Channel {
     messageID: string,
     reaction: Reaction,
     options?: { enforce_unique?: boolean; skip_push?: boolean },
-  ): Promise<ReactionAPIResponse | undefined> {
+  ) {
     if (!messageID) {
       throw Error(`Message id is missing`);
     }
@@ -498,7 +498,7 @@ export class Channel {
           });
         }
 
-        return await offlineDb.queueTask({
+        return await offlineDb.queueTask<ReactionAPIResponse>({
           task: {
             channelId: this.id as string,
             channelType: this.type,

package/src/client.ts

@@ -777,7 +777,24 @@ export class StreamChat {
         'data_template': 'data handlebars template',
         'apn_template': 'apn notification handlebars template under v2'
       },
-      'webhook_url': 'https://acme.com/my/awesome/webhook/'
+      'webhook_url': 'https://acme.com/my/awesome/webhook/',
+      'event_hooks': [
+        {
+          'hook_type': 'webhook',
+          'enabled': true,
+          'event_types': ['message.new'],
+          'webhook_url': 'https://acme.com/my/awesome/webhook/'
+        },
+        {
+          'hook_type': 'sqs',
+          'enabled': true,
+          'event_types': ['message.new'],
+          'sqs_url': 'https://sqs.us-east-1.amazonaws.com/1234567890/my-queue',
+          'sqs_auth_type': 'key',
+          'sqs_key': 'my-access-key',
+          'sqs_secret': 'my-secret-key'
+        }
+      ]
     }
    */
   async updateAppSettings(options: AppSettings) {
@@ -3019,13 +3036,15 @@ export class StreamChat {
         } else {
           await this.offlineDb.softDeleteMessage({ id: messageID });
         }
-        return await this.offlineDb.queueTask({
-          task: {
-            messageId: messageID,
-            payload: [messageID, hardDelete],
-            type: 'delete-message',
+        return await this.offlineDb.queueTask<APIResponse & { message: MessageResponse }>(
+          {
+            task: {
+              messageId: messageID,
+              payload: [messageID, hardDelete],
+              type: 'delete-message',
+            },
           },
-        });
+        );
       }
     } catch (error) {
       this.logger('error', `offlineDb:deleteMessage`, {

package/src/offline-support/offline_support_api.ts

@@ -6,6 +6,7 @@ import type {
   PendingTask,
   PrepareBatchDBQueries,
 } from './types';
+import { OfflineError } from './types';
 import type { StreamChat } from '../client';
 import type { AxiosError } from 'axios';
 import { OfflineDBSyncManager } from './offline_sync_manager';
@@ -986,22 +987,24 @@ export abstract class AbstractOfflineDB implements OfflineDBApi {
    * It will return the response from the execution if it succeeded.
    * @param task - the pending task we want to execute
    */
-  public queueTask = async ({ task }: { task: PendingTask }) => {
-    let response;
-    try {
+  public queueTask = async <T>({ task }: { task: PendingTask }): Promise<T> => {
+    const attemptTaskExecution = async () => {
       if (!this.client.wsConnection?.isHealthy) {
-        await this.addPendingTask(task);
-        return;
+        throw new OfflineError(
+          'Cannot execute task because the connection has been lost.',
+          { type: 'connection:lost' },
+        );
       }
-      response = await this.executeTask({ task });
+      return (await this.executeTask({ task })) as T;
+    };
+    try {
+      return await attemptTaskExecution();
     } catch (e) {
       if (!this.shouldSkipQueueingTask(e as AxiosError<APIErrorResponse>)) {
         await this.addPendingTask(task);
-        throw e;
       }
+      throw e;
     }
-
-    return response;
   };
 
   /**

package/src/offline-support/types.ts

@@ -6,7 +6,6 @@ import type {
   ChannelResponse,
   ChannelSort,
   LocalMessage,
-  Message,
   MessageResponse,
   PollResponse,
   ReactionFilters,
@@ -398,6 +397,31 @@ export type PendingTask = {
     }
 );
 
-export type PendingTaskExtraData = {
-  message?: Message;
-};
+export type OfflineErrorType = 'connection:lost';
+
+export class OfflineError extends Error {
+  public type: OfflineErrorType;
+  public name = 'OfflineError';
+
+  constructor(
+    message: string,
+    {
+      type,
+    }: {
+      type: OfflineError['type'];
+    },
+  ) {
+    super(message);
+    this.type = type;
+  }
+
+  // Vitest helper (serialized errors are too large to read)
+  // https://github.com/vitest-dev/vitest/blob/v3.1.3/packages/utils/src/error.ts#L60-L62
+  toJSON() {
+    return {
+      message: `${this.type} - ${this.message}`,
+      stack: this.stack,
+      name: this.name,
+    };
+  }
+}