stream-chat 8.14.5 → 8.16.0

package/src/channel.ts

@@ -170,18 +170,10 @@ export class Channel<StreamChatGenerics extends ExtendableGenerics = DefaultGene
    * @return {Promise<SendMessageAPIResponse<StreamChatGenerics>>} The Server Response
    */
   async sendMessage(message: Message<StreamChatGenerics>, options?: SendMessageOptions) {
-    const sendMessageResponse = await this.getClient().post<SendMessageAPIResponse<StreamChatGenerics>>(
-      this._channelURL() + '/message',
-      {
-        message,
-        ...options,
-      },
-    );
-
-    // Reset unreadCount to 0.
-    this.state.unreadCount = 0;
-
-    return sendMessageResponse;
+    return await this.getClient().post<SendMessageAPIResponse<StreamChatGenerics>>(this._channelURL() + '/message', {
+      message,
+      ...options,
+    });
   }
 
   sendFile(
@@ -649,7 +641,7 @@ export class Channel<StreamChatGenerics extends ExtendableGenerics = DefaultGene
    * @see {@link https://getstream.io/chat/docs/typing_indicators/?language=js|Docs}
    * @param {string} [parent_id] set this field to `message.id` to indicate that typing event is happening in a thread
    */
-  async keystroke(parent_id?: string) {
+  async keystroke(parent_id?: string, options?: { user_id: string }) {
     if (!this.getConfig()?.typing_events) {
       return;
     }
@@ -663,6 +655,7 @@ export class Channel<StreamChatGenerics extends ExtendableGenerics = DefaultGene
       await this.sendEvent({
         type: 'typing.start',
         parent_id,
+        ...(options || {}),
       } as Event<StreamChatGenerics>);
     }
   }
@@ -672,7 +665,7 @@ export class Channel<StreamChatGenerics extends ExtendableGenerics = DefaultGene
    * @see {@link https://getstream.io/chat/docs/typing_indicators/?language=js|Docs}
    * @param {string} [parent_id] set this field to `message.id` to indicate that typing event is happening in a thread
    */
-  async stopTyping(parent_id?: string) {
+  async stopTyping(parent_id?: string, options?: { user_id: string }) {
     if (!this.getConfig()?.typing_events) {
       return;
     }
@@ -681,6 +674,7 @@ export class Channel<StreamChatGenerics extends ExtendableGenerics = DefaultGene
     await this.sendEvent({
       type: 'typing.stop',
       parent_id,
+      ...(options || {}),
     } as Event<StreamChatGenerics>);
   }
 
@@ -1241,7 +1235,6 @@ export class Channel<StreamChatGenerics extends ExtendableGenerics = DefaultGene
       case 'message.read':
         if (event.user?.id && event.created_at) {
           channelState.read[event.user.id] = {
-            // because in client.ts the handleEvent call that flows to this sets this `event.received_at = new Date();`
             last_read: new Date(event.created_at),
             last_read_message_id: event.last_read_message_id,
             user: event.user,
@@ -1290,6 +1283,12 @@ export class Channel<StreamChatGenerics extends ExtendableGenerics = DefaultGene
             channelState.addPinnedMessage(event.message);
           }
 
+          // do not increase the unread count - the back-end does not increase the count neither in the following cases:
+          // 1. the message is mine
+          // 2. the message is a thread reply from any user
+          const preventUnreadCountUpdate = ownMessage || isThreadMessage;
+          if (preventUnreadCountUpdate) break;
+
           if (event.user?.id) {
             for (const userId in channelState.read) {
               if (userId === event.user.id) {
@@ -1304,9 +1303,7 @@ export class Channel<StreamChatGenerics extends ExtendableGenerics = DefaultGene
             }
           }
 
-          if (ownMessage) {
-            channelState.unreadCount = 0;
-          } else if (this._countMessageAsUnread(event.message)) {
+          if (this._countMessageAsUnread(event.message)) {
             channelState.unreadCount = channelState.unreadCount + 1;
           }
         }
@@ -1360,6 +1357,23 @@ export class Channel<StreamChatGenerics extends ExtendableGenerics = DefaultGene
           delete channelState.members[event.user.id];
         }
         break;
+      case 'notification.mark_unread': {
+        const ownMessage = event.user?.id === this.getClient().user?.id;
+        if (!(ownMessage && event.user)) break;
+
+        const unreadCount = event.unread_messages ?? 0;
+
+        channelState.read[event.user.id] = {
+          first_unread_message_id: event.first_unread_message_id,
+          last_read: new Date(event.last_read_at as string),
+          last_read_message_id: event.last_read_message_id,
+          user: event.user,
+          unread_messages: unreadCount,
+        };
+
+        channelState.unreadCount = unreadCount;
+        break;
+      }
       case 'channel.updated':
         if (event.channel) {
           const isFrozenChanged = event.channel?.frozen !== undefined && event.channel.frozen !== channel.data?.frozen;

package/src/channel_state.ts

@@ -12,10 +12,17 @@ import {
   UserResponse,
   PendingMessageResponse,
 } from './types';
+import { addToMessageList } from './utils';
 
 type ChannelReadStatus<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = Record<
   string,
-  { last_read: Date; unread_messages: number; user: UserResponse<StreamChatGenerics>; last_read_message_id?: string }
+  {
+    last_read: Date;
+    unread_messages: number;
+    user: UserResponse<StreamChatGenerics>;
+    first_unread_message_id?: string;
+    last_read_message_id?: string;
+  }
 >;
 
 /**
@@ -435,64 +442,7 @@ export class ChannelState<StreamChatGenerics extends ExtendableGenerics = Defaul
     sortBy: 'pinned_at' | 'created_at' = 'created_at',
     addIfDoesNotExist = true,
   ) {
-    const addMessageToList = addIfDoesNotExist || timestampChanged;
-    let messageArr = messages;
-
-    // if created_at has changed, message should be filtered and re-inserted in correct order
-    // slow op but usually this only happens for a message inserted to state before actual response with correct timestamp
-    if (timestampChanged) {
-      messageArr = messageArr.filter((msg) => !(msg.id && message.id === msg.id));
-    }
-
-    // Get array length after filtering
-    const messageArrayLength = messageArr.length;
-
-    // for empty list just concat and return unless it's an update or deletion
-    if (messageArrayLength === 0 && addMessageToList) {
-      return messageArr.concat(message);
-    } else if (messageArrayLength === 0) {
-      return [...messageArr];
-    }
-
-    const messageTime = (message[sortBy] as Date).getTime();
-    const messageIsNewest = (messageArr[messageArrayLength - 1][sortBy] as Date).getTime() < messageTime;
-
-    // if message is newer than last item in the list concat and return unless it's an update or deletion
-    if (messageIsNewest && addMessageToList) {
-      return messageArr.concat(message);
-    } else if (messageIsNewest) {
-      return [...messageArr];
-    }
-
-    // find the closest index to push the new message
-    let left = 0;
-    let middle = 0;
-    let right = messageArrayLength - 1;
-    while (left <= right) {
-      middle = Math.floor((right + left) / 2);
-      if ((messageArr[middle][sortBy] as Date).getTime() <= messageTime) left = middle + 1;
-      else right = middle - 1;
-    }
-
-    // message already exists and not filtered due to timestampChanged, update and return
-    if (!timestampChanged && message.id) {
-      if (messageArr[left] && message.id === messageArr[left].id) {
-        messageArr[left] = message;
-        return [...messageArr];
-      }
-
-      if (messageArr[left - 1] && message.id === messageArr[left - 1].id) {
-        messageArr[left - 1] = message;
-        return [...messageArr];
-      }
-    }
-
-    // Do not add updated or deleted messages to the list if they do not already exist
-    // or have a timestamp change.
-    if (addMessageToList) {
-      messageArr.splice(left, 0, message);
-    }
-    return [...messageArr];
+    return addToMessageList(messages, message, timestampChanged, sortBy, addIfDoesNotExist);
   }
 
   /**

package/src/client.ts

@@ -95,7 +95,9 @@ import {
   GetImportResponse,
   GetMessageAPIResponse,
   GetRateLimitsResponse,
+  QueryThreadsAPIResponse,
   GetUnreadCountAPIResponse,
+  GetUnreadCountBatchAPIResponse,
   ListChannelResponse,
   ListCommandsResponse,
   ListImportsPaginationOptions,
@@ -123,12 +125,10 @@ import {
   PushProviderListResponse,
   PushProviderUpsertResponse,
   QueryChannelsAPIResponse,
+  QuerySegmentsOptions,
   ReactionResponse,
   ReactivateUserOptions,
   ReactivateUsersOptions,
-  Recipient,
-  RecipientFilters,
-  RecipientQueryOptions,
   ReservedMessageFields,
   ReviewFlagReportOptions,
   ReviewFlagReportResponse,
@@ -138,8 +138,7 @@ import {
   SearchPayload,
   Segment,
   SegmentData,
-  SegmentFilters,
-  SegmentQueryOptions,
+  SegmentType,
   SendFileAPIResponse,
   StreamChatOptions,
   SyncOptions,
@@ -159,13 +158,19 @@ import {
   UpdatedMessage,
   UpdateMessageAPIResponse,
   UpdateMessageOptions,
+  UpdateSegmentData,
   UserCustomEvent,
   UserFilters,
   UserOptions,
   UserResponse,
   UserSort,
+  GetThreadAPIResponse,
+  PartialThreadUpdate,
+  QueryThreadsOptions,
+  GetThreadOptions,
 } from './types';
 import { InsightMetrics, postInsights } from './insights';
+import { Thread } from './thread';
 
 function isString(x: unknown): x is string {
   return typeof x === 'string' || x instanceof String;
@@ -1688,10 +1693,28 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
     );
   }
 
+  /**
+   * getUnreadCount - Returns unread counts for a single user
+   *
+   * @param {string} [userID] User ID.
+   *
+   * @return {<GetUnreadCountAPIResponse>}
+   */
   async getUnreadCount(userID?: string) {
     return await this.get<GetUnreadCountAPIResponse>(this.baseURL + '/unread', userID ? { user_id: userID } : {});
   }
 
+  /**
+   * getUnreadCountBatch - Returns unread counts for multiple users at once. Only works server side.
+   *
+   * @param {string[]} [userIDs] List of user IDs to fetch unread counts for.
+   *
+   * @return {<GetUnreadCountBatchAPIResponse>}
+   */
+  async getUnreadCountBatch(userIDs: string[]) {
+    return await this.post<GetUnreadCountBatchAPIResponse>(this.baseURL + '/unread_batch', { user_ids: userIDs });
+  }
+
   /**
    * removeDevice - Removes the device with the given id. Clientside users can only delete their own devices
    *
@@ -2578,6 +2601,103 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
     );
   }
 
+  /**
+   * queryThreads - returns the list of threads of current user.
+   *
+   * @param {QueryThreadsOptions} options Options object for pagination and limiting the participants and replies.
+   * @param {number}  options.limit Limits the number of threads to be returned.
+   * @param {boolean} options.watch Subscribes the user to the channels of the threads.
+   * @param {number}  options.participant_limit Limits the number of participants returned per threads.
+   * @param {number}  options.reply_limit Limits the number of replies returned per threads.
+   *
+   * @returns {{ threads: Thread<StreamChatGenerics>[], next: string }} Returns the list of threads and the next cursor.
+   */
+  async queryThreads(options?: QueryThreadsOptions) {
+    const opts = {
+      limit: 10,
+      participant_limit: 10,
+      reply_limit: 3,
+      watch: true,
+      ...options,
+    };
+
+    const res = await this.post<QueryThreadsAPIResponse<StreamChatGenerics>>(this.baseURL + `/threads`, opts);
+
+    return {
+      threads: res.threads.map((thread) => new Thread(this, thread)),
+      next: res.next,
+    };
+  }
+
+  /**
+   * getThread - returns the thread of a message by its id.
+   *
+   * @param {string}            messageId The message id
+   * @param {GetThreadOptions}  options Options object for pagination and limiting the participants and replies.
+   * @param {boolean}           options.watch Subscribes the user to the channel of the thread.
+   * @param {number}            options.participant_limit Limits the number of participants returned per threads.
+   * @param {number}            options.reply_limit Limits the number of replies returned per threads.
+   *
+   * @returns {Thread<StreamChatGenerics>} Returns the thread.
+   */
+  async getThread(messageId: string, options: GetThreadOptions = {}) {
+    if (!messageId) {
+      throw Error('Please specify the message id when calling partialUpdateThread');
+    }
+
+    const opts = {
+      participant_limit: 100,
+      reply_limit: 3,
+      watch: true,
+      ...options,
+    };
+
+    const res = await this.get<GetThreadAPIResponse<StreamChatGenerics>>(this.baseURL + `/threads/${messageId}`, opts);
+
+    return new Thread<StreamChatGenerics>(this, res.thread);
+  }
+
+  /**
+   * partialUpdateThread - updates the given thread
+   *
+   * @param {string}              messageId The id of the thread message which needs to be updated.
+   * @param {PartialThreadUpdate} partialThreadObject should contain "set" or "unset" params for any of the thread's non-reserved fields.
+   *
+   * @returns {GetThreadAPIResponse<StreamChatGenerics>} Returns the updated thread.
+   */
+  async partialUpdateThread(messageId: string, partialThreadObject: PartialThreadUpdate) {
+    if (!messageId) {
+      throw Error('Please specify the message id when calling partialUpdateThread');
+    }
+
+    // check for reserved fields from ThreadResponse type within partialThreadObject's set and unset.
+    // Throw error if any of the reserved field is found.
+    const reservedThreadFields = [
+      'created_at',
+      'id',
+      'last_message_at',
+      'type',
+      'updated_at',
+      'user',
+      'reply_count',
+      'participants',
+      'channel',
+    ];
+
+    for (const key in { ...partialThreadObject.set, ...partialThreadObject.unset }) {
+      if (reservedThreadFields.includes(key)) {
+        throw Error(
+          `You cannot set ${key} field on Thread object. ${key} is reserved for server-side use. Please omit ${key} from your set object.`,
+        );
+      }
+    }
+
+    return await this.patch<GetThreadAPIResponse<StreamChatGenerics>>(
+      this.baseURL + `/threads/${messageId}`,
+      partialThreadObject,
+    );
+  }
+
   getUserAgent() {
     return (
       this.userAgent || `stream-chat-javascript-client-${this.node ? 'node' : 'browser'}-${process.env.PKG_VERSION}`
@@ -2824,56 +2944,132 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
   }
 
   /**
-   * createSegment - Creates a Campaign Segment
+   * createSegment - Creates a segment
    *
+   * @private
+   * @param {SegmentType} type Segment type
+   * @param {string} id Segment ID (valid UUID)
+   * @param {string} name Segment name (valid UUID)
    * @param {SegmentData} params Segment data
    *
-   * @return {Segment} The Created Segment
+   * @return {Segment} The created Segment
    */
-  async createSegment(params: SegmentData) {
-    const { segment } = await this.post<{ segment: Segment }>(this.baseURL + `/segments`, { segment: params });
+  private async createSegment(type: SegmentType, id: string, name: string, data?: SegmentData): Promise<Segment> {
+    const body = {
+      id,
+      type,
+      name,
+      data,
+    };
+    const { segment } = await this.post<{ segment: Segment }>(this.baseURL + `/segments`, body);
     return segment;
   }
 
   /**
-   * querySegments - Query Campaign Segments
+   * createUserSegment - Creates a user segment
    *
+   * @param {string} id Segment ID (valid UUID)
+   * @param {string} name Segment name
+   * @param {SegmentData} data Segment data
+   *
+   * @return {Segment} The created Segment
+   */
+  async createUserSegment(id: string, name: string, data?: SegmentData): Promise<Segment> {
+    return await this.createSegment('user', id, name, data);
+  }
+
+  /**
+   * createChannelSegment - Creates a channel segment
+   *
+   * @param {string} id Segment ID (valid UUID)
+   * @param {string} name Segment name
+   * @param {SegmentData} data Segment data
+   *
+   * @return {Segment} The created Segment
+   */
+  async createChannelSegment(id: string, name: string, data?: SegmentData): Promise<Segment> {
+    return await this.createSegment('channel', id, name, data);
+  }
+
+  /**
+   * updateSegment - Update a segment
+   *
+   * @param {string} id Segment ID
+   * @param {Partial<UpdateSegmentData>} data Data to update
+   *
+   * @return {Segment} Updated Segment
+   */
+  async updateSegment(id: string, data: Partial<UpdateSegmentData>) {
+    const { segment } = await this.put<{ segment: Segment }>(this.baseURL + `/segments/${id}`, data);
+    return segment;
+  }
+
+  /**
+   * addSegmentTargets - Add targets to a segment
+   *
+   * @param {string} id Segment ID
+   * @param {string[]} targets Targets to add to the segment
+   *
+   * @return {APIResponse} API response
+   */
+  async addSegmentTargets(id: string, targets: string[]) {
+    const body = { targets };
+    return await this.post<APIResponse>(this.baseURL + `/segments/${id}/addtargets`, body);
+  }
+
+  /**
+   * deleteSegmentTargets - Delete targets from a segment
+   *
+   * @param {string} id Segment ID
+   * @param {string[]} targets Targets to add to the segment
+   *
+   * @return {APIResponse} API response
+   */
+  async deleteSegmentTargets(id: string, targets: string[]) {
+    const body = { targets };
+    return await this.post<APIResponse>(this.baseURL + `/segments/${id}/deletetargets`, body);
+  }
+
+  /**
+   * querySegments - Query Segments
+   *
+   * @param {filter} filter MongoDB style filter conditions
+   * @param {QuerySegmentsOptions} options Options for sorting/paginating the results
    *
    * @return {Segment[]} Segments
    */
-  async querySegments(filters: SegmentFilters, options: SegmentQueryOptions = {}) {
+  async querySegments(filter: {}, options: QuerySegmentsOptions = {}) {
     return await this.get<{
       segments: Segment[];
     }>(this.baseURL + `/segments`, {
       payload: {
-        filter_conditions: filters,
+        filter,
         ...options,
       },
     });
   }
 
   /**
-   * updateSegment - Update a Campaign Segment
+   * deleteSegment - Delete a Campaign Segment
    *
    * @param {string} id Segment ID
-   * @param {Partial<SegmentData>} params Segment data
    *
-   * @return {Segment} Updated Segment
+   * @return {Promise<APIResponse>} The Server Response
    */
-  async updateSegment(id: string, params: Partial<SegmentData>) {
-    const { segment } = await this.put<{ segment: Segment }>(this.baseURL + `/segments/${id}`, { segment: params });
-    return segment;
+  async deleteSegment(id: string) {
+    return await this.delete<APIResponse>(this.baseURL + `/segments/${id}`);
   }
 
   /**
-   * deleteSegment - Delete a Campaign Segment
+   * segmentTargetExists - Check if a target exists in a segment
    *
-   * @param {string} id Segment ID
+   * @param {string} segmentId Segment ID
+   * @param {string} targetId Target ID
    *
    * @return {Promise<APIResponse>} The Server Response
    */
-  async deleteSegment(id: string) {
-    return this.delete<APIResponse>(this.baseURL + `/segments/${id}`);
+  async segmentTargetExists(segmentId: string, targetId: string) {
+    return await this.get<APIResponse>(this.baseURL + `/segments/${segmentId}/target/${targetId}`);
   }
 
   /**
@@ -2987,27 +3183,6 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
     return await this.post<APIResponse & TestCampaignResponse>(this.baseURL + `/campaigns/${id}/test`, { users });
   }
 
-  /**
-   * queryRecipients - Query Campaign Recipient Results
-   *
-   *
-   * @return {Recipient[]} Recipients
-   */
-  async queryRecipients(filters: RecipientFilters, options: RecipientQueryOptions = {}) {
-    return await this.get<{
-      campaigns: Record<string, Campaign>;
-      recipients: Recipient[];
-      segments: Record<string, Segment>;
-      channels?: Record<string, ChannelResponse<StreamChatGenerics>>;
-      users?: Record<string, UserResponse<StreamChatGenerics>>;
-    }>(this.baseURL + `/recipients`, {
-      payload: {
-        filter_conditions: filters,
-        ...options,
-      },
-    });
-  }
-
   /**
    * enrichURL - Get OpenGraph data of the given link
    *

package/src/events.ts

@@ -24,9 +24,11 @@ export const EVENT_MAP = {
   'notification.invite_rejected': true,
   'notification.invited': true,
   'notification.mark_read': true,
+  'notification.mark_unread': true,
   'notification.message_new': true,
   'notification.mutes_updated': true,
   'notification.removed_from_channel': true,
+  'notification.thread_message_new': true,
   'reaction.deleted': true,
   'reaction.new': true,
   'reaction.updated': true,

package/src/index.ts

@@ -3,6 +3,7 @@ export * from './client';
 export * from './client_state';
 export * from './channel';
 export * from './channel_state';
+export * from './thread';
 export * from './connection';
 export * from './events';
 export * from './permissions';
@@ -10,4 +11,4 @@ export * from './signing';
 export * from './token_manager';
 export * from './insights';
 export * from './types';
-export { isOwnUser, chatCodes, logChatPromiseExecution } from './utils';
+export { isOwnUser, chatCodes, logChatPromiseExecution, formatMessage } from './utils';