@stream-io/video-client 1.11.5 → 1.11.7

package/dist/src/coordinator/connection/connection_fallback.d.ts

@@ -1,39 +0,0 @@
-import { AxiosRequestConfig, CancelTokenSource } from 'axios';
-import { StreamClient } from './client';
-import { LogLevel, UR } from './types';
-import { ConnectedEvent } from '../../gen/coordinator';
-export declare enum ConnectionState {
-    Closed = "CLOSED",
-    Connected = "CONNECTED",
-    Connecting = "CONNECTING",
-    Disconnected = "DISCONNECTED",
-    Init = "INIT"
-}
-export declare class WSConnectionFallback {
-    client: StreamClient;
-    state: ConnectionState;
-    consecutiveFailures: number;
-    connectionID?: string;
-    cancelToken?: CancelTokenSource;
-    constructor(client: StreamClient);
-    _log(msg: string, extra?: UR, level?: LogLevel): void;
-    _setState(state: ConnectionState): void;
-    /** @private */
-    _onlineStatusChanged: (event: {
-        type: string;
-    }) => void;
-    /** @private */
-    _req: <T = UR>(params: UR, config: AxiosRequestConfig, retry: boolean) => Promise<T>;
-    /** @private */
-    _poll: () => Promise<void>;
-    /**
-     * 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: (reconnect?: boolean) => Promise<ConnectedEvent | undefined>;
-    /**
-     * isHealthy checks if there is a connectionID and connection is in Connected state
-     */
-    isHealthy: () => boolean;
-    disconnect: (timeout?: number) => Promise<void>;
-}

package/dist/src/coordinator/connection/errors.d.ts

@@ -1,16 +0,0 @@
-import { AxiosResponse } from 'axios';
-import { APIErrorResponse } from './types';
-export declare const APIErrorCodes: Record<string, {
-    name: string;
-    retryable: boolean;
-}>;
-type APIError = Error & {
-    code: number;
-    isWSFailure?: boolean;
-};
-export declare function isAPIError(error: Error): error is APIError;
-export declare function isErrorRetryable(error: APIError): boolean;
-export declare function isConnectionIDError(error: APIError): boolean;
-export declare function isWSFailure(err: APIError): boolean;
-export declare function isErrorResponse(res: AxiosResponse<unknown>): res is AxiosResponse<APIErrorResponse>;
-export {};

package/dist/src/coordinator/connection/insights.d.ts

@@ -1,57 +0,0 @@
-import { StableWSConnection } from './connection';
-export type InsightTypes = 'ws_fatal' | 'ws_success_after_failure' | 'http_hi_failed';
-export declare class InsightMetrics {
-    connectionStartTimestamp: number | null;
-    wsConsecutiveFailures: number;
-    wsTotalFailures: number;
-    instanceClientId: string;
-    constructor();
-}
-/**
- * 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 declare const postInsights: (insightType: InsightTypes, insights: Record<string, unknown>) => Promise<void>;
-export declare function buildWsFatalInsight(connection: StableWSConnection, event: Record<string, unknown>): {
-    ready_state: 0 | 1 | 2 | 3 | undefined;
-    url: string;
-    api_key: string;
-    start_ts: number | null;
-    end_ts: number;
-    auth_type: string;
-    token: string | undefined;
-    user_id: string | undefined;
-    user_details: import("./types").UserWithId | undefined;
-    device: string;
-    client_id: string | undefined;
-    ws_details: import("ws") | undefined;
-    ws_consecutive_failures: number;
-    ws_total_failures: number;
-    request_id: string | undefined;
-    online: boolean | null;
-    user_agent: string | null;
-    instance_client_id: string;
-};
-export declare function buildWsSuccessAfterFailureInsight(connection: StableWSConnection): {
-    ready_state: 0 | 1 | 2 | 3 | undefined;
-    url: string;
-    api_key: string;
-    start_ts: number | null;
-    end_ts: number;
-    auth_type: string;
-    token: string | undefined;
-    user_id: string | undefined;
-    user_details: import("./types").UserWithId | undefined;
-    device: string;
-    client_id: string | undefined;
-    ws_details: import("ws") | undefined;
-    ws_consecutive_failures: number;
-    ws_total_failures: number;
-    request_id: string | undefined;
-    online: boolean | null;
-    user_agent: string | null;
-    instance_client_id: string;
-};

package/src/coordinator/connection/base64.ts

@@ -1,80 +0,0 @@
-import { fromByteArray } from 'base64-js';
-
-function isString<T>(arrayOrString: string | T[]): arrayOrString is string {
-  return typeof (arrayOrString as string) === 'string';
-}
-
-type MapGenericCallback<T, U> = (value: T, index: number, array: T[]) => U;
-type MapStringCallback<U> = (value: string, index: number, string: string) => U;
-
-function isMapStringCallback<T, U>(
-  arrayOrString: string | T[],
-  callback: MapGenericCallback<T, U> | MapStringCallback<U>,
-): callback is MapStringCallback<U> {
-  return !!callback && isString(arrayOrString);
-}
-
-// source - https://github.com/beatgammit/base64-js/blob/master/test/convert.js#L72
-function map<T, U>(array: T[], callback: MapGenericCallback<T, U>): U[];
-function map<U>(string: string, callback: MapStringCallback<U>): U[];
-function map<T, U>(
-  arrayOrString: string | T[],
-  callback: MapGenericCallback<T, U> | MapStringCallback<U>,
-): U[] {
-  const res = [];
-
-  if (isString(arrayOrString) && isMapStringCallback(arrayOrString, callback)) {
-    for (let k = 0, len = arrayOrString.length; k < len; k++) {
-      if (arrayOrString.charAt(k)) {
-        const kValue = arrayOrString.charAt(k);
-        const mappedValue = callback(kValue, k, arrayOrString);
-        res[k] = mappedValue;
-      }
-    }
-  } else if (
-    !isString(arrayOrString) &&
-    !isMapStringCallback(arrayOrString, callback)
-  ) {
-    for (let k = 0, len = arrayOrString.length; k < len; k++) {
-      if (k in arrayOrString) {
-        const kValue = arrayOrString[k];
-        const mappedValue = callback(kValue, k, arrayOrString);
-        res[k] = mappedValue;
-      }
-    }
-  }
-
-  return res;
-}
-
-export const encodeBase64 = (data: string): string =>
-  fromByteArray(new Uint8Array(map(data, (char) => char.charCodeAt(0))));
-
-// base-64 decoder throws exception if encoded string is not padded by '=' to make string length
-// in multiples of 4. So gonna use our own method for this purpose to keep backwards compatibility
-// https://github.com/beatgammit/base64-js/blob/master/index.js#L26
-export const decodeBase64 = (s: string): string => {
-  const e = {} as { [key: string]: number },
-    w = String.fromCharCode,
-    L = s.length;
-  let i,
-    b = 0,
-    c,
-    x,
-    l = 0,
-    a,
-    r = '';
-  const A = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
-  for (i = 0; i < 64; i++) {
-    e[A.charAt(i)] = i;
-  }
-  for (x = 0; x < L; x++) {
-    c = e[s.charAt(x)];
-    b = (b << 6) + c;
-    l += 6;
-    while (l >= 8) {
-      ((a = (b >>> (l -= 8)) & 0xff) || x < L - 2) && (r += w(a));
-    }
-  }
-  return r;
-};

package/src/coordinator/connection/connection_fallback.ts

@@ -1,242 +0,0 @@
-import axios, { AxiosRequestConfig, CancelTokenSource } from 'axios';
-import { StreamClient } from './client';
-import {
-  addConnectionEventListeners,
-  removeConnectionEventListeners,
-  retryInterval,
-  sleep,
-} from './utils';
-import { isAPIError, isConnectionIDError, isErrorRetryable } from './errors';
-import { LogLevel, StreamVideoEvent, UR } from './types';
-import { ConnectedEvent } from '../../gen/coordinator';
-
-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, {
-      ...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,
-          publicEndpoint: true,
-        },
-      );
-
-      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: StreamVideoEvent[];
-        }>(
-          {},
-          {
-            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: ConnectedEvent;
-      }>(
-        { json: this.client._buildWSPayload() },
-        {
-          timeout: 8000, // 8s
-        },
-        reconnect,
-      );
-
-      this._setState(ConnectionState.Connected);
-      this.connectionID = event.connection_id;
-      this.client.resolveConnectionId?.();
-      // @ts-expect-error
-      this.client.dispatchEvent(event);
-      this._poll();
-      return event;
-    } catch (err) {
-      this._setState(ConnectionState.Closed);
-      this.client.rejectConnectionId?.();
-      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

@@ -1,80 +0,0 @@
-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 },
-};
-
-// todo: this is not a correct error declaration. /recordings endpoint returns error objects as follows:
-// {
-//     "code": 16,
-//     "message": "ListRecordings failed with error: \"Can't find call with id default:bbbb\"",
-//     "StatusCode": 404,
-//     "duration": "0.00ms",
-//     "more_info": "https://getstream.io/chat/docs/api_errors_response",
-//     "details": []
-// }
-
-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/insights.ts

@@ -1,88 +0,0 @@
-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);
-}