stream-chat 8.17.0 → 8.18.1

package/src/client.ts

@@ -11,6 +11,8 @@ import { StableWSConnection } from './connection';
 import { CheckSignature, DevToken, JWTUserToken } from './signing';
 import { TokenManager } from './token_manager';
 import { WSConnectionFallback } from './connection_fallback';
+import { Campaign } from './campaign';
+import { Segment } from './segment';
 import { isErrorResponse, isWSFailure } from './errors';
 import {
   addFileToFormData,
@@ -38,7 +40,7 @@ import {
   BaseDeviceFields,
   BlockList,
   BlockListResponse,
-  Campaign,
+  CampaignResponse,
   CampaignData,
   CampaignFilters,
   CampaignQueryOptions,
@@ -65,7 +67,6 @@ import {
   CustomPermissionOptions,
   DeactivateUsersOptions,
   DefaultGenerics,
-  DeleteCampaignOptions,
   DeleteChannelsResponse,
   DeleteCommandResponse,
   DeleteUserOptions,
@@ -136,7 +137,7 @@ import {
   SearchMessageSortBase,
   SearchOptions,
   SearchPayload,
-  Segment,
+  SegmentResponse,
   SegmentData,
   SegmentType,
   SendFileAPIResponse,
@@ -145,7 +146,6 @@ import {
   SyncResponse,
   TaskResponse,
   TaskStatus,
-  TestCampaignResponse,
   TestPushDataInput,
   TestSNSDataInput,
   TestSQSDataInput,
@@ -168,6 +168,10 @@ import {
   PartialThreadUpdate,
   QueryThreadsOptions,
   GetThreadOptions,
+  CampaignSort,
+  SegmentTargetsResponse,
+  QuerySegmentTargetsFilter,
+  SortParam,
 } from './types';
 import { InsightMetrics, postInsights } from './insights';
 import { Thread } from './thread';
@@ -2943,6 +2947,30 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
     return this.get<APIResponse & ExportChannelStatusResponse>(`${this.baseURL}/export_channels/${id}`);
   }
 
+  campaign(idOrData: string | CampaignData, data?: CampaignData) {
+    if (typeof idOrData === 'string') {
+      return new Campaign(this, idOrData, data);
+    }
+
+    return new Campaign(this, null, idOrData);
+  }
+
+  segment(type: SegmentType, idOrData: string | SegmentData, data?: SegmentData) {
+    if (typeof idOrData === 'string') {
+      return new Segment(this, type, idOrData, data);
+    }
+
+    return new Segment(this, type, null, idOrData);
+  }
+
+  validateServerSideAuth() {
+    if (!this.secret) {
+      throw new Error(
+        'Campaigns is a server-side only feature. Please initialize the client with a secret to use this feature.',
+      );
+    }
+  }
+
   /**
    * createSegment - Creates a segment
    *
@@ -2952,17 +2980,17 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
    * @param {string} name Segment name (valid UUID)
    * @param {SegmentData} params Segment data
    *
-   * @return {Segment} The created Segment
+   * @return {{segment: SegmentResponse} & APIResponse} The created Segment
    */
-  private async createSegment(type: SegmentType, id: string, name: string, data?: SegmentData): Promise<Segment> {
+  private async createSegment(type: SegmentType, id: string, name: string, data?: SegmentData) {
+    this.validateServerSideAuth();
     const body = {
       id,
       type,
       name,
       data,
     };
-    const { segment } = await this.post<{ segment: Segment }>(this.baseURL + `/segments`, body);
-    return segment;
+    return this.post<{ segment: SegmentResponse }>(this.baseURL + `/segments`, body);
   }
 
   /**
@@ -2974,8 +3002,9 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
    *
    * @return {Segment} The created Segment
    */
-  async createUserSegment(id: string, name: string, data?: SegmentData): Promise<Segment> {
-    return await this.createSegment('user', id, name, data);
+  async createUserSegment(id: string, name: string, data?: SegmentData) {
+    this.validateServerSideAuth();
+    return this.createSegment('user', id, name, data);
   }
 
   /**
@@ -2987,8 +3016,14 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
    *
    * @return {Segment} The created Segment
    */
-  async createChannelSegment(id: string, name: string, data?: SegmentData): Promise<Segment> {
-    return await this.createSegment('channel', id, name, data);
+  async createChannelSegment(id: string, name: string, data?: SegmentData) {
+    this.validateServerSideAuth();
+    return this.createSegment('channel', id, name, data);
+  }
+
+  async getSegment(id: string) {
+    this.validateServerSideAuth();
+    return this.get<{ segment: SegmentResponse } & APIResponse>(this.baseURL + `/segments/${id}`);
   }
 
   /**
@@ -3000,8 +3035,8 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
    * @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;
+    this.validateServerSideAuth();
+    return this.put<{ segment: SegmentResponse }>(this.baseURL + `/segments/${id}`, data);
   }
 
   /**
@@ -3013,21 +3048,39 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
    * @return {APIResponse} API response
    */
   async addSegmentTargets(id: string, targets: string[]) {
-    const body = { targets };
-    return await this.post<APIResponse>(this.baseURL + `/segments/${id}/addtargets`, body);
+    this.validateServerSideAuth();
+    const body = { target_ids: targets };
+    return this.post<APIResponse>(this.baseURL + `/segments/${id}/addtargets`, body);
   }
 
+  async querySegmentTargets(
+    id: string,
+    filter: QuerySegmentTargetsFilter | null = {},
+    sort: SortParam[] | null | [] = [],
+    options = {},
+  ) {
+    this.validateServerSideAuth();
+    return this.post<{ targets: SegmentTargetsResponse[]; next?: string } & APIResponse>(
+      this.baseURL + `/segments/${id}/targets/query`,
+      {
+        filter: filter || {},
+        sort: sort || [],
+        ...options,
+      },
+    );
+  }
   /**
-   * deleteSegmentTargets - Delete targets from a segment
+   * removeSegmentTargets - Remove 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);
+  async removeSegmentTargets(id: string, targets: string[]) {
+    this.validateServerSideAuth();
+    const body = { target_ids: targets };
+    return this.post<APIResponse>(this.baseURL + `/segments/${id}/deletetargets`, body);
   }
 
   /**
@@ -3038,15 +3091,17 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
    *
    * @return {Segment[]} Segments
    */
-  async querySegments(filter: {}, options: QuerySegmentsOptions = {}) {
-    return await this.get<{
-      segments: Segment[];
-      next?: string;
-    }>(this.baseURL + `/segments`, {
-      payload: {
-        filter,
-        ...options,
-      },
+  async querySegments(filter: {}, sort?: SortParam[], options: QuerySegmentsOptions = {}) {
+    this.validateServerSideAuth();
+    return this.post<
+      {
+        segments: SegmentResponse[];
+        next?: string;
+      } & APIResponse
+    >(this.baseURL + `/segments/query`, {
+      filter,
+      sort,
+      ...options,
     });
   }
 
@@ -3058,7 +3113,8 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
    * @return {Promise<APIResponse>} The Server Response
    */
   async deleteSegment(id: string) {
-    return await this.delete<APIResponse>(this.baseURL + `/segments/${id}`);
+    this.validateServerSideAuth();
+    return this.delete<APIResponse>(this.baseURL + `/segments/${id}`);
   }
 
   /**
@@ -3070,7 +3126,8 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
    * @return {Promise<APIResponse>} The Server Response
    */
   async segmentTargetExists(segmentId: string, targetId: string) {
-    return await this.get<APIResponse>(this.baseURL + `/segments/${segmentId}/target/${targetId}`);
+    this.validateServerSideAuth();
+    return this.get<APIResponse>(this.baseURL + `/segments/${segmentId}/target/${targetId}`);
   }
 
   /**
@@ -3081,27 +3138,38 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
    * @return {Campaign} The Created Campaign
    */
   async createCampaign(params: CampaignData) {
-    const { campaign } = await this.post<{ campaign: Campaign }>(this.baseURL + `/campaigns`, { campaign: params });
-    return campaign;
+    this.validateServerSideAuth();
+    return this.post<{ campaign: CampaignResponse } & APIResponse>(this.baseURL + `/campaigns`, { ...params });
   }
 
+  async getCampaign(id: string) {
+    this.validateServerSideAuth();
+    return this.get<{ campaign: CampaignResponse } & APIResponse>(this.baseURL + `/campaigns/${id}`);
+  }
+
+  async startCampaign(id: string, scheduledFor?: string) {
+    this.validateServerSideAuth();
+    return this.post<{ campaign: CampaignResponse } & APIResponse>(this.baseURL + `/campaigns/${id}/start`, {
+      scheduled_for: scheduledFor,
+    });
+  }
   /**
    * queryCampaigns - Query Campaigns
    *
    *
    * @return {Campaign[]} Campaigns
    */
-  async queryCampaigns(filters: CampaignFilters, options: CampaignQueryOptions = {}) {
-    return await this.get<{
-      campaigns: Campaign[];
-      segments: Record<string, Segment>;
-      channels?: Record<string, ChannelResponse<StreamChatGenerics>>;
-      users?: Record<string, UserResponse<StreamChatGenerics>>;
-    }>(this.baseURL + `/campaigns`, {
-      payload: {
-        filter_conditions: filters,
-        ...options,
-      },
+  async queryCampaigns(filter: CampaignFilters, sort?: CampaignSort, options?: CampaignQueryOptions) {
+    this.validateServerSideAuth();
+    return await this.post<
+      {
+        campaigns: CampaignResponse[];
+        next?: string;
+      } & APIResponse
+    >(this.baseURL + `/campaigns/query`, {
+      filter,
+      sort,
+      ...(options || {}),
     });
   }
 
@@ -3114,10 +3182,8 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
    * @return {Campaign} Updated Campaign
    */
   async updateCampaign(id: string, params: Partial<CampaignData>) {
-    const { campaign } = await this.put<{ campaign: Campaign }>(this.baseURL + `/campaigns/${id}`, {
-      campaign: params,
-    });
-    return campaign;
+    this.validateServerSideAuth();
+    return this.put<{ campaign: CampaignResponse }>(this.baseURL + `/campaigns/${id}`, params);
   }
 
   /**
@@ -3127,24 +3193,9 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
    *
    * @return {Promise<APIResponse>} The Server Response
    */
-  async deleteCampaign(id: string, params: DeleteCampaignOptions = {}) {
-    return this.delete<APIResponse>(this.baseURL + `/campaigns/${id}`, params);
-  }
-
-  /**
-   * scheduleCampaign - Schedule a Campaign
-   *
-   * @param {string} id Campaign ID
-   * @param {{scheduledFor: number}} params Schedule params
-   *
-   * @return {Campaign} Scheduled Campaign
-   */
-  async scheduleCampaign(id: string, params: { scheduledFor: number }) {
-    const { scheduledFor } = params;
-    const { campaign } = await this.patch<{ campaign: Campaign }>(this.baseURL + `/campaigns/${id}/schedule`, {
-      scheduled_for: scheduledFor,
-    });
-    return campaign;
+  async deleteCampaign(id: string) {
+    this.validateServerSideAuth();
+    return this.delete<APIResponse>(this.baseURL + `/campaigns/${id}`);
   }
 
   /**
@@ -3155,35 +3206,11 @@ export class StreamChat<StreamChatGenerics extends ExtendableGenerics = DefaultG
    * @return {Campaign} Stopped Campaign
    */
   async stopCampaign(id: string) {
-    const { campaign } = await this.patch<{ campaign: Campaign }>(this.baseURL + `/campaigns/${id}/stop`);
-    return campaign;
-  }
-
-  /**
-   * resumeCampaign - Resume a Campaign
-   *
-   * @param {string} id Campaign ID
-   *
-   * @return {Campaign} Resumed Campaign
-   */
-  async resumeCampaign(id: string) {
-    const { campaign } = await this.patch<{ campaign: Campaign }>(this.baseURL + `/campaigns/${id}/resume`);
+    this.validateServerSideAuth();
+    const { campaign } = await this.patch<{ campaign: CampaignResponse }>(this.baseURL + `/campaigns/${id}/stop`);
     return campaign;
   }
 
-  /**
-   * testCampaign - Test a Campaign
-   *
-   * @param {string} id Campaign ID
-   * @param {{users: string[]}} params Test params
-   *
-   * @return {TestCampaignResponse} Test campaign response
-   */
-  async testCampaign(id: string, params: { users: string[] }) {
-    const { users } = params;
-    return await this.post<APIResponse & TestCampaignResponse>(this.baseURL + `/campaigns/${id}/test`, { users });
-  }
-
   /**
    * enrichURL - Get OpenGraph data of the given link
    *

package/src/index.ts

@@ -11,4 +11,6 @@ export * from './signing';
 export * from './token_manager';
 export * from './insights';
 export * from './types';
+export * from './segment';
+export * from './campaign';
 export { isOwnUser, chatCodes, logChatPromiseExecution, formatMessage } from './utils';

package/src/segment.ts

@@ -0,0 +1,89 @@
+import { StreamChat } from './client';
+import {
+  DefaultGenerics,
+  ExtendableGenerics,
+  QuerySegmentTargetsFilter,
+  SegmentData,
+  SegmentResponse,
+  SortParam,
+} from './types';
+
+type SegmentType = 'user' | 'channel';
+
+type SegmentUpdatableFields = {
+  description?: string;
+  filter?: {};
+  name?: string;
+};
+
+export class Segment<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> {
+  type: SegmentType;
+  id?: string | null;
+  client: StreamChat<StreamChatGenerics>;
+  data?: SegmentData | SegmentResponse;
+
+  constructor(client: StreamChat<StreamChatGenerics>, type: SegmentType, id: string | null, data?: SegmentData) {
+    this.client = client;
+    this.type = type;
+    this.id = id;
+    this.data = data;
+  }
+
+  async create() {
+    const body = {
+      id: this.id,
+      type: this.type,
+      name: this.data?.name,
+      filter: this.data?.filter,
+      description: this.data?.description,
+      all_users: this.data?.all_users,
+    };
+
+    return this.client.post<{ segment: SegmentResponse }>(this.client.baseURL + `/segments`, body);
+  }
+
+  verifySegmentId() {
+    if (!this.id) {
+      throw new Error(
+        'Segment id is missing. Either create the segment using segment.create() or set the id during instantiation - const segment = client.segment(id)',
+      );
+    }
+  }
+
+  async get() {
+    this.verifySegmentId();
+    return this.client.getSegment(this.id as string);
+  }
+
+  async update(data: Partial<SegmentUpdatableFields>) {
+    this.verifySegmentId();
+
+    return this.client.updateSegment(this.id as string, data);
+  }
+
+  async addTargets(targets: string[]) {
+    this.verifySegmentId();
+    return this.client.addSegmentTargets(this.id as string, targets);
+  }
+
+  async removeTargets(targets: string[]) {
+    this.verifySegmentId();
+    return this.client.removeSegmentTargets(this.id as string, targets);
+  }
+
+  async delete() {
+    this.verifySegmentId();
+    return this.client.deleteSegment(this.id as string);
+  }
+
+  async targetExists(targetId: string) {
+    this.verifySegmentId();
+    return this.client.segmentTargetExists(this.id as string, targetId);
+  }
+
+  async queryTargets(filter: QuerySegmentTargetsFilter | null = {}, sort: SortParam[] | null | [] = [], options = {}) {
+    this.verifySegmentId();
+
+    return this.client.querySegmentTargets(this.id as string, filter, sort, options);
+  }
+}

package/src/thread.ts

@@ -41,11 +41,13 @@ export class Thread<StreamChatGenerics extends ExtendableGenerics = DefaultGener
     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),
-      };
+    if (t.read) {
+      for (const r of t.read) {
+        this.read[r.user.id] = {
+          ...r,
+          last_read: new Date(r.last_read),
+        };
+      }
     }
   }
 
@@ -53,8 +55,17 @@ export class Thread<StreamChatGenerics extends ExtendableGenerics = DefaultGener
     return this._client;
   }
 
+  /**
+   * addReply - Adds or updates a latestReplies to the thread
+   *
+   * @param {MessageResponse<StreamChatGenerics>} message reply message to be added.
+   */
   addReply(message: MessageResponse<StreamChatGenerics>) {
-    this.latestReplies = addToMessageList(this.latestReplies, formatMessage(message));
+    if (message.parent_id !== this.message.id) {
+      throw new Error('Message does not belong to this thread');
+    }
+
+    this.latestReplies = addToMessageList(this.latestReplies, formatMessage(message), true);
   }
 
   updateReply(message: MessageResponse<StreamChatGenerics>) {
@@ -77,6 +88,7 @@ export class Thread<StreamChatGenerics extends ExtendableGenerics = DefaultGener
 
     if (message.parent_id && message.parent_id === this.message.id) {
       this.updateReply(message);
+      return;
     }
 
     if (!message.parent_id && message.id === this.message.id) {

package/src/types.ts

@@ -673,6 +673,7 @@ export type OwnUserBase<StreamChatGenerics extends ExtendableGenerics = DefaultG
   total_unread_count: number;
   unread_channels: number;
   unread_count: number;
+  unread_threads: number;
   invisible?: boolean;
   roles?: string[];
 };
@@ -2487,17 +2488,19 @@ export type DeleteUserOptions = {
 export type SegmentType = 'channel' | 'user';
 
 export type SegmentData = {
+  all_users?: boolean;
   description?: string;
   filter?: {};
+  name?: string;
 };
 
-export type Segment = {
+export type SegmentResponse = {
   created_at: string;
   deleted_at: string;
   id: string;
   locked: boolean;
-  name: string;
   size: number;
+  task_id: string;
   type: SegmentType;
   updated_at: string;
 } & SegmentData;
@@ -2506,6 +2509,12 @@ export type UpdateSegmentData = {
   name: string;
 } & SegmentData;
 
+export type SegmentTargetsResponse = {
+  created_at: string;
+  segment_id: string;
+  target_id: string;
+};
+
 export type SortParam = {
   field: string;
   direction?: AscDesc;
@@ -2517,10 +2526,18 @@ export type Pager = {
   prev?: string;
 };
 
-export type QuerySegmentsOptions = {
-  sort?: SortParam[];
-} & Pager;
+export type QuerySegmentsOptions = Pager;
 
+export type QuerySegmentTargetsFilter = {
+  target_id?: {
+    $eq?: string;
+    $gte?: string;
+    $in?: string[];
+    $lte?: string;
+  };
+};
+export type QuerySegmentTargetsSort = {};
+export type QuerySegmentTargetsOptions = Pick<Pager, 'next' | 'limit'>;
 export type CampaignSortField = {
   field: string;
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -2534,6 +2551,8 @@ export type CampaignSort = {
 
 export type CampaignQueryOptions = {
   limit?: number;
+  next?: string;
+  prev?: string;
   sort?: CampaignSort;
 };
 
@@ -2543,43 +2562,43 @@ export type SegmentQueryOptions = CampaignQueryOptions;
 export type CampaignFilters = {};
 
 export type CampaignData = {
-  attachments: Attachment[];
-  channel_type: string;
-  defaults: Record<string, string>;
-  name: string;
-  segment_id: string;
-  text: string;
+  channel_template?: {
+    type: string;
+    custom?: {};
+    id?: string;
+    members?: string[];
+  };
+  create_channels?: boolean;
+  deleted_at?: string;
   description?: string;
+  id?: string | null;
+  message_template?: {
+    text: string;
+    attachments?: Attachment[];
+    custom?: {};
+  };
+  name?: string;
+  segment_ids?: string[];
   sender_id?: string;
+  skip_push?: boolean;
+  skip_webhook?: boolean;
+  user_ids?: string[];
 };
 
-export type CampaignStatusName = 'draft' | 'stopped' | 'scheduled' | 'completed' | 'failed' | 'in_progress';
-
-export type CampaignStatus = {
-  status: CampaignStatusName;
-  completed_at?: string;
-  errored_messages?: number;
-  failed_at?: string;
-  resumed_at?: string;
-  scheduled_at?: string;
-  scheduled_for?: string;
-  sent_messages?: number;
-  stopped_at?: string;
-  task_id?: string;
+export type CampaignStats = {
+  progress?: number;
+  stats_channels_created?: number;
+  stats_completed_at?: string;
+  stats_messages_sent?: number;
+  stats_started_at?: string;
 };
-
-export type Campaign = {
+export type CampaignResponse = {
   created_at: string;
   id: string;
+  stats: CampaignStats;
   updated_at: string;
-} & CampaignData &
-  CampaignStatus;
-
-export type TestCampaignResponse = {
-  status: CampaignStatusName;
-  details?: string;
-  results?: Record<string, string>;
-};
+  scheduled_for?: string;
+} & CampaignData;
 
 export type DeleteCampaignOptions = {};
 

package/src/utils.ts

@@ -84,6 +84,7 @@ export function isOwnUserBaseProperty(property: string) {
     total_unread_count: true,
     unread_channels: true,
     unread_count: true,
+    unread_threads: true,
     invisible: true,
     roles: true,
   };