stream-chat 4.4.3-dev.2 → 5.0.0

package/src/connection_fallback.ts

@@ -0,0 +1,205 @@
+import axios, { AxiosRequestConfig, CancelTokenSource } from 'axios';
+import { StreamChat } from './client';
+import { addConnectionEventListeners, removeConnectionEventListeners, retryInterval, sleep } from './utils';
+import { isAPIError, isConnectionIDError, isErrorRetryable } from './errors';
+import { ConnectionOpen, Event, UnknownType, UR, LiteralStringForUnion, LogLevel } from './types';
+
+export enum ConnectionState {
+  Closed = 'CLOSED',
+  Connected = 'CONNECTED',
+  Connecting = 'CONNECTING',
+  Disconnected = 'DISCONNECTED',
+  Init = 'INIT',
+}
+
+export class WSConnectionFallback<
+  AttachmentType extends UR = UR,
+  ChannelType extends UR = UR,
+  CommandType extends string = LiteralStringForUnion,
+  EventType extends UR = UR,
+  MessageType extends UR = UR,
+  ReactionType extends UR = UR,
+  UserType extends UR = UR
+> {
+  client: StreamChat<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>;
+  state: ConnectionState;
+  consecutiveFailures: number;
+  connectionID?: string;
+  cancelToken?: CancelTokenSource;
+
+  constructor({
+    client,
+  }: {
+    client: StreamChat<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>;
+  }) {
+    this.client = client;
+    this.state = ConnectionState.Init;
+    this.consecutiveFailures = 0;
+
+    addConnectionEventListeners(this._onlineStatusChanged);
+  }
+
+  _log(msg: string, extra: UR = {}, level: LogLevel = 'info') {
+    this.client.logger(level, 'WSConnectionFallback:' + msg, { tags: ['connection_fallback', 'connection'], ...extra });
+  }
+
+  _setState(state: ConnectionState) {
+    this._log(`_setState() - ${state}`);
+
+    // transition from connecting => connected
+    if (this.state === ConnectionState.Connecting && state === ConnectionState.Connected) {
+      //@ts-expect-error
+      this.client.dispatchEvent({ type: 'connection.changed', online: true });
+    }
+
+    if (state === ConnectionState.Closed || state === ConnectionState.Disconnected) {
+      //@ts-expect-error
+      this.client.dispatchEvent({ type: 'connection.changed', online: false });
+    }
+
+    this.state = state;
+  }
+
+  /** @private */
+  _onlineStatusChanged = (event: { type: string }) => {
+    this._log(`_onlineStatusChanged() - ${event.type}`);
+
+    if (event.type === 'offline') {
+      this._setState(ConnectionState.Closed);
+      this.cancelToken?.cancel('disconnect() is called');
+      this.cancelToken = undefined;
+      return;
+    }
+
+    if (event.type === 'online' && this.state === ConnectionState.Closed) {
+      this.connect(true);
+    }
+  };
+
+  /** @private */
+  _req = async <T = UR>(params: UnknownType, config: AxiosRequestConfig, retry: boolean): Promise<T> => {
+    if (!this.cancelToken && !params.close) {
+      this.cancelToken = axios.CancelToken.source();
+    }
+
+    try {
+      const res = await this.client.doAxiosRequest<T>(
+        'get',
+        (this.client.baseURL as string).replace(':3030', ':8900') + '/longpoll', // replace port if present for testing with local API
+        undefined,
+        {
+          config: { ...config, cancelToken: this.cancelToken?.token },
+          params,
+        },
+      );
+
+      this.consecutiveFailures = 0; // always reset in case of no error
+      return res;
+    } catch (err) {
+      this.consecutiveFailures += 1;
+
+      if (retry && isErrorRetryable(err)) {
+        this._log(`_req() - Retryable error, retrying request`);
+        await sleep(retryInterval(this.consecutiveFailures));
+        return this._req<T>(params, config, retry);
+      }
+
+      throw err;
+    }
+  };
+
+  /** @private */
+  _poll = async () => {
+    while (this.state === ConnectionState.Connected) {
+      try {
+        const data = await this._req<{
+          events: Event<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>[];
+        }>({}, { timeout: 30000 }, true); // 30s => API responds in 20s if there is no event
+
+        if (data.events?.length) {
+          for (let i = 0; i < data.events.length; i++) {
+            this.client.dispatchEvent(data.events[i]);
+          }
+        }
+      } catch (err) {
+        if (axios.isCancel(err)) {
+          this._log(`_poll() - axios canceled request`);
+          return;
+        }
+
+        /** client.doAxiosRequest will take care of TOKEN_EXPIRED error */
+
+        if (isConnectionIDError(err)) {
+          this._log(`_poll() - ConnectionID error, connecting without ID...`);
+          this._setState(ConnectionState.Disconnected);
+          this.connect(true);
+          return;
+        }
+
+        if (isAPIError(err) && !isErrorRetryable(err)) {
+          this._setState(ConnectionState.Closed);
+          return;
+        }
+
+        await sleep(retryInterval(this.consecutiveFailures));
+      }
+    }
+  };
+
+  /**
+   * connect try to open a longpoll request
+   * @param reconnect should be false for first call and true for subsequent calls to keep the connection alive and call recoverState
+   */
+  connect = async (reconnect = false) => {
+    if (this.state === ConnectionState.Connecting) {
+      throw new Error('connecting already in progress');
+    }
+    if (this.state === ConnectionState.Connected) {
+      throw new Error('already connected and polling');
+    }
+
+    this._setState(ConnectionState.Connecting);
+    this.connectionID = undefined; // connect should be sent with empty connection_id so API creates one
+    try {
+      const { event } = await this._req<{ event: ConnectionOpen<ChannelType, CommandType, UserType> }>(
+        { json: this.client._buildWSPayload() },
+        { timeout: 8000 }, // 8s
+        reconnect,
+      );
+
+      this._setState(ConnectionState.Connected);
+      this.connectionID = event.connection_id;
+      this._poll();
+      if (reconnect) {
+        this.client.recoverState();
+      }
+      return event;
+    } catch (err) {
+      this._setState(ConnectionState.Closed);
+      throw err;
+    }
+  };
+
+  /**
+   * isHealthy checks if there is a connectionID and connection is in Connected state
+   */
+  isHealthy = () => {
+    return this.connectionID && this.state === ConnectionState.Connected;
+  };
+
+  disconnect = async (timeout = 2000) => {
+    removeConnectionEventListeners(this._onlineStatusChanged);
+
+    this._setState(ConnectionState.Disconnected);
+    this.cancelToken?.cancel('disconnect() is called');
+    this.cancelToken = undefined;
+
+    try {
+      await this._req({ close: true }, { timeout }, false);
+      this.connectionID = undefined;
+      this._log(`disconnect() - Closed connectionID`);
+    } catch (err) {
+      this._log(`disconnect() - Failed`, { err }, 'error');
+    }
+  };
+}

package/src/errors.ts

@@ -0,0 +1,58 @@
+export const APIErrorCodes: Record<string, { name: string; retryable: boolean }> = {
+  '-1': { name: 'InternalSystemError', retryable: true },
+  '2': { name: 'AccessKeyError', retryable: false },
+  '3': { name: 'AuthenticationFailedError', retryable: true },
+  '4': { name: 'InputError', retryable: false },
+  '6': { name: 'DuplicateUsernameError', retryable: false },
+  '9': { name: 'RateLimitError', retryable: true },
+  '16': { name: 'DoesNotExistError', retryable: false },
+  '17': { name: 'NotAllowedError', retryable: false },
+  '18': { name: 'EventNotSupportedError', retryable: false },
+  '19': { name: 'ChannelFeatureNotSupportedError', retryable: false },
+  '20': { name: 'MessageTooLongError', retryable: false },
+  '21': { name: 'MultipleNestingLevelError', retryable: false },
+  '22': { name: 'PayloadTooBigError', retryable: false },
+  '23': { name: 'RequestTimeoutError', retryable: true },
+  '24': { name: 'MaxHeaderSizeExceededError', retryable: false },
+  '40': { name: 'AuthErrorTokenExpired', retryable: false },
+  '41': { name: 'AuthErrorTokenNotValidYet', retryable: false },
+  '42': { name: 'AuthErrorTokenUsedBeforeIssuedAt', retryable: false },
+  '43': { name: 'AuthErrorTokenSignatureInvalid', retryable: false },
+  '44': { name: 'CustomCommandEndpointMissingError', retryable: false },
+  '45': { name: 'CustomCommandEndpointCallError', retryable: true },
+  '46': { name: 'ConnectionIDNotFoundError', retryable: false },
+  '60': { name: 'CoolDownError', retryable: true },
+  '69': { name: 'ErrWrongRegion', retryable: false },
+  '70': { name: 'ErrQueryChannelPermissions', retryable: false },
+  '71': { name: 'ErrTooManyConnections', retryable: true },
+  '99': { name: 'AppSuspendedError', retryable: false },
+};
+
+type APIError = Error & { code: number; isWSFailure?: boolean };
+
+export function isAPIError(error: Error): error is APIError {
+  return (error as APIError).code !== undefined;
+}
+
+export function isErrorRetryable(error: APIError) {
+  if (!error.code) return false;
+  const err = APIErrorCodes[`${error.code}`];
+  if (!err) return false;
+  return err.retryable;
+}
+
+export function isConnectionIDError(error: APIError) {
+  return error.code === 46; // ConnectionIDNotFoundError
+}
+
+export function isWSFailure(err: APIError): boolean {
+  if (typeof err.isWSFailure === 'boolean') {
+    return err.isWSFailure;
+  }
+
+  try {
+    return JSON.parse(err.message).isWSFailure;
+  } catch (_) {
+    return false;
+  }
+}

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' | 'http_beacon_failed';
+export type InsightTypes = 'ws_fatal' | 'ws_success_after_failure' | 'http_hi_failed';
 export class InsightMetrics {
   connectionStartTimestamp: number | null;
   wsConsecutiveFailures: number;
@@ -17,51 +17,57 @@ export class InsightMetrics {
   }
 }
 
-export function buildWsFatalInsight<
-  ChannelType extends UnknownType = UnknownType,
-  CommandType extends string = LiteralStringForUnion,
-  UserType extends UnknownType = UnknownType
->(
-  connection: StableWSConnection<ChannelType, CommandType, UserType>,
-  event: Record<string, unknown>,
-) {
+/**
+ * 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 {
     ...event,
     ...buildWsBaseInsight(connection),
   };
 }
 
-function buildWsBaseInsight<
-  ChannelType extends UnknownType = UnknownType,
-  CommandType extends string = LiteralStringForUnion,
-  UserType extends UnknownType = UnknownType
->(connection: StableWSConnection<ChannelType, CommandType, UserType>) {
+function buildWsBaseInsight(connection: StableWSConnection) {
+  const { client } = connection;
   return {
     ready_state: connection.ws?.readyState,
-    url: connection._buildUrl(connection.requestID),
-    api_key: connection.apiKey,
-    start_ts: connection.insightMetrics.connectionStartTimestamp,
+    url: connection._buildUrl(),
+    api_key: client.key,
+    start_ts: client.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,
+    auth_type: client.getAuthType(),
+    token: client.tokenManager.token,
+    user_id: client.userID,
+    user_details: client._user,
+    device: client.options.device,
     client_id: connection.connectionID,
     ws_details: connection.ws,
-    ws_consecutive_failures: connection.insightMetrics.wsConsecutiveFailures,
-    ws_total_failures: connection.insightMetrics.wsTotalFailures,
+    ws_consecutive_failures: client.insightMetrics.wsConsecutiveFailures,
+    ws_total_failures: client.insightMetrics.wsTotalFailures,
     request_id: connection.requestID,
     online: typeof navigator !== 'undefined' ? navigator?.onLine : null,
     user_agent: typeof navigator !== 'undefined' ? navigator?.userAgent : null,
-    instance_client_id: connection.insightMetrics.instanceClientId,
+    instance_client_id: client.insightMetrics.instanceClientId,
   };
 }
 
-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/permissions.ts

@@ -37,33 +37,12 @@ export class Permission {
 }
 
 // deprecated
-export const AllowAll = new Permission(
-  'Allow all',
-  MaxPriority,
-  AnyResource,
-  AnyRole,
-  false,
-  Allow,
-);
+export const AllowAll = new Permission('Allow all', MaxPriority, AnyResource, AnyRole, false, Allow);
 
 // deprecated
-export const DenyAll = new Permission(
-  'Deny all',
-  MinPriority,
-  AnyResource,
-  AnyRole,
-  false,
-  Deny,
-);
+export const DenyAll = new Permission('Deny all', MinPriority, AnyResource, AnyRole, false, Deny);
 
-export type Role =
-  | 'admin'
-  | 'user'
-  | 'guest'
-  | 'anonymous'
-  | 'channel_member'
-  | 'channel_moderator'
-  | string;
+export type Role = 'admin' | 'user' | 'guest' | 'anonymous' | 'channel_member' | 'channel_moderator' | string;
 
 export const BuiltinRoles = {
   Admin: 'admin',

package/src/signing.ts

@@ -1,7 +1,7 @@
 import jwt, { Secret, SignOptions } from 'jsonwebtoken';
 import crypto from 'crypto';
 import { encodeBase64, decodeBase64 } from './base64';
-import { UnknownType } from './types';
+import { UR } from './types';
 
 /**
  * Creates the JWT token that can be used for a UserSession
@@ -10,21 +10,16 @@ import { UnknownType } from './types';
  * @private
  * @param {Secret} apiSecret - API Secret key
  * @param {string} userId - The user_id key in the JWT payload
- * @param {UnknownType} [extraData] - Extra that should be part of the JWT token
+ * @param {UR} [extraData] - Extra that should be part of the JWT token
  * @param {SignOptions} [jwtOptions] - Options that can be past to jwt.sign
  * @return {string} JWT Token
  */
-export function JWTUserToken(
-  apiSecret: Secret,
-  userId: string,
-  extraData: UnknownType = {},
-  jwtOptions: SignOptions = {},
-) {
+export function JWTUserToken(apiSecret: Secret, userId: string, extraData: UR = {}, jwtOptions: SignOptions = {}) {
   if (typeof userId !== 'string') {
     throw new TypeError('userId should be a string');
   }
 
-  const payload: { user_id: string } & UnknownType = {
+  const payload: { user_id: string } & UR = {
     user_id: userId,
     ...extraData,
   };
@@ -36,10 +31,7 @@ export function JWTUserToken(
     );
   }
 
-  const opts: SignOptions = Object.assign(
-    { algorithm: 'HS256', noTimestamp: true },
-    jwtOptions,
-  );
+  const opts: SignOptions = Object.assign({ algorithm: 'HS256', noTimestamp: true }, jwtOptions);
 
   if (payload.iat) {
     opts.noTimestamp = false;
@@ -52,10 +44,7 @@ export function JWTServerToken(apiSecret: Secret, jwtOptions: SignOptions = {})
     server: true,
   };
 
-  const opts: SignOptions = Object.assign(
-    { algorithm: 'HS256', noTimestamp: true },
-    jwtOptions,
-  );
+  const opts: SignOptions = Object.assign({ algorithm: 'HS256', noTimestamp: true }, jwtOptions);
   return jwt.sign(payload, apiSecret, opts);
 }
 

package/src/token_manager.ts

@@ -1,14 +1,14 @@
 import { Secret } from 'jsonwebtoken';
 import { UserFromToken, JWTServerToken, JWTUserToken } from './signing';
 import { isFunction } from './utils';
-import { TokenOrProvider, UnknownType, UserResponse } from './types';
+import { TokenOrProvider, UR, UserResponse } from './types';
 
 /**
  * TokenManager
  *
  * Handles all the operations around user token.
  */
-export class TokenManager<UserType extends UnknownType = UnknownType> {
+export class TokenManager<UserType extends UR = UR> {
   loadTokenPromise: Promise<string> | null;
   type: 'static' | 'provider';
   secret?: Secret;
@@ -40,10 +40,7 @@ export class TokenManager<UserType extends UnknownType = UnknownType> {
    * @param {TokenOrProvider} tokenOrProvider
    * @param {UserResponse<UserType>} user
    */
-  setTokenOrProvider = async (
-    tokenOrProvider: TokenOrProvider,
-    user: UserResponse<UserType>,
-  ) => {
+  setTokenOrProvider = async (tokenOrProvider: TokenOrProvider, user: UserResponse<UserType>) => {
     this.validateToken(tokenOrProvider, user);
     this.user = user;
 
@@ -85,11 +82,7 @@ export class TokenManager<UserType extends UnknownType = UnknownType> {
       throw new Error('User token can not be empty');
     }
 
-    if (
-      tokenOrProvider &&
-      typeof tokenOrProvider !== 'string' &&
-      !isFunction(tokenOrProvider)
-    ) {
+    if (tokenOrProvider && typeof tokenOrProvider !== 'string' && !isFunction(tokenOrProvider)) {
       throw new Error('user token should either be a string or a function');
     }
 
@@ -98,13 +91,8 @@ export class TokenManager<UserType extends UnknownType = UnknownType> {
       if (user.anon && tokenOrProvider === '') return;
 
       const tokenUserId = UserFromToken(tokenOrProvider);
-      if (
-        tokenOrProvider != null &&
-        (tokenUserId == null || tokenUserId === '' || tokenUserId !== user.id)
-      ) {
-        throw new Error(
-          'userToken does not have a user_id or is not matching with user.id',
-        );
+      if (tokenOrProvider != null && (tokenUserId == null || tokenUserId === '' || tokenUserId !== user.id)) {
+        throw new Error('userToken does not have a user_id or is not matching with user.id');
       }
     }
   };