@stream-io/video-client 0.0.1-alpha.7

package/src/coordinator/connection/connection_fallback.ts

@@ -0,0 +1,239 @@
+import axios, { AxiosRequestConfig, CancelTokenSource } from 'axios';
+import { StreamClient } from './client';
+import {
+  addConnectionEventListeners,
+  removeConnectionEventListeners,
+  retryInterval,
+  sleep,
+} from './utils';
+import { isAPIError, isConnectionIDError, isErrorRetryable } from './errors';
+import { ConnectionOpen, Event, UR, LogLevel } from './types';
+
+export enum ConnectionState {
+  Closed = 'CLOSED',
+  Connected = 'CONNECTED',
+  Connecting = 'CONNECTING',
+  Disconnected = 'DISCONNECTED',
+  Init = 'INIT',
+}
+
+export class WSConnectionFallback {
+  client: StreamClient;
+  state: ConnectionState;
+  consecutiveFailures: number;
+  connectionID?: string;
+  cancelToken?: CancelTokenSource;
+
+  constructor(client: StreamClient) {
+    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
+    ) {
+      this.client.dispatchEvent({ type: 'connection.changed', online: true });
+    }
+
+    if (
+      state === ConnectionState.Closed ||
+      state === ConnectionState.Disconnected
+    ) {
+      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: UR,
+    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;
+
+      // @ts-ignore
+      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[];
+        }>(
+          {},
+          {
+            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 */
+
+        // @ts-ignore
+        if (isConnectionIDError(err)) {
+          this._log(`_poll() - ConnectionID error, connecting without ID...`);
+          this._setState(ConnectionState.Disconnected);
+          this.connect(true);
+          return;
+        }
+
+        // @ts-ignore
+        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) {
+      this._log(
+        'connect() - connecting already in progress',
+        { reconnect },
+        'warn',
+      );
+      return;
+    }
+    if (this.state === ConnectionState.Connected) {
+      this._log(
+        'connect() - already connected and polling',
+        { reconnect },
+        'warn',
+      );
+      return;
+    }
+
+    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;
+      }>(
+        { json: this.client._buildWSPayload() },
+        {
+          timeout: 8000, // 8s
+        },
+        reconnect,
+      );
+
+      this._setState(ConnectionState.Connected);
+      this.connectionID = event.connection_id;
+      // @ts-expect-error
+      this.client.dispatchEvent(event);
+      this._poll();
+      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;
+
+    const connection_id = this.connectionID;
+    this.connectionID = undefined;
+
+    try {
+      await this._req(
+        { close: true, connection_id },
+        {
+          timeout,
+        },
+        false,
+      );
+      this._log(`disconnect() - Closed connectionID`);
+    } catch (err) {
+      this._log(`disconnect() - Failed`, { err }, 'error');
+    }
+  };
+}

package/src/coordinator/connection/errors.ts

@@ -0,0 +1,70 @@
+import { AxiosResponse } from 'axios';
+import { APIErrorResponse } from './types';
+
+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;
+  }
+}
+
+export function isErrorResponse(
+  res: AxiosResponse<unknown>,
+): res is AxiosResponse<APIErrorResponse> {
+  return !res.status || res.status < 200 || 300 <= res.status;
+}

package/src/coordinator/connection/events.ts

@@ -0,0 +1,10 @@
+export const EVENT_MAP = {
+  'health.check': true,
+
+  'call.created': true,
+
+  // local events
+  'connection.changed': true,
+  'connection.recovered': true,
+  'transport.changed': true,
+};

package/src/coordinator/connection/insights.ts

@@ -0,0 +1,88 @@
+import axios from 'axios';
+import { StableWSConnection } from './connection';
+import { randomId, sleep } from './utils';
+
+export type InsightTypes =
+  | 'ws_fatal'
+  | 'ws_success_after_failure'
+  | 'http_hi_failed';
+export class InsightMetrics {
+  connectionStartTimestamp: number | null;
+  wsConsecutiveFailures: number;
+  wsTotalFailures: number;
+  instanceClientId: string;
+
+  constructor() {
+    this.connectionStartTimestamp = null;
+    this.wsTotalFailures = 0;
+    this.wsConsecutiveFailures = 0;
+    this.instanceClientId = randomId();
+  }
+}
+
+/**
+ * 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(connection: StableWSConnection) {
+  const { client } = connection;
+  return {
+    ready_state: connection.ws?.readyState,
+    url: connection._buildUrl(),
+    api_key: client.key,
+    start_ts: client.insightMetrics.connectionStartTimestamp,
+    end_ts: new Date().getTime(),
+    auth_type: client.getAuthType(),
+    token: client.tokenManager.token,
+    user_id: client.userID,
+    user_details: client._user,
+    // device: client.options.device,
+    device: 'browser',
+    client_id: connection.connectionID,
+    ws_details: connection.ws,
+    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: client.insightMetrics.instanceClientId,
+  };
+}
+
+export function buildWsSuccessAfterFailureInsight(
+  connection: StableWSConnection,
+) {
+  return buildWsBaseInsight(connection);
+}

package/src/coordinator/connection/signing.ts

@@ -0,0 +1,104 @@
+import jwt, { Secret, SignOptions } from 'jsonwebtoken';
+import crypto from 'crypto';
+import { encodeBase64, decodeBase64 } from './base64';
+import { UR } from './types';
+
+/**
+ * Creates the JWT token that can be used for a UserSession
+ * @method JWTUserToken
+ * @memberof signing
+ * @private
+ * @param {Secret} apiSecret - API Secret key
+ * @param {string} userId - The user_id key in the JWT payload
+ * @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: UR = {},
+  jwtOptions: SignOptions = {},
+) {
+  if (typeof userId !== 'string') {
+    throw new TypeError('userId should be a string');
+  }
+
+  const payload: { user_id: string } & UR = {
+    user_id: userId,
+    ...extraData,
+  };
+
+  // make sure we return a clear error when jwt is shimmed (ie. browser build)
+  if (jwt == null || jwt.sign == null) {
+    throw Error(
+      `Unable to find jwt crypto, if you are getting this error is probably because you are trying to generate tokens on browser or React Native (or other environment where crypto functions are not available). Please Note: token should only be generated server-side.`,
+    );
+  }
+
+  const opts: SignOptions = Object.assign(
+    { algorithm: 'HS256', noTimestamp: true },
+    jwtOptions,
+  );
+
+  if (payload.iat) {
+    opts.noTimestamp = false;
+  }
+  return jwt.sign(payload, apiSecret, opts);
+}
+
+export function JWTServerToken(
+  apiSecret: Secret,
+  jwtOptions: SignOptions = {},
+) {
+  const payload = {
+    server: true,
+  };
+
+  const opts: SignOptions = Object.assign(
+    { algorithm: 'HS256', noTimestamp: true },
+    jwtOptions,
+  );
+  return jwt.sign(payload, apiSecret, opts);
+}
+
+export function UserFromToken(token: string) {
+  const fragments = token.split('.');
+  if (fragments.length !== 3) {
+    return '';
+  }
+  const b64Payload = fragments[1];
+  const payload = decodeBase64(b64Payload);
+  const data = JSON.parse(payload);
+  return data.user_id as string;
+}
+
+/**
+ *
+ * @param {string} userId the id of the user
+ * @return {string}
+ */
+export function DevToken(userId: string) {
+  return [
+    'eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9', //{"alg": "HS256", "typ": "JWT"}
+    encodeBase64(JSON.stringify({ user_id: userId })),
+    'devtoken', // hardcoded signature
+  ].join('.');
+}
+
+/**
+ *
+ * @param {string} body the signed message
+ * @param {string} secret the shared secret used to generate the signature (Stream API secret)
+ * @param {string} signature the signature to validate
+ * @return {boolean}
+ */
+export function CheckSignature(
+  body: string,
+  secret: string,
+  signature: string,
+) {
+  const key = Buffer.from(secret, 'ascii');
+  const hash = crypto.createHmac('sha256', key).update(body).digest('hex');
+  return hash === signature;
+}

package/src/coordinator/connection/token_manager.ts

@@ -0,0 +1,160 @@
+import { Secret } from 'jsonwebtoken';
+import { UserFromToken, JWTServerToken, JWTUserToken } from './signing';
+import { isFunction } from './utils';
+import { TokenOrProvider, UserResponse } from './types';
+
+/**
+ * TokenManager
+ *
+ * Handles all the operations around user token.
+ */
+export class TokenManager {
+  loadTokenPromise: Promise<string> | null;
+  type: 'static' | 'provider';
+  secret?: Secret;
+  token?: string;
+  tokenProvider?: TokenOrProvider;
+  user?: UserResponse;
+  /**
+   * Constructor
+   *
+   * @param {Secret} secret
+   */
+  constructor(secret?: Secret) {
+    this.loadTokenPromise = null;
+    if (secret) {
+      this.secret = secret;
+    }
+
+    this.type = 'static';
+
+    if (this.secret) {
+      this.token = JWTServerToken(this.secret);
+    }
+  }
+
+  /**
+   * Set the static string token or token provider.
+   * Token provider should return a token string or a promise which resolves to string token.
+   *
+   * @param {TokenOrProvider} tokenOrProvider
+   * @param {UserResponse} user
+   */
+  setTokenOrProvider = async (
+    tokenOrProvider: TokenOrProvider,
+    user: UserResponse,
+  ) => {
+    this.validateToken(tokenOrProvider, user);
+    this.user = user;
+
+    if (isFunction(tokenOrProvider)) {
+      this.tokenProvider = tokenOrProvider;
+      this.type = 'provider';
+    }
+
+    if (typeof tokenOrProvider === 'string') {
+      this.token = tokenOrProvider;
+      this.type = 'static';
+    }
+
+    if (!tokenOrProvider && this.user && this.secret) {
+      this.token = JWTUserToken(this.secret, user.id, {}, {});
+      this.type = 'static';
+    }
+
+    await this.loadToken();
+  };
+
+  /**
+   * Resets the token manager.
+   * Useful for client disconnection or switching user.
+   */
+  reset = () => {
+    this.token = undefined;
+    this.user = undefined;
+    this.loadTokenPromise = null;
+  };
+
+  // Validates the user token.
+  validateToken = (tokenOrProvider: TokenOrProvider, user: UserResponse) => {
+    // allow empty token for anon user
+    if (user && user.anon && !tokenOrProvider) return;
+
+    // Don't allow empty token for non-server side client.
+    if (!this.secret && !tokenOrProvider) {
+      throw new Error('User token can not be empty');
+    }
+
+    if (
+      tokenOrProvider &&
+      typeof tokenOrProvider !== 'string' &&
+      !isFunction(tokenOrProvider)
+    ) {
+      throw new Error('user token should either be a string or a function');
+    }
+
+    if (typeof tokenOrProvider === 'string') {
+      // Allow empty token for anonymous users
+      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',
+        );
+      }
+    }
+  };
+
+  // Resolves when token is ready. This function is simply to check if loadToken is in progress, in which
+  // case a function should wait.
+  tokenReady = () => this.loadTokenPromise;
+
+  // Fetches a token from tokenProvider function and sets in tokenManager.
+  // In case of static token, it will simply resolve to static token.
+  loadToken = () => {
+    // eslint-disable-next-line no-async-promise-executor
+    this.loadTokenPromise = new Promise(async (resolve, reject) => {
+      if (this.type === 'static') {
+        return resolve(this.token as string);
+      }
+
+      if (this.tokenProvider && typeof this.tokenProvider !== 'string') {
+        try {
+          this.token = await this.tokenProvider();
+        } catch (e) {
+          return reject(
+            new Error(`Call to tokenProvider failed with message: ${e}`),
+          );
+        }
+        resolve(this.token);
+      }
+    });
+
+    return this.loadTokenPromise;
+  };
+
+  // Returns a current token
+  getToken = () => {
+    if (this.token) {
+      return this.token;
+    }
+
+    if (this.user && this.user.anon && !this.token) {
+      return this.token;
+    }
+
+    if (this.secret) {
+      return JWTServerToken(this.secret);
+    }
+
+    throw new Error(
+      `Both secret and user tokens are not set. Either client.connectUser wasn't called or client.disconnect was called`,
+    );
+  };
+
+  isStatic = () => this.type === 'static';
+}