stream-chat 4.2.0 → 4.4.1

package/src/client.ts

@@ -72,7 +72,7 @@ import {
   ListCommandsResponse,
   LiteralStringForUnion,
   Logger,
-  MarkAllReadOptions,
+  MarkChannelsReadOptions,
   Message,
   MessageFilters,
   MessageResponse,
@@ -84,6 +84,7 @@ import {
   PartialUserUpdate,
   PermissionAPIResponse,
   PermissionsAPIResponse,
+  PushProvider,
   ReactionResponse,
   SearchOptions,
   SearchPayload,
@@ -111,7 +112,13 @@ import {
   Segment,
   Campaign,
   CampaignData,
+  OGAttachment,
+  TaskStatus,
+  DeleteUserOptions,
+  DeleteChannelsResponse,
+  TaskResponse,
 } from './types';
+import { InsightTypes, InsightMetrics } from './insights';
 
 function isString(x: unknown): x is string {
   return typeof x === 'string' || x instanceof String;
@@ -191,6 +198,7 @@ export class StreamChat<
   wsConnection: StableWSConnection<ChannelType, CommandType, UserType> | null;
   wsPromise: ConnectAPIResponse<ChannelType, CommandType, UserType> | null;
   consecutiveFailures: number;
+  insightMetrics: InsightMetrics;
 
   /**
    * Initialize a client
@@ -285,6 +293,7 @@ export class StreamChat<
     // generated from secret.
     this.tokenManager = new TokenManager(this.secret);
     this.consecutiveFailures = 0;
+    this.insightMetrics = new InsightMetrics();
 
     /**
      * logger function should accept 3 parameters:
@@ -729,6 +738,7 @@ export class StreamChat<
 				  apnTemplate: '{}', //if app doesn't have apn configured it will error
 				  firebaseTemplate: '{}', //if app doesn't have firebase configured it will error
 				  firebaseDataTemplate: '{}', //if app doesn't have firebase configured it will error
+				  huaweiDataTemplate: '{}' //if app doesn't have huawei configured it will error
 				  skipDevices: true, // skip config/device checks and sending to real devices
 			}
 	 */
@@ -741,6 +751,9 @@ export class StreamChat<
       ...(data.firebaseDataTemplate
         ? { firebase_data_template: data.firebaseDataTemplate }
         : {}),
+      ...(data.huaweiDataTemplate
+        ? { huawei_data_template: data.huaweiDataTemplate }
+        : {}),
       ...(data.skipDevices ? { skip_devices: true } : {}),
     });
   }
@@ -748,13 +761,11 @@ export class StreamChat<
   /**
    * testSQSSettings - Tests that the given or configured SQS configuration is valid
    *
-   * @param {string} userID User ID. If user has no devices, it will error
-   * @param {TestPushDataInput} [data] Overrides for push templates/message used
+   * @param {TestSQSDataInput} [data] Overrides SQS settings for testing if needed
    * 		IE: {
-				  messageID: 'id-of-message',//will error if message does not exist
-				  apnTemplate: '{}', //if app doesn't have apn configured it will error
-				  firebaseTemplate: '{}', //if app doesn't have firebase configured it will error
-				  firebaseDataTemplate: '{}', //if app doesn't have firebase configured it will error
+				  sqs_key: 'auth_key',
+				  sqs_secret: 'auth_secret',
+				  sqs_url: 'url_to_queue',
 			}
    */
   async testSQSSettings(data: TestSQSDataInput = {}) {
@@ -1609,6 +1620,7 @@ export class StreamChat<
     }
 
     // The StableWSConnection handles all the reconnection logic.
+
     this.wsConnection = new StableWSConnection<ChannelType, CommandType, UserType>({
       wsBaseURL: client.wsBaseURL,
       clientID: client.clientID,
@@ -1623,6 +1635,8 @@ export class StreamChat<
       eventCallback: this.dispatchEvent as (event: ConnectionChangeEvent) => void,
       logger: this.logger,
       device: this.options.device,
+      postInsights: this.options.enableInsights ? this.postInsights : undefined,
+      insightMetrics: this.insightMetrics,
     });
 
     let warmUpPromise;
@@ -1890,7 +1904,7 @@ export class StreamChat<
    *
    * @param {BaseDeviceFields} device the device object
    * @param {string} device.id device id
-   * @param {string} device.push_provider the push provider (apn or firebase)
+   * @param {string} device.push_provider the push provider
    *
    */
   setLocalDevice(device: BaseDeviceFields) {
@@ -1905,11 +1919,11 @@ export class StreamChat<
    * addDevice - Adds a push device for a user.
    *
    * @param {string} id the device id
-   * @param {'apn' | 'firebase'} push_provider the push provider (apn or firebase)
+   * @param {PushProvider} push_provider the push provider
    * @param {string} [userID] the user id (defaults to current user)
    *
    */
-  async addDevice(id: string, push_provider: 'apn' | 'firebase', userID?: string) {
+  async addDevice(id: string, push_provider: PushProvider, userID?: string) {
     return await this.post<APIResponse>(this.baseURL + '/devices', {
       id,
       push_provider,
@@ -2505,12 +2519,24 @@ export class StreamChat<
   }
 
   /**
+   * @deprecated use markChannelsRead instead
+   *
    * markAllRead - marks all channels for this user as read
    * @param {MarkAllReadOptions<UserType>} [data]
    *
    * @return {Promise<APIResponse>}
    */
-  async markAllRead(data: MarkAllReadOptions<UserType> = {}) {
+  markAllRead = this.markChannelsRead;
+
+  /**
+   * markChannelsRead - marks channels read -
+   * it accepts a map of cid:messageid pairs, if messageid is empty, the whole channel will be marked as read
+   *
+   * @param {MarkChannelsReadOptions <UserType>} [data]
+   *
+   * @return {Promise<APIResponse>}
+   */
+  async markChannelsRead(data: MarkChannelsReadOptions<UserType> = {}) {
     await this.post<APIResponse>(this.baseURL + '/channels/read', {
       ...data,
     });
@@ -2692,6 +2718,7 @@ export class StreamChat<
    *
    * @param {Omit<MessageResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType>, 'mentioned_users'> & { mentioned_users?: string[] }} message object, id needs to be specified
    * @param {string | { id: string }} [userId]
+   * @param {boolean} [options.skip_enrich_url] Do not try to enrich the URLs within message
    *
    * @return {APIResponse & { message: MessageResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType> }} Response that includes the message
    */
@@ -2705,6 +2732,7 @@ export class StreamChat<
       UserType
     >,
     userId?: string | { id: string },
+    options?: { skip_enrich_url?: boolean },
   ) {
     if (!message.id) {
       throw Error('Please specify the message id when calling updateMessage');
@@ -2777,6 +2805,7 @@ export class StreamChat<
       >
     >(this.baseURL + `/messages/${message.id}`, {
       message: clonedMessage,
+      ...options,
     });
   }
 
@@ -2789,12 +2818,15 @@ export class StreamChat<
    *         example: {id: "user1", set:{text: "hi"}, unset:["color"]}
    * @param {string | { id: string }} [userId]
    *
+   * @param {boolean} [options.skip_enrich_url] Do not try to enrich the URLs within message
+   *
    * @return {APIResponse & { message: MessageResponse<AttachmentType, ChannelType, CommandType, MessageType, ReactionType, UserType> }} Response that includes the updated message
    */
   async partialUpdateMessage(
     id: string,
     partialMessageObject: PartialMessageUpdate<MessageType>,
     userId?: string | { id: string },
+    options?: { skip_enrich_url?: boolean },
   ) {
     if (!id) {
       throw Error('Please specify the message id when calling partialUpdateMessage');
@@ -2814,6 +2846,7 @@ export class StreamChat<
       >
     >(this.baseURL + `/messages/${id}`, {
       ...partialMessageObject,
+      ...options,
       user,
     });
   }
@@ -3279,4 +3312,95 @@ export class StreamChat<
     );
     return campaign;
   }
+
+  /**
+   * enrichURL - Get OpenGraph data of the given link
+   *
+   * @param {string} url link
+   * @return {OGAttachment} OG Attachment
+   */
+  async enrichURL(url: string) {
+    return this.get<APIResponse & OGAttachment>(this.baseURL + `/og`, { url });
+  }
+
+  /**
+   * getTask - Gets status of a long running task
+   *
+   * @param {string} id Task ID
+   *
+   * @return {TaskStatus} The task status
+   */
+  async getTask(id: string) {
+    return this.get<APIResponse & TaskStatus>(`${this.baseURL}/tasks/${id}`);
+  }
+
+  /**
+   * deleteChannels - Deletes a list of channel
+   *
+   * @param {string[]} cids Channel CIDs
+   * @param {boolean} [options.hard_delete] Defines if the channel is hard deleted or not
+   *
+   * @return {DeleteChannelsResponse} Result of the soft deletion, if server-side, it holds the task ID as well
+   */
+  async deleteChannels(cids: string[], options: { hard_delete?: boolean } = {}) {
+    return await this.post<APIResponse & DeleteChannelsResponse>(
+      this.baseURL + `/channels/delete`,
+      { cids, ...options },
+    );
+  }
+
+  postInsights = async (insightType: InsightTypes, insights: Record<string, unknown>) => {
+    const maxAttempts = 3;
+    for (let i = 0; i < maxAttempts; i++) {
+      try {
+        await this.axiosInstance.post(
+          `https://insights.stream-io-api.com/insights/${insightType}`,
+          insights,
+        );
+      } catch (e) {
+        this.logger('warn', `failed to send insights event ${insightType}`, {
+          tags: ['insights', 'connection'],
+          error: e,
+          insights,
+        });
+        await sleep((i + 1) * 3000);
+        continue;
+      }
+      break;
+    }
+  };
+
+  /**
+   * deleteUsers - Batch Delete Users
+   *
+   * @param {string[]} user_ids which users to delete
+   * @param {DeleteUserOptions} options Configuration how to delete users
+   *
+   * @return {APIResponse} 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]');
+    }
+    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'
+    ) {
+      throw new Error(
+        'Invalid delete user options. conversations must be one of [soft hard]',
+      );
+    }
+    return await this.post<APIResponse & TaskResponse>(this.baseURL + `/users/delete`, {
+      user_ids,
+      ...options,
+    });
+  }
 }

package/src/connection.ts

@@ -1,6 +1,12 @@
 import WebSocket from 'isomorphic-ws';
-import { chatCodes, sleep, retryInterval } from './utils';
+import { chatCodes, sleep, retryInterval, randomId } from './utils';
 import { TokenManager } from './token_manager';
+import {
+  buildWsFatalInsight,
+  buildWsSuccessAfterFailureInsight,
+  InsightMetrics,
+  InsightTypes,
+} from './insights';
 import {
   BaseDeviceFields,
   ConnectAPIResponse,
@@ -30,6 +36,7 @@ type Constructor<
   authType: 'anonymous' | 'jwt';
   clientID: string;
   eventCallback: (event: ConnectionChangeEvent) => void;
+  insightMetrics: InsightMetrics;
   logger: Logger | (() => void);
   messageCallback: (messageEvent: WebSocket.MessageEvent) => void;
   recoverCallback: (
@@ -41,6 +48,7 @@ type Constructor<
   userID: string;
   wsBaseURL: string;
   device?: BaseDeviceFields;
+  postInsights?: (eventType: InsightTypes, event: Record<string, unknown>) => void;
 };
 
 /**
@@ -78,7 +86,6 @@ export class StableWSConnection<
   userID: Constructor<ChannelType, CommandType, UserType>['userID'];
   wsBaseURL: Constructor<ChannelType, CommandType, UserType>['wsBaseURL'];
   device: Constructor<ChannelType, CommandType, UserType>['device'];
-
   connectionID?: string;
   connectionOpen?: ConnectAPIResponse<ChannelType, CommandType, UserType>;
   consecutiveFailures: number;
@@ -97,11 +104,14 @@ export class StableWSConnection<
       StatusCode?: string | number;
     },
   ) => void;
+  requestID: string | undefined;
+  connectionStartTimestamp: number | undefined;
   resolvePromise?: (value: WebSocket.MessageEvent) => void;
   totalFailures: number;
   ws?: WebSocket;
   wsID: number;
-
+  postInsights?: Constructor<ChannelType, CommandType, UserType>['postInsights'];
+  insightMetrics: InsightMetrics;
   constructor({
     apiKey,
     authType,
@@ -116,6 +126,8 @@ export class StableWSConnection<
     userID,
     wsBaseURL,
     device,
+    postInsights,
+    insightMetrics,
   }: Constructor<ChannelType, CommandType, UserType>) {
     this.wsBaseURL = wsBaseURL;
     this.clientID = clientID;
@@ -149,6 +161,8 @@ export class StableWSConnection<
     this.pingInterval = 25 * 1000;
     this.connectionCheckTimeout = this.pingInterval + 10 * 1000;
     this._listenForConnectionChanges();
+    this.postInsights = postInsights;
+    this.insightMetrics = insightMetrics;
   }
 
   /**
@@ -244,13 +258,19 @@ export class StableWSConnection<
     ]);
   }
 
-  _buildUrl = () => {
+  /**
+   * Builds and returns the url for websocket.
+   * @param reqID Unique identifier generated on client side, to help tracking apis on backend.
+   * @returns url string
+   */
+  _buildUrl = (reqID?: string) => {
     const params = {
       user_id: this.user.id,
       user_details: this.user,
       user_token: this.tokenManager.getToken(),
       server_determines_connection_id: true,
       device: this.device,
+      request_id: reqID,
     };
     const qs = encodeURIComponent(JSON.stringify(params));
     const token = this.tokenManager.getToken();
@@ -352,11 +372,12 @@ export class StableWSConnection<
   async _connect() {
     if (this.isConnecting) return; // simply ignore _connect if it's currently trying to connect
     this.isConnecting = true;
-
+    this.requestID = randomId();
+    this.insightMetrics.connectionStartTimestamp = new Date().getTime();
     try {
       await this.tokenManager.tokenReady();
       this._setupConnectionPromise();
-      const wsURL = this._buildUrl();
+      const wsURL = this._buildUrl(this.requestID);
       this.ws = new WebSocket(wsURL);
       this.ws.onopen = this.onopen.bind(this, this.wsID);
       this.ws.onclose = this.onclose.bind(this, this.wsID);
@@ -367,6 +388,13 @@ export class StableWSConnection<
 
       if (response) {
         this.connectionID = response.connection_id;
+        if (this.insightMetrics.wsConsecutiveFailures > 0) {
+          this.postInsights?.(
+            'ws_success_after_failure',
+            buildWsSuccessAfterFailureInsight(this),
+          );
+          this.insightMetrics.wsConsecutiveFailures = 0;
+        }
         return response;
       }
     } catch (err) {
@@ -559,6 +587,12 @@ export class StableWSConnection<
   };
 
   onclose = (wsID: number, event: WebSocket.CloseEvent) => {
+    if (event.code !== chatCodes.WS_CLOSED_SUCCESS) {
+      this.insightMetrics.wsConsecutiveFailures++;
+      this.insightMetrics.wsTotalFailures++;
+      this.postInsights?.('ws_fatal', buildWsFatalInsight(this, event));
+    }
+
     this.logger('info', 'connection:onclose() - onclose callback - ' + event.code, {
       tags: ['connection'],
       event,
@@ -701,25 +735,20 @@ export class StableWSConnection<
 
   /**
    * _listenForConnectionChanges - Adds an event listener for the browser going online or offline
-   *
    */
   _listenForConnectionChanges = () => {
-    if (
-      typeof window !== 'undefined' &&
-      window != null &&
-      window.addEventListener != null
-    ) {
+    // (typeof window !== 'undefined') check is for environments where window is not defined, such as nextjs environment,
+    // and thus (window === undefined) will result in ReferenceError.
+    if (typeof window !== 'undefined' && window?.addEventListener) {
       window.addEventListener('offline', this.onlineStatusChanged);
       window.addEventListener('online', this.onlineStatusChanged);
     }
   };
 
   _removeConnectionListeners = () => {
-    if (
-      typeof window !== 'undefined' &&
-      window != null &&
-      window.addEventListener != null
-    ) {
+    // (typeof window !== 'undefined') check is for environments where window is not defined, such as nextjs environment,
+    // and thus (window === undefined) will result in ReferenceError.
+    if (typeof window !== 'undefined' && window?.removeEventListener) {
       window.removeEventListener('offline', this.onlineStatusChanged);
       window.removeEventListener('online', this.onlineStatusChanged);
     }
@@ -796,7 +825,6 @@ export class StableWSConnection<
         {
           type: 'health.check',
           client_id: this.clientID,
-          user_id: this.userID,
         },
       ];
       // try to send on the connection

package/src/index.ts

@@ -8,5 +8,6 @@ export * from './events';
 export * from './permissions';
 export * from './signing';
 export * from './token_manager';
+export * from './insights';
 export * from './types';
 export { isOwnUser, chatCodes, logChatPromiseExecution } from './utils';

package/src/insights.ts

@@ -0,0 +1,68 @@
+import { StableWSConnection } from './connection';
+import WebSocket from 'isomorphic-ws';
+import { LiteralStringForUnion, UnknownType } from './types';
+
+export type InsightTypes = 'ws_fatal' | 'ws_success_after_failure';
+export class InsightMetrics {
+  connectionStartTimestamp: number | null;
+  wsConsecutiveFailures: number;
+  wsTotalFailures: number;
+
+  constructor() {
+    this.connectionStartTimestamp = null;
+    this.wsTotalFailures = 0;
+    this.wsConsecutiveFailures = 0;
+  }
+}
+
+export function buildWsFatalInsight<
+  ChannelType extends UnknownType = UnknownType,
+  CommandType extends string = LiteralStringForUnion,
+  UserType extends UnknownType = UnknownType
+>(
+  connection: StableWSConnection<ChannelType, CommandType, UserType>,
+  event: WebSocket.CloseEvent,
+) {
+  return {
+    err: {
+      wasClean: event.wasClean,
+      code: event.code,
+      reason: event.reason,
+    },
+    ...buildWsBaseInsight(connection),
+  };
+}
+
+function buildWsBaseInsight<
+  ChannelType extends UnknownType = UnknownType,
+  CommandType extends string = LiteralStringForUnion,
+  UserType extends UnknownType = UnknownType
+>(connection: StableWSConnection<ChannelType, CommandType, UserType>) {
+  return {
+    ready_state: connection.ws?.readyState,
+    url: connection._buildUrl(connection.requestID),
+    api_key: connection.apiKey,
+    start_ts: connection.insightMetrics.connectionStartTimestamp,
+    end_ts: new Date().getTime(),
+    auth_type: connection.authType,
+    token: connection.tokenManager.token,
+    user_id: connection.userID,
+    user_details: connection.user,
+    device: connection.device,
+    client_id: connection.connectionID,
+    ws_details: connection.ws,
+    ws_consecutive_failures: connection.insightMetrics.wsConsecutiveFailures,
+    ws_total_failures: connection.insightMetrics.wsTotalFailures,
+    request_id: connection.requestID,
+    online: typeof navigator !== 'undefined' ? navigator?.onLine : null,
+    user_agent: typeof navigator !== 'undefined' ? navigator?.userAgent : null,
+  };
+}
+
+export function buildWsSuccessAfterFailureInsight<
+  ChannelType extends UnknownType = UnknownType,
+  CommandType extends string = LiteralStringForUnion,
+  UserType extends UnknownType = UnknownType
+>(connection: StableWSConnection<ChannelType, CommandType, UserType>) {
+  return buildWsBaseInsight(connection);
+}