stream-chat 5.6.0 → 6.2.0

package/src/client_state.ts

@@ -1,11 +1,11 @@
-import { UR, UserResponse } from './types';
+import { UserResponse, ExtendableGenerics, DefaultGenerics } from './types';
 
 /**
  * ClientState - A container class for the client state.
  */
-export class ClientState<UserType = UR> {
+export class ClientState<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> {
   users: {
-    [key: string]: UserResponse<UserType>;
+    [key: string]: UserResponse<StreamChatGenerics>;
   };
   userChannelReferences: { [key: string]: { [key: string]: boolean } };
   constructor() {
@@ -16,19 +16,19 @@ export class ClientState<UserType = UR> {
     this.userChannelReferences = {};
   }
 
-  updateUsers(users: UserResponse<UserType>[]) {
+  updateUsers(users: UserResponse<StreamChatGenerics>[]) {
     for (const user of users) {
       this.updateUser(user);
     }
   }
 
-  updateUser(user?: UserResponse<UserType>) {
+  updateUser(user?: UserResponse<StreamChatGenerics>) {
     if (user != null) {
       this.users[user.id] = user;
     }
   }
 
-  updateUserReference(user: UserResponse<UserType>, channelID: string) {
+  updateUserReference(user: UserResponse<StreamChatGenerics>, channelID: string) {
     if (user == null) {
       return;
     }

package/src/connection.ts

@@ -9,7 +9,7 @@ import {
   addConnectionEventListeners,
 } from './utils';
 import { buildWsFatalInsight, buildWsSuccessAfterFailureInsight, postInsights } from './insights';
-import { ConnectAPIResponse, ConnectionOpen, LiteralStringForUnion, UR, LogLevel } from './types';
+import { ConnectAPIResponse, ConnectionOpen, ExtendableGenerics, DefaultGenerics, UR, LogLevel } from './types';
 import { StreamChat } from './client';
 
 // Type guards to check WebSocket error type
@@ -36,22 +36,13 @@ const isErrorEvent = (res: WebSocket.CloseEvent | WebSocket.Data | WebSocket.Err
  * - state can be recovered by querying the channel again
  * - if the servers fails to publish a message to the client, the WS connection is destroyed
  */
-export class StableWSConnection<
-  // CAUTION: generics are out of usual order here
-  ChannelType extends UR = UR,
-  CommandType extends string = LiteralStringForUnion,
-  UserType extends UR = UR,
-  AttachmentType extends UR = UR,
-  EventType extends UR = UR,
-  MessageType extends UR = UR,
-  ReactionType extends UR = UR
-> {
+export class StableWSConnection<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> {
   // global from constructor
-  client: StreamChat<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>;
+  client: StreamChat<StreamChatGenerics>;
 
   // local vars
   connectionID?: string;
-  connectionOpen?: ConnectAPIResponse<ChannelType, CommandType, UserType>;
+  connectionOpen?: ConnectAPIResponse<StreamChatGenerics>;
   consecutiveFailures: number;
   pingInterval: number;
   healthCheckTimeoutRef?: NodeJS.Timeout;
@@ -66,16 +57,12 @@ export class StableWSConnection<
     reason?: Error & { code?: string | number; isWSFailure?: boolean; StatusCode?: string | number },
   ) => void;
   requestID: string | undefined;
-  resolvePromise?: (value: ConnectionOpen<ChannelType, CommandType, UserType>) => void;
+  resolvePromise?: (value: ConnectionOpen<StreamChatGenerics>) => void;
   totalFailures: number;
   ws?: WebSocket;
   wsID: number;
 
-  constructor({
-    client,
-  }: {
-    client: StreamChat<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>;
-  }) {
+  constructor({ client }: { client: StreamChat<StreamChatGenerics> }) {
     /** StreamChat client */
     this.client = client;
     /** consecutive failures influence the duration of the timeout */
@@ -501,7 +488,6 @@ export class StableWSConnection<
     this.isHealthy = healthy;
 
     if (this.isHealthy) {
-      //@ts-expect-error
       this.client.dispatchEvent({ type: 'connection.changed', online: this.isHealthy });
       return;
     }
@@ -509,7 +495,6 @@ export class StableWSConnection<
     // we're offline, wait few seconds and fire and event if still offline
     setTimeout(() => {
       if (this.isHealthy) return;
-      //@ts-expect-error
       this.client.dispatchEvent({ type: 'connection.changed', online: this.isHealthy });
     }, 5000);
   };
@@ -575,7 +560,7 @@ export class StableWSConnection<
   _setupConnectionPromise = () => {
     this.isResolved = false;
     /** a promise that is resolved once ws.open is called */
-    this.connectionOpen = new Promise<ConnectionOpen<ChannelType, CommandType, UserType>>((resolve, reject) => {
+    this.connectionOpen = new Promise<ConnectionOpen<StreamChatGenerics>>((resolve, reject) => {
       this.resolvePromise = resolve;
       this.rejectPromise = reject;
     });

package/src/connection_fallback.ts

@@ -2,7 +2,7 @@ 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';
+import { ConnectionOpen, Event, UR, ExtendableGenerics, DefaultGenerics, LogLevel } from './types';
 
 export enum ConnectionState {
   Closed = 'CLOSED',
@@ -12,26 +12,14 @@ export enum ConnectionState {
   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>;
+export class WSConnectionFallback<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> {
+  client: StreamChat<StreamChatGenerics>;
   state: ConnectionState;
   consecutiveFailures: number;
   connectionID?: string;
   cancelToken?: CancelTokenSource;
 
-  constructor({
-    client,
-  }: {
-    client: StreamChat<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>;
-  }) {
+  constructor({ client }: { client: StreamChat<StreamChatGenerics> }) {
     this.client = client;
     this.state = ConnectionState.Init;
     this.consecutiveFailures = 0;
@@ -48,12 +36,10 @@ export class WSConnectionFallback<
 
     // 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 });
     }
 
@@ -77,7 +63,7 @@ export class WSConnectionFallback<
   };
 
   /** @private */
-  _req = async <T = UR>(params: UnknownType, config: AxiosRequestConfig, retry: boolean): Promise<T> => {
+  _req = async <T = UR>(params: UR, config: AxiosRequestConfig, retry: boolean): Promise<T> => {
     if (!this.cancelToken && !params.close) {
       this.cancelToken = axios.CancelToken.source();
     }
@@ -113,7 +99,7 @@ export class WSConnectionFallback<
     while (this.state === ConnectionState.Connected) {
       try {
         const data = await this._req<{
-          events: Event<AttachmentType, ChannelType, CommandType, EventType, MessageType, ReactionType, UserType>[];
+          events: Event<StreamChatGenerics>[];
         }>({}, { timeout: 30000 }, true); // 30s => API responds in 20s if there is no event
 
         if (data.events?.length) {
@@ -163,7 +149,7 @@ export class WSConnectionFallback<
     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> }>(
+      const { event } = await this._req<{ event: ConnectionOpen<StreamChatGenerics> }>(
         { json: this.client._buildWSPayload() },
         { timeout: 8000 }, // 8s
         reconnect,

package/src/token_manager.ts

@@ -1,20 +1,20 @@
 import { Secret } from 'jsonwebtoken';
 import { UserFromToken, JWTServerToken, JWTUserToken } from './signing';
 import { isFunction } from './utils';
-import { TokenOrProvider, UR, UserResponse } from './types';
+import { TokenOrProvider, ExtendableGenerics, DefaultGenerics, UserResponse } from './types';
 
 /**
  * TokenManager
  *
  * Handles all the operations around user token.
  */
-export class TokenManager<UserType extends UR = UR> {
+export class TokenManager<StreamChatGenerics extends ExtendableGenerics = DefaultGenerics> {
   loadTokenPromise: Promise<string> | null;
   type: 'static' | 'provider';
   secret?: Secret;
   token?: string;
   tokenProvider?: TokenOrProvider;
-  user?: UserResponse<UserType>;
+  user?: UserResponse<StreamChatGenerics>;
   /**
    * Constructor
    *
@@ -38,9 +38,9 @@ export class TokenManager<UserType extends UR = UR> {
    * Token provider should return a token string or a promise which resolves to string token.
    *
    * @param {TokenOrProvider} tokenOrProvider
-   * @param {UserResponse<UserType>} user
+   * @param {UserResponse<StreamChatGenerics>} user
    */
-  setTokenOrProvider = async (tokenOrProvider: TokenOrProvider, user: UserResponse<UserType>) => {
+  setTokenOrProvider = async (tokenOrProvider: TokenOrProvider, user: UserResponse<StreamChatGenerics>) => {
     this.validateToken(tokenOrProvider, user);
     this.user = user;
 
@@ -73,7 +73,7 @@ export class TokenManager<UserType extends UR = UR> {
   };
 
   // Validates the user token.
-  validateToken = (tokenOrProvider: TokenOrProvider, user: UserResponse<UserType>) => {
+  validateToken = (tokenOrProvider: TokenOrProvider, user: UserResponse<StreamChatGenerics>) => {
     // allow empty token for anon user
     if (user && user.anon && !tokenOrProvider) return;