stream-chat 4.4.3-dev.0 → 4.4.3

package/src/client.ts

@@ -118,7 +118,7 @@ import {
   DeleteChannelsResponse,
   TaskResponse,
 } from './types';
-import { InsightTypes, InsightMetrics } from './insights';
+import { InsightMetrics, postInsights } from './insights';
 
 function isString(x: unknown): x is string {
   return typeof x === 'string' || x instanceof String;
@@ -269,7 +269,7 @@ export class StreamChat<
 
     this.axiosInstance = axios.create(this.options);
 
-    this.setBaseURL(this.options.baseURL || 'https://chat-us-east-1.stream-io-api.com');
+    this.setBaseURL(this.options.baseURL || 'https://chat.stream-io-api.com');
 
     if (typeof process !== 'undefined' && process.env.STREAM_LOCAL_TEST_RUN) {
       this.setBaseURL('http://localhost:3030');
@@ -1140,6 +1140,7 @@ export class StreamChat<
       this.consecutiveFailures = 0;
       return this.handleResponse(response);
     } catch (e) {
+      e.client_request_id = requestConfig.headers?.['x-client-request-id'];
       this._logApiError(type, url, e);
       this.consecutiveFailures += 1;
       if (e.response) {
@@ -1619,10 +1620,14 @@ export class StreamChat<
       throw Error('clientID is not set');
     }
 
-    // The StableWSConnection handles all the reconnection logic.
+    if (!this.wsConnection && (this.options.warmUp || this.options.enableInsights)) {
+      this._sayHi();
+    }
 
+    // The StableWSConnection handles all the reconnection logic.
     this.wsConnection = new StableWSConnection<ChannelType, CommandType, UserType>({
       wsBaseURL: client.wsBaseURL,
+      enableInsights: this.options.enableInsights,
       clientID: client.clientID,
       userID: client.userID,
       tokenManager: client.tokenManager,
@@ -1635,24 +1640,29 @@ 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;
-    if (this.options.warmUp) {
-      warmUpPromise = this.doAxiosRequest('options', this.baseURL + '/connect');
-    }
-    const handshake = await this.wsConnection.connect();
-    try {
-      await warmUpPromise;
-    } catch (e) {
-      this.logger('error', 'Warmup request failed', {
-        error: e,
-      });
-    }
+    return await this.wsConnection.connect();
+  }
 
-    return handshake;
+  /**
+   * Check the connectivity with server for warmup purpose.
+   *
+   * @private
+   */
+  _sayHi() {
+    const client_request_id = randomId();
+    const opts = { headers: { 'x-client-request-id': client_request_id } };
+    this.doAxiosRequest('get', this.baseURL + '/hi', null, opts).catch((e) => {
+      if (this.options.enableInsights) {
+        postInsights('http_hi_failed', {
+          api_key: this.key,
+          err: e,
+          client_request_id,
+        });
+      }
+    });
   }
 
   /**
@@ -2912,6 +2922,13 @@ export class StreamChat<
   ) {
     const token = this._getToken();
 
+    if (!options.headers?.['x-client-request-id']) {
+      options.headers = {
+        ...options.headers,
+        'x-client-request-id': randomId(),
+      };
+    }
+
     return {
       params: {
         user_id: this.userID,
@@ -3349,27 +3366,6 @@ export class StreamChat<
     );
   }
 
-  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
    *

package/src/connection.ts

@@ -5,7 +5,7 @@ import {
   buildWsFatalInsight,
   buildWsSuccessAfterFailureInsight,
   InsightMetrics,
-  InsightTypes,
+  postInsights,
 } from './insights';
 import {
   BaseDeviceFields,
@@ -48,7 +48,7 @@ type Constructor<
   userID: string;
   wsBaseURL: string;
   device?: BaseDeviceFields;
-  postInsights?: (eventType: InsightTypes, event: Record<string, unknown>) => void;
+  enableInsights?: boolean;
 };
 
 /**
@@ -110,7 +110,7 @@ export class StableWSConnection<
   totalFailures: number;
   ws?: WebSocket;
   wsID: number;
-  postInsights?: Constructor<ChannelType, CommandType, UserType>['postInsights'];
+  enableInsights?: boolean;
   insightMetrics: InsightMetrics;
   constructor({
     apiKey,
@@ -126,7 +126,7 @@ export class StableWSConnection<
     userID,
     wsBaseURL,
     device,
-    postInsights,
+    enableInsights,
     insightMetrics,
   }: Constructor<ChannelType, CommandType, UserType>) {
     this.wsBaseURL = wsBaseURL;
@@ -161,7 +161,7 @@ export class StableWSConnection<
     this.pingInterval = 25 * 1000;
     this.connectionCheckTimeout = this.pingInterval + 10 * 1000;
     this._listenForConnectionChanges();
-    this.postInsights = postInsights;
+    this.enableInsights = enableInsights;
     this.insightMetrics = insightMetrics;
   }
 
@@ -270,7 +270,7 @@ export class StableWSConnection<
       user_token: this.tokenManager.getToken(),
       server_determines_connection_id: true,
       device: this.device,
-      request_id: reqID,
+      client_request_id: reqID,
     };
     const qs = encodeURIComponent(JSON.stringify(params));
     const token = this.tokenManager.getToken();
@@ -388,10 +388,10 @@ export class StableWSConnection<
 
       if (response) {
         this.connectionID = response.connection_id;
-        if (this.insightMetrics.wsConsecutiveFailures > 0 && this.postInsights) {
-          this.postInsights(
+        if (this.insightMetrics.wsConsecutiveFailures > 0 && this.enableInsights) {
+          postInsights(
             'ws_success_after_failure',
-            buildWsSuccessAfterFailureInsight(this),
+            buildWsSuccessAfterFailureInsight((this as unknown) as StableWSConnection),
           );
           this.insightMetrics.wsConsecutiveFailures = 0;
         }
@@ -400,13 +400,15 @@ export class StableWSConnection<
     } catch (err) {
       this.isConnecting = false;
 
-      if (this.postInsights) {
+      if (this.enableInsights) {
         this.insightMetrics.wsConsecutiveFailures++;
         this.insightMetrics.wsTotalFailures++;
 
-        // @ts-ignore
-        const insights = buildWsFatalInsight(this, convertErrorToJson(err));
-        this.postInsights?.('ws_fatal', insights);
+        const insights = buildWsFatalInsight(
+          (this as unknown) as StableWSConnection,
+          convertErrorToJson(err as Error),
+        );
+        postInsights?.('ws_fatal', insights);
       }
       throw err;
     }

package/src/insights.ts

@@ -1,8 +1,8 @@
+import axios from 'axios';
 import { StableWSConnection } from './connection';
-import { LiteralStringForUnion, UnknownType } from './types';
-import { randomId } from './utils';
+import { randomId, sleep } from './utils';
 
-export type InsightTypes = 'ws_fatal' | 'ws_success_after_failure';
+export type InsightTypes = 'ws_fatal' | 'ws_success_after_failure' | 'http_hi_failed';
 export class InsightMetrics {
   connectionStartTimestamp: number | null;
   wsConsecutiveFailures: number;
@@ -17,12 +17,34 @@ export class InsightMetrics {
   }
 }
 
-export function buildWsFatalInsight<
-  ChannelType extends UnknownType = UnknownType,
-  CommandType extends string = LiteralStringForUnion,
-  UserType extends UnknownType = UnknownType
->(
-  connection: StableWSConnection<ChannelType, CommandType, UserType>,
+/**
+ * postInsights is not supposed to be used by end users directly within chat application, and thus is kept isolated
+ * from all the client/connection code/logic.
+ *
+ * @param insightType
+ * @param insights
+ */
+export const postInsights = async (
+  insightType: InsightTypes,
+  insights: Record<string, unknown>,
+) => {
+  const maxAttempts = 3;
+  for (let i = 0; i < maxAttempts; i++) {
+    try {
+      await axios.post(
+        `https://chat-insights.getstream.io/insights/${insightType}`,
+        insights,
+      );
+    } catch (e) {
+      await sleep((i + 1) * 3000);
+      continue;
+    }
+    break;
+  }
+};
+
+export function buildWsFatalInsight(
+  connection: StableWSConnection,
   event: Record<string, unknown>,
 ) {
   return {
@@ -31,11 +53,7 @@ export function buildWsFatalInsight<
   };
 }
 
-function buildWsBaseInsight<
-  ChannelType extends UnknownType = UnknownType,
-  CommandType extends string = LiteralStringForUnion,
-  UserType extends UnknownType = UnknownType
->(connection: StableWSConnection<ChannelType, CommandType, UserType>) {
+function buildWsBaseInsight(connection: StableWSConnection) {
   return {
     ready_state: connection.ws?.readyState,
     url: connection._buildUrl(connection.requestID),
@@ -58,10 +76,6 @@ function buildWsBaseInsight<
   };
 }
 
-export function buildWsSuccessAfterFailureInsight<
-  ChannelType extends UnknownType = UnknownType,
-  CommandType extends string = LiteralStringForUnion,
-  UserType extends UnknownType = UnknownType
->(connection: StableWSConnection<ChannelType, CommandType, UserType>) {
+export function buildWsSuccessAfterFailureInsight(connection: StableWSConnection) {
   return buildWsBaseInsight(connection);
 }

package/src/types.ts

@@ -2163,11 +2163,13 @@ export type DeleteType = 'soft' | 'hard';
   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
  */
 export type DeleteUserOptions = {
   user: DeleteType;
   conversations?: DeleteType;
   messages?: DeleteType;
+  new_channel_owner_id?: string;
 };
 
 export type SegmentData = {

package/src/utils.ts

@@ -199,15 +199,20 @@ function getRandomBytes(length: number): Uint8Array {
   return bytes;
 }
 
-export function convertErrorToJson(err: unknown) {
+export function convertErrorToJson(err: Error) {
   const jsonObj = {} as Record<string, unknown>;
 
   if (!err) return jsonObj;
 
-  Object.getOwnPropertyNames(err).forEach((key) => {
-    // @ts-ignore
-    jsonObj[key] = err[key];
-  });
+  try {
+    Object.getOwnPropertyNames(err).forEach((key) => {
+      jsonObj[key] = Object.getOwnPropertyDescriptor(err, key);
+    });
+  } catch (_) {
+    return {
+      error: 'failed to serialize the error',
+    };
+  }
 
   return jsonObj;
 }