stream-chat 8.15.0 → 8.17.0

package/src/client.ts

@@ -95,6 +95,7 @@ import {
   GetImportResponse,
   GetMessageAPIResponse,
   GetRateLimitsResponse,
+  QueryThreadsAPIResponse,
   GetUnreadCountAPIResponse,
   GetUnreadCountBatchAPIResponse,
   ListChannelResponse,
@@ -163,8 +164,13 @@ import {
   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;
@@ -2595,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}`
@@ -2938,6 +3041,7 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
   async querySegments(filter: {}, options: QuerySegmentsOptions = {}) {
     return await this.get<{
       segments: Segment[];
+      next?: string;
     }>(this.baseURL + `/segments`, {
       payload: {
         filter,

package/src/events.ts

@@ -28,6 +28,7 @@ export const EVENT_MAP = {
   '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';

package/src/thread.ts

@@ -0,0 +1,116 @@
+import { StreamChat } from './client';
+import {
+  DefaultGenerics,
+  ExtendableGenerics,
+  MessageResponse,
+  ThreadResponse,
+  ChannelResponse,
+  FormatMessageResponse,
+  ReactionResponse,
+  UserResponse,
+} from './types';
+import { addToMessageList, formatMessage } from './utils';
+
+type ThreadReadStatus<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = Record<
+  string,
+  {
+    last_read: Date;
+    last_read_message_id: string;
+    unread_messages: number;
+    user: UserResponse<StreamChatGenerics>;
+  }
+>;
+
+export class Thread<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> {
+  id: string;
+  latestReplies: FormatMessageResponse<StreamChatGenerics>[] = [];
+  participants: ThreadResponse['thread_participants'] = [];
+  message: FormatMessageResponse<StreamChatGenerics>;
+  channel: ChannelResponse<StreamChatGenerics>;
+  _channel: ReturnType<StreamChat<StreamChatGenerics>['channel']>;
+  replyCount = 0;
+  _client: StreamChat<StreamChatGenerics>;
+  read: ThreadReadStatus<StreamChatGenerics> = {};
+
+  constructor(client: StreamChat<StreamChatGenerics>, t: ThreadResponse<StreamChatGenerics>) {
+    this.id = t.parent_message.id;
+    this.message = formatMessage(t.parent_message);
+    this.latestReplies = t.latest_replies.map(formatMessage);
+    this.participants = t.thread_participants;
+    this.replyCount = t.reply_count;
+    this.channel = t.channel;
+    this._channel = client.channel(t.channel.type, t.channel.id);
+    this._client = client;
+    for (const r of t.read) {
+      this.read[r.user.id] = {
+        ...r,
+        last_read: new Date(r.last_read),
+      };
+    }
+  }
+
+  getClient(): StreamChat<StreamChatGenerics> {
+    return this._client;
+  }
+
+  addReply(message: MessageResponse<StreamChatGenerics>) {
+    this.latestReplies = addToMessageList(this.latestReplies, formatMessage(message));
+  }
+
+  updateReply(message: MessageResponse<StreamChatGenerics>) {
+    this.latestReplies = this.latestReplies.map((m) => {
+      if (m.id === message.id) {
+        return formatMessage(message);
+      }
+      return m;
+    });
+  }
+
+  updateMessageOrReplyIfExists(message: MessageResponse<StreamChatGenerics>) {
+    if (!message.parent_id && message.id !== this.message.id) {
+      return;
+    }
+
+    if (message.parent_id && message.parent_id !== this.message.id) {
+      return;
+    }
+
+    if (message.parent_id && message.parent_id === this.message.id) {
+      this.updateReply(message);
+    }
+
+    if (!message.parent_id && message.id === this.message.id) {
+      this.message = formatMessage(message);
+    }
+  }
+
+  addReaction(
+    reaction: ReactionResponse<StreamChatGenerics>,
+    message?: MessageResponse<StreamChatGenerics>,
+    enforce_unique?: boolean,
+  ) {
+    if (!message) return;
+
+    this.latestReplies = this.latestReplies.map((m) => {
+      if (m.id === message.id) {
+        return formatMessage(
+          this._channel.state.addReaction(reaction, message, enforce_unique) as MessageResponse<StreamChatGenerics>,
+        );
+      }
+      return m;
+    });
+  }
+
+  removeReaction(reaction: ReactionResponse<StreamChatGenerics>, message?: MessageResponse<StreamChatGenerics>) {
+    if (!message) return;
+
+    this.latestReplies = this.latestReplies.map((m) => {
+      if (m.id === message.id) {
+        return formatMessage(
+          this._channel.state.removeReaction(reaction, message) as MessageResponse<StreamChatGenerics>,
+        );
+      }
+      return m;
+    });
+  }
+}

package/src/types.ts

@@ -478,6 +478,58 @@ export type GetMessageAPIResponse<
   StreamChatGenerics extends ExtendableGenerics = DefaultGenerics
 > = SendMessageAPIResponse<StreamChatGenerics>;
 
+export type ThreadResponse<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
+  channel: ChannelResponse<StreamChatGenerics>;
+  channel_cid: string;
+  created_at: string;
+  deleted_at: string;
+  latest_replies: MessageResponse<StreamChatGenerics>[];
+  parent_message: MessageResponse<StreamChatGenerics>;
+  parent_message_id: string;
+  read: {
+    last_read: string;
+    last_read_message_id: string;
+    unread_messages: number;
+    user: UserResponse<StreamChatGenerics>;
+  }[];
+  reply_count: number;
+  thread_participants: {
+    created_at: string;
+    user: UserResponse<StreamChatGenerics>;
+  }[];
+  title: string;
+  updated_at: string;
+};
+
+// TODO: Figure out a way to strongly type set and unset.
+export type PartialThreadUpdate = {
+  set?: Partial<Record<string, unknown>>;
+  unset?: Partial<Record<string, unknown>>;
+};
+
+export type QueryThreadsOptions = {
+  limit?: number;
+  next?: string;
+  participant_limit?: number;
+  reply_limit?: number;
+  watch?: boolean;
+};
+
+export type QueryThreadsAPIResponse<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = APIResponse & {
+  threads: ThreadResponse<StreamChatGenerics>[];
+  next?: string;
+};
+
+export type GetThreadOptions = {
+  participant_limit?: number;
+  reply_limit?: number;
+  watch?: boolean;
+};
+
+export type GetThreadAPIResponse<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = APIResponse & {
+  thread: ThreadResponse<StreamChatGenerics>;
+};
+
 export type GetMultipleMessagesAPIResponse<
   StreamChatGenerics extends ExtendableGenerics = DefaultGenerics
 > = APIResponse & {
@@ -510,7 +562,14 @@ export type GetUnreadCountAPIResponse = APIResponse & {
     last_read: string;
     unread_count: number;
   }[];
+  threads: {
+    last_read: string;
+    last_read_message_id: string;
+    parent_message_id: string;
+    unread_count: number;
+  }[];
   total_unread_count: number;
+  total_unread_threads_count: number;
 };
 
 export type GetUnreadCountBatchAPIResponse = APIResponse & {
@@ -893,6 +952,7 @@ export type MarkChannelsReadOptions<StreamChatGenerics extends ExtendableGeneric
 export type MarkReadOptions<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> = {
   client_id?: string;
   connection_id?: string;
+  thread_id?: string;
   user?: UserResponse<StreamChatGenerics>;
   user_id?: string;
 };
@@ -1099,6 +1159,7 @@ export type Event<StreamChatGenerics extends ExtendableGenerics = DefaultGeneric
   reaction?: ReactionResponse<StreamChatGenerics>;
   received_at?: string | Date;
   team?: string;
+  thread?: ThreadResponse<StreamChatGenerics>;
   // @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
@@ -1446,6 +1507,7 @@ export type UserFilters<StreamChatGenerics extends ExtendableGenerics = DefaultG
       | RequireOnlyOne<{
           $contains?: PrimitiveFilter<string>;
           $eq?: PrimitiveFilter<UserResponse<StreamChatGenerics>['teams']>;
+          $in?: PrimitiveFilter<UserResponse<StreamChatGenerics>['teams']>;
         }>
       | PrimitiveFilter<UserResponse<StreamChatGenerics>['teams']>;
     username?:
@@ -2425,8 +2487,8 @@ export type DeleteUserOptions = {
 export type SegmentType = 'channel' | 'user';
 
 export type SegmentData = {
-  description: string;
-  filter: {};
+  description?: string;
+  filter?: {};
 };
 
 export type Segment = {

package/src/utils.ts

@@ -1,5 +1,14 @@
 import FormData from 'form-data';
-import { AscDesc, ExtendableGenerics, DefaultGenerics, OwnUserBase, OwnUserResponse, UserResponse } from './types';
+import {
+  AscDesc,
+  ExtendableGenerics,
+  DefaultGenerics,
+  OwnUserBase,
+  OwnUserResponse,
+  UserResponse,
+  MessageResponse,
+  FormatMessageResponse,
+} from './types';
 import { AxiosRequestConfig } from 'axios';
 
 /**
@@ -263,3 +272,94 @@ export const axiosParamsSerializer: AxiosRequestConfig['paramsSerializer'] = (pa
 
   return newParams.join('&');
 };
+
+/**
+ * formatMessage - Takes the message object. Parses the dates, sets __html
+ * and sets the status to received if missing. Returns a message object
+ *
+ * @param {MessageResponse<StreamChatGenerics>} message a message object
+ *
+ */
+export function formatMessage<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics>(
+  message: MessageResponse<StreamChatGenerics>,
+): FormatMessageResponse<StreamChatGenerics> {
+  return {
+    ...message,
+    /**
+     * @deprecated please use `html`
+     */
+    __html: message.html,
+    // parse the date..
+    pinned_at: message.pinned_at ? new Date(message.pinned_at) : null,
+    created_at: message.created_at ? new Date(message.created_at) : new Date(),
+    updated_at: message.updated_at ? new Date(message.updated_at) : new Date(),
+    status: message.status || 'received',
+  };
+}
+
+export function addToMessageList<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics>(
+  messages: Array<FormatMessageResponse<StreamChatGenerics>>,
+  message: FormatMessageResponse<StreamChatGenerics>,
+  timestampChanged = false,
+  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];
+}