stream-chat 9.50.3 → 10.0.0-rc.2

package/src/thread_manager.ts

@@ -1,11 +1,21 @@
+import { chatLoggerSystem } from './logger';
 import { StateStore } from './store';
 import { throttle } from './utils';
 
 import type { StreamChat } from './client';
 import type { Thread } from './thread';
-import type { Event, OwnUserResponse, QueryThreadsOptions } from './types';
+import type {
+  Event,
+  EventPayload,
+  EventType,
+  OwnUserResponse,
+  QueryThreadsRequest,
+} from './types';
 import { WithSubscriptions } from './utils/WithSubscriptions';
 
+const eventIsHealthCheck = (event: Event): event is EventPayload<'health.check'> =>
+  Object.hasOwn(event, 'me');
+
 const DEFAULT_CONNECTION_RECOVERY_THROTTLE_DURATION = 1000;
 const MAX_QUERY_THREADS_LIMIT = 25;
 export const THREAD_MANAGER_INITIAL_STATE = {
@@ -51,6 +61,8 @@ export type ThreadManagerPagination = {
   nextCursor: string | null;
 };
 
+const logger = chatLoggerSystem.getLogger('thread-manager');
+
 export class ThreadManager extends WithSubscriptions {
   public readonly state: StateStore<ThreadManagerState>;
   private client: StreamChat;
@@ -121,16 +133,21 @@ export class ThreadManager extends WithSubscriptions {
       (this.client.user as OwnUserResponse) ?? {};
     this.state.partialNext({ unreadThreadCount });
 
-    const unsubscribeFunctions = [
-      'health.check',
-      'notification.mark_read',
-      'notification.mark_unread',
-      'notification.thread_message_new',
-      'notification.channel_deleted',
-    ].map(
+    const unsubscribeFunctions = (
+      [
+        'health.check',
+        'notification.mark_read',
+        'notification.mark_unread',
+        'notification.thread_message_new',
+        'notification.channel_deleted',
+      ] as const satisfies EventType[]
+    ).map(
       (eventType) =>
         this.client.on(eventType, (event) => {
-          const { unread_threads: unreadThreadCount } = event.me ?? event;
+          const { unread_threads: unreadThreadCount } =
+            (eventIsHealthCheck(event) && event.me) ||
+            (event as Extract<typeof event, { unread_threads?: any }>);
+
           if (typeof unreadThreadCount === 'number') {
             this.state.partialNext({ unreadThreadCount });
           }
@@ -174,7 +191,7 @@ export class ThreadManager extends WithSubscriptions {
     );
 
   private subscribeNewReplies = () =>
-    this.client.on('notification.thread_message_new', (event: Event) => {
+    this.client.on('notification.thread_message_new', (event) => {
       const parentId = event.message?.parent_id;
       if (!parentId) return;
 
@@ -211,7 +228,7 @@ export class ThreadManager extends WithSubscriptions {
       },
       DEFAULT_CONNECTION_RECOVERY_THROTTLE_DURATION,
       { trailing: true },
-    );
+    ).throttledFn;
 
     const unsubscribeConnectionRecovered = this.client.on(
       'connection.recovered',
@@ -280,7 +297,9 @@ export class ThreadManager extends WithSubscriptions {
         ready: true,
       }));
     } catch (error) {
-      this.client.logger('error', (error as Error).message);
+      logger
+        .withExtraTags('reload')
+        .error('Failed to reload the thread list.', { error });
       this.state.next((current) => ({
         ...current,
         pagination: {
@@ -291,8 +310,8 @@ export class ThreadManager extends WithSubscriptions {
     }
   };
 
-  public queryThreads = (options: QueryThreadsOptions = {}) =>
-    this.client.queryThreads({
+  public queryThreads = (options: QueryThreadsRequest = {}) =>
+    this.client.queryThreadsAndHydrate({
       limit: 25,
       participant_limit: 10,
       reply_limit: 10,
@@ -300,7 +319,7 @@ export class ThreadManager extends WithSubscriptions {
       ...options,
     });
 
-  public loadNextPage = async (options: Omit<QueryThreadsOptions, 'next'> = {}) => {
+  public loadNextPage = async (options: Omit<QueryThreadsRequest, 'next'> = {}) => {
     const { pagination } = this.state.getLatestValue();
 
     if (pagination.isLoadingNext || !pagination.nextCursor) return;
@@ -325,7 +344,9 @@ export class ThreadManager extends WithSubscriptions {
         },
       }));
     } catch (error) {
-      this.client.logger('error', (error as Error).message);
+      logger
+        .withExtraTags('loadNextPage')
+        .error('Failed to load the next page of threads.', { error });
       this.state.next((current) => ({
         ...current,
         pagination: {

package/src/token_manager.ts

@@ -1,9 +1,13 @@
 import type jwt from 'jsonwebtoken';
 
+import { chatLoggerSystem } from './logger';
 import { JWTServerToken, JWTUserToken, UserFromToken } from './signing';
 import { isFunction } from './utils';
-import type { TokenOrProvider, UserResponse } from './types';
+import type { TokenOrProvider } from './types';
 
+const logger = chatLoggerSystem.getLogger('token-manager');
+
+export type TokenManagerMinimalUser = { id: string; anon?: boolean };
 /**
  * TokenManager
  *
@@ -15,11 +19,12 @@ export class TokenManager {
   secret?: jwt.Secret;
   token?: string;
   tokenProvider?: TokenOrProvider;
-  user?: UserResponse;
+  user?: TokenManagerMinimalUser;
   /**
-   * Constructor
+   * Initializes the token manager, optionally with a server-side API secret used to mint tokens
+   * locally.
    *
-   * @param {Secret} secret
+   * @param secret - Optional API secret. When provided, the manager will sign server tokens locally.
    */
   constructor(secret?: jwt.Secret) {
     this.loadTokenPromise = null;
@@ -35,13 +40,16 @@ export class TokenManager {
   }
 
   /**
-   * Set the static string token or token provider.
-   * Token provider should return a token string or a promise which resolves to string token.
+   * Sets the static string token or token provider. A token provider should return a token string
+   * or a promise that resolves to a token string.
    *
-   * @param {TokenOrProvider} tokenOrProvider
-   * @param {UserResponse} user
+   * @param tokenOrProvider - A token string or an async provider that returns one.
+   * @param user - The user the token belongs to.
    */
-  setTokenOrProvider = async (tokenOrProvider: TokenOrProvider, user: UserResponse) => {
+  setTokenOrProvider = async (
+    tokenOrProvider: TokenOrProvider,
+    user: TokenManagerMinimalUser,
+  ) => {
     this.validateToken(tokenOrProvider, user);
     this.user = user;
 
@@ -76,7 +84,7 @@ export class TokenManager {
   };
 
   // Validates the user token.
-  validateToken = (tokenOrProvider: TokenOrProvider, user: UserResponse) => {
+  validateToken = (tokenOrProvider: TokenOrProvider, user: TokenManagerMinimalUser) => {
     // allow empty token for anon user
     if (user && user.anon && !tokenOrProvider) return;
 
@@ -126,6 +134,9 @@ export class TokenManager {
         try {
           this.token = await this.tokenProvider();
         } catch (e) {
+          logger
+            .withExtraTags('loadToken')
+            .error('The token provider threw an error.', { error: e });
           return reject(
             new Error(`Call to tokenProvider failed with message: ${e}`, { cause: e }),
           );