stream-chat 8.14.4 → 8.15.0

package/src/client.ts

@@ -96,6 +96,7 @@ import {
   GetMessageAPIResponse,
   GetRateLimitsResponse,
   GetUnreadCountAPIResponse,
+  GetUnreadCountBatchAPIResponse,
   ListChannelResponse,
   ListCommandsResponse,
   ListImportsPaginationOptions,
@@ -123,12 +124,10 @@ import {
   PushProviderListResponse,
   PushProviderUpsertResponse,
   QueryChannelsAPIResponse,
+  QuerySegmentsOptions,
   ReactionResponse,
   ReactivateUserOptions,
   ReactivateUsersOptions,
-  Recipient,
-  RecipientFilters,
-  RecipientQueryOptions,
   ReservedMessageFields,
   ReviewFlagReportOptions,
   ReviewFlagReportResponse,
@@ -138,8 +137,7 @@ import {
   SearchPayload,
   Segment,
   SegmentData,
-  SegmentFilters,
-  SegmentQueryOptions,
+  SegmentType,
   SendFileAPIResponse,
   StreamChatOptions,
   SyncOptions,
@@ -159,6 +157,7 @@ import {
   UpdatedMessage,
   UpdateMessageAPIResponse,
   UpdateMessageOptions,
+  UpdateSegmentData,
   UserCustomEvent,
   UserFilters,
   UserOptions,
@@ -1688,10 +1687,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
    *
@@ -2824,56 +2841,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 +3080,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
    *
@@ -3052,16 +3124,16 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
    *
    * @return {TaskResponse} A task ID
    */
-  async deleteUsers(user_ids: string[], options: DeleteUserOptions) {
-    if (options?.user !== 'soft' && options?.user !== 'hard') {
-      throw new Error('Invalid delete user options. user must be one of [soft hard]');
+  async deleteUsers(user_ids: string[], options: DeleteUserOptions = {}) {
+    if (typeof options.user !== 'undefined' && !['soft', 'hard', 'pruning'].includes(options.user)) {
+      throw new Error('Invalid delete user options. user must be one of [soft hard pruning]');
     }
-    if (options.messages !== undefined && options.messages !== 'soft' && options.messages !== 'hard') {
-      throw new Error('Invalid delete user options. messages must be one of [soft hard]');
-    }
-    if (options.conversations !== undefined && options.conversations !== 'soft' && options.conversations !== 'hard') {
+    if (typeof options.conversations !== 'undefined' && !['soft', 'hard'].includes(options.conversations)) {
       throw new Error('Invalid delete user options. conversations must be one of [soft hard]');
     }
+    if (typeof options.messages !== 'undefined' && !['soft', 'hard', 'pruning'].includes(options.messages)) {
+      throw new Error('Invalid delete user options. messages must be one of [soft hard pruning]');
+    }
     return await this.post<APIResponse & TaskResponse>(this.baseURL + `/users/delete`, {
       user_ids,
       ...options,

package/src/events.ts

@@ -24,6 +24,7 @@ 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,

package/src/types.ts

@@ -114,6 +114,10 @@ export type AppSettingsAPIResponse<StreamChatGenerics extends ExtendableGenerics
     campaign_enabled?: boolean;
     cdn_expiration_seconds?: number;
     custom_action_handler_url?: string;
+    datadog_info?: {
+      api_key: string;
+      site: string;
+    };
     disable_auth_checks?: boolean;
     disable_permissions_checks?: boolean;
     enforce_unique_usernames?: 'no' | 'app' | 'team';
@@ -247,6 +251,7 @@ export type BannedUsersResponse<StreamChatGenerics extends ExtendableGenerics =
 
 export type BlockListResponse = BlockList & {
   created_at?: string;
+  type?: string;
   updated_at?: string;
 };
 
@@ -508,6 +513,10 @@ export type GetUnreadCountAPIResponse = APIResponse & {
   total_unread_count: number;
 };
 
+export type GetUnreadCountBatchAPIResponse = APIResponse & {
+  counts_by_user: { [userId: string]: GetUnreadCountAPIResponse };
+};
+
 export type ListChannelResponse<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = APIResponse & {
   channel_types: Record<
     string,
@@ -558,6 +567,7 @@ export type MessageResponseBase<
   };
   latest_reactions?: ReactionResponse<StreamChatGenerics>[];
   mentioned_users?: UserResponse<StreamChatGenerics>[];
+  moderation_details?: ModerationDetailsResponse;
   own_reactions?: ReactionResponse<StreamChatGenerics>[] | null;
   pin_expires?: string | null;
   pinned_at?: string | null;
@@ -571,6 +581,18 @@ export type MessageResponseBase<
   updated_at?: string;
 };
 
+export type ModerationDetailsResponse = {
+  action: 'MESSAGE_RESPONSE_ACTION_BOUNCE' | (string & {});
+  error_msg: string;
+  harms: ModerationHarmResponse[];
+  original_text: string;
+};
+
+export type ModerationHarmResponse = {
+  name: string;
+  phrase_list_ids: number[];
+};
+
 export type MuteResponse<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
   user: UserResponse<StreamChatGenerics>;
   created_at?: string;
@@ -1055,8 +1077,13 @@ export type Event<StreamChatGenerics extends ExtendableGenerics = DefaultGeneric
   cid?: string;
   clear_history?: boolean;
   connection_id?: string;
+  // event creation timestamp, format Date ISO string
   created_at?: string;
+  // id of the message that was marked as unread - all the following messages are considered unread. (notification.mark_unread)
+  first_unread_message_id?: string;
   hard_delete?: boolean;
+  // creation date of a message with last_read_message_id, formatted as Date ISO string
+  last_read_at?: string;
   last_read_message_id?: string;
   mark_messages_deleted?: boolean;
   me?: OwnUserResponse<StreamChatGenerics>;
@@ -1072,9 +1099,14 @@ export type Event<StreamChatGenerics extends ExtendableGenerics = DefaultGeneric
   reaction?: ReactionResponse<StreamChatGenerics>;
   received_at?: string | Date;
   team?: string;
+  // @deprecated number of all unread messages across all current user's unread channels, equals unread_count
   total_unread_count?: number;
+  // number of all current user's channels with at least one unread message including the channel in this event
   unread_channels?: number;
+  // number of all unread messages across all current user's unread channels
   unread_count?: number;
+  // number of unread messages in the channel from this event (notification.mark_unread)
+  unread_messages?: number;
   user?: UserResponse<StreamChatGenerics>;
   user_id?: string;
   watcher_count?: number;
@@ -2365,40 +2397,68 @@ export type DeleteChannelsResponse = {
   result: Record<string, string>;
 } & Partial<TaskResponse>;
 
-export type DeleteType = 'soft' | 'hard';
+export type DeleteType = 'soft' | 'hard' | 'pruning';
 
 /*
   DeleteUserOptions specifies a collection of one or more `user_ids` to be deleted.
 
-  `user` soft|hard determines if the user needs to be hard- or soft-deleted, where hard-delete
-  implies that all related objects (messages, flags, etc) will be hard-deleted as well.
-  `conversations` soft|hard will delete any 1to1 channels that the user was a member of.
-  `messages` soft-hard will delete any messages that the user has sent.
-  `new_channel_owner_id` any channels owned by the hard-deleted user will be transferred to this user ID
+  `user`:
+    - soft: marks user as deleted and retains all user data 
+    - pruning: marks user as deleted and nullifies user information 
+    - hard: deletes user completely - this requires hard option for messages and conversation as well
+  `conversations`:
+    - soft: marks all conversation channels as deleted (same effect as Delete Channels with 'hard' option disabled)
+    - hard: deletes channel and all its data completely including messages (same effect as Delete Channels with 'hard' option enabled)
+  `messages`:
+    - soft: marks all user messages as deleted without removing any related message data
+    - pruning: marks all user messages as deleted, nullifies message information and removes some message data such as reactions and flags
+    - hard: deletes messages completely with all related information
+  `new_channel_owner_id`: any channels owned by the hard-deleted user will be transferred to this user ID
  */
 export type DeleteUserOptions = {
-  user: DeleteType;
-  conversations?: DeleteType;
+  conversations?: Exclude<DeleteType, 'pruning'>;
   messages?: DeleteType;
   new_channel_owner_id?: string;
+  user?: DeleteType;
 };
 
+export type SegmentType = 'channel' | 'user';
+
 export type SegmentData = {
   description: string;
   filter: {};
-  name: string;
-  type: 'channel' | 'user';
 };
 
 export type Segment = {
   created_at: string;
+  deleted_at: string;
   id: string;
-  in_use: boolean;
+  locked: boolean;
+  name: string;
   size: number;
-  status: 'computing' | 'ready';
+  type: SegmentType;
   updated_at: string;
 } & SegmentData;
 
+export type UpdateSegmentData = {
+  name: string;
+} & SegmentData;
+
+export type SortParam = {
+  field: string;
+  direction?: AscDesc;
+};
+
+export type Pager = {
+  limit?: number;
+  next?: string;
+  prev?: string;
+};
+
+export type QuerySegmentsOptions = {
+  sort?: SortParam[];
+} & Pager;
+
 export type CampaignSortField = {
   field: string;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -2416,12 +2476,9 @@ export type CampaignQueryOptions = {
 };
 
 export type SegmentQueryOptions = CampaignQueryOptions;
-export type RecipientQueryOptions = CampaignQueryOptions;
 
 // TODO: add better typing
-export type SegmentFilters = {};
 export type CampaignFilters = {};
-export type RecipientFilters = {};
 
 export type CampaignData = {
   attachments: Attachment[];
@@ -2462,20 +2519,7 @@ export type TestCampaignResponse = {
   results?: Record<string, string>;
 };
 
-export type DeleteCampaignOptions = {
-  recipients?: boolean;
-};
-
-export type Recipient = {
-  campaign_id: string;
-  channel_cid: string;
-  created_at: string;
-  status: 'pending' | 'sent' | 'failed';
-  updated_at: string;
-  details?: string;
-  message_id?: string;
-  receiver_id?: string;
-};
+export type DeleteCampaignOptions = {};
 
 export type TaskStatus = {
   created_at: string;