stream-chat 9.50.2 → 10.0.0-rc.1

package/src/connection_fallback.ts

@@ -8,7 +8,11 @@ import {
   sleep,
 } from './utils';
 import { isAPIError, isConnectionIDError, isErrorRetryable } from './errors';
-import type { ConnectionOpen, Event, LogLevel, UR } from './types';
+import { chatLoggerSystem } from './logger';
+import type { ConnectionOpen, UR } from './types';
+import type { WSEvent } from './gen/models';
+
+const logger = chatLoggerSystem.getLogger('connection-fallback');
 
 export enum ConnectionState {
   Closed = 'CLOSED',
@@ -33,15 +37,8 @@ export class WSConnectionFallback {
     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}`);
+    logger.withExtraTags('_setState').debug(`Transitioning to state: ${state}.`);
 
     // transition from connecting => connected
     if (
@@ -60,7 +57,9 @@ export class WSConnectionFallback {
 
   /** @private */
   _onlineStatusChanged = (event: { type: string }) => {
-    this._log(`_onlineStatusChanged() - ${event.type}`);
+    logger
+      .withExtraTags('_onlineStatusChanged')
+      .info(`Network status changed to ${event.type}.`);
 
     if (event.type === 'offline') {
       this._setState(ConnectionState.Closed);
@@ -85,24 +84,22 @@ export class WSConnectionFallback {
     }
 
     try {
-      const res = await this.client.doAxiosRequest<T>(
+      const res = await this.client.api.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,
-        },
+        { ...config, cancelToken: this.cancelToken?.token, params },
       );
 
       this.consecutiveFailures = 0; // always reset in case of no error
       return res;
-      // eslint-disable-next-line @typescript-eslint/no-explicit-any
     } catch (error: any) {
       this.consecutiveFailures += 1;
 
       if (retry && isErrorRetryable(error)) {
-        this._log(`_req() - Retryable error, retrying request`);
+        logger
+          .withExtraTags('_req')
+          .debug('Encountered a retryable error. Retrying the request.');
         await sleep(retryInterval(this.consecutiveFailures));
         return this._req<T>(params, config, retry);
       }
@@ -116,7 +113,7 @@ export class WSConnectionFallback {
     while (this.state === ConnectionState.Connected) {
       try {
         const data = await this._req<{
-          events: Event[];
+          events: WSEvent[];
         }>({}, { timeout: 30000 }, true); // 30s => API responds in 20s if there is no event
 
         if (data.events?.length) {
@@ -124,17 +121,18 @@ export class WSConnectionFallback {
             this.client.dispatchEvent(data.events[i]);
           }
         }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
       } catch (error: any) {
         if (axios.isCancel(error)) {
-          this._log(`_poll() - axios canceled request`);
+          logger.withExtraTags('_poll').debug('Axios canceled the request.');
           return;
         }
 
         /** client.doAxiosRequest will take care of TOKEN_EXPIRED error */
 
         if (isConnectionIDError(error)) {
-          this._log(`_poll() - ConnectionID error, connecting without ID...`);
+          logger
+            .withExtraTags('_poll')
+            .warn('Received a connection ID error. Reconnecting without an ID.');
           this._setState(ConnectionState.Disconnected);
           this.connect(true);
           return;
@@ -152,15 +150,20 @@ export class WSConnectionFallback {
 
   /**
    * 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
+   *
+   * @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');
+      logger
+        .withExtraTags('connect')
+        .warn('A connection attempt is already in progress.', { reconnect });
       return;
     }
     if (this.state === ConnectionState.Connected) {
-      this._log('connect() - already connected and polling', { reconnect }, 'warn');
+      logger
+        .withExtraTags('connect')
+        .warn('Already connected and polling.', { reconnect });
       return;
     }
 
@@ -175,7 +178,6 @@ export class WSConnectionFallback {
 
       this._setState(ConnectionState.Connected);
       this.connectionID = event.connection_id;
-      // @ts-expect-error type mismatch
       this.client.dispatchEvent(event);
       this._poll();
       if (reconnect) {
@@ -205,9 +207,9 @@ export class WSConnectionFallback {
 
     try {
       await this._req({ close: true, connection_id }, { timeout }, false);
-      this._log(`disconnect() - Closed connectionID`);
+      logger.withExtraTags('disconnect').info('Closed the connection ID.');
     } catch (err) {
-      this._log(`disconnect() - Failed`, { err }, 'error');
+      logger.withExtraTags('disconnect').error('Disconnect failed.', { error: err });
     }
   };
 }

package/src/constants.ts

@@ -1,9 +1,5 @@
 export const DEFAULT_QUERY_CHANNELS_MESSAGE_LIST_PAGE_SIZE = 25;
 export const DEFAULT_QUERY_CHANNEL_MESSAGE_LIST_PAGE_SIZE = 100;
-export const DEFAULT_MESSAGE_SET_PAGINATION = Object.freeze({
-  hasNext: false,
-  hasPrev: false,
-});
 export const DEFAULT_UPLOAD_SIZE_LIMIT_BYTES = 100 * 1024 * 1024; // 100 MB
 export const API_MAX_FILES_ALLOWED_PER_MESSAGE = 10;
 export const MAX_CHANNEL_MEMBER_COUNT_IN_CHANNEL_QUERY = 100;
@@ -23,7 +19,7 @@ export const RESERVED_UPDATED_MESSAGE_FIELDS = Object.freeze({
   own_reactions: true,
   reaction_counts: true,
   reply_count: true,
-  // Message text related fields that shouldn't be in update
+  // MessageRequest text related fields that shouldn't be in update
   i18n: true,
   type: true,
   html: true,

package/src/custom_types.ts

@@ -1,4 +1,7 @@
-export interface CustomAttachmentData {}
+export interface CustomAttachmentData {
+  mime_type?: string;
+  file_size?: number;
+}
 export interface CustomChannelData {}
 export interface CustomCommandData {}
 export interface CustomEventData {}

package/src/errors.ts

@@ -1,5 +1,5 @@
 import type { AxiosResponse } from 'axios';
-import type { APIErrorResponse } from './types';
+import type { APIError as Gen_APIError } from './types';
 
 export const APIErrorCodes: Record<string, { name: string; retryable: boolean }> = {
   '-1': { name: 'InternalSystemError', retryable: true },
@@ -66,6 +66,6 @@ export function isWSFailure(err: APIError): boolean {
 
 export function isErrorResponse(
   res: AxiosResponse<unknown>,
-): res is AxiosResponse<APIErrorResponse> {
+): res is AxiosResponse<Gen_APIError> {
   return !res.status || res.status < 200 || 300 <= res.status;
 }

package/src/gen/chat/ChannelApi.ts

@@ -0,0 +1,275 @@
+import type { ChatApi, StreamResponse } from '../../gen-imports';
+import type {
+  ChannelGetOrCreateRequest,
+  ChannelStateResponse,
+  ChannelStopWatchingRequest,
+  CreateDraftRequest,
+  CreateDraftResponse,
+  DeleteChannelResponse,
+  EventResponse,
+  GetDraftResponse,
+  GetManyMessagesResponse,
+  HideChannelRequest,
+  HideChannelResponse,
+  MarkReadRequest,
+  MarkReadResponse,
+  MarkUnreadRequest,
+  Response,
+  SendEventRequest,
+  SendMessageRequest,
+  SendMessageResponse,
+  ShowChannelRequest,
+  ShowChannelResponse,
+  TruncateChannelRequest,
+  TruncateChannelResponse,
+  UpdateChannelPartialRequest,
+  UpdateChannelPartialResponse,
+  UpdateChannelRequest,
+  UpdateChannelResponse,
+  UpdateMemberPartialRequest,
+  UpdateMemberPartialResponse,
+  UploadChannelFileRequest,
+  UploadChannelFileResponse,
+  UploadChannelRequest,
+  UploadChannelResponse,
+} from '../models';
+
+export class ChannelApi {
+  constructor(
+    protected chatApi: ChatApi,
+    public readonly type: string,
+    public id: string | undefined,
+  ) {}
+
+  delete(request?: {
+    hard_delete?: boolean;
+  }): Promise<StreamResponse<DeleteChannelResponse>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.deleteChannel({ id: this.id, type: this.type, ...request });
+  }
+
+  updateChannelPartial(
+    request?: UpdateChannelPartialRequest,
+  ): Promise<StreamResponse<UpdateChannelPartialResponse>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.updateChannelPartial({
+      id: this.id,
+      type: this.type,
+      ...request,
+    });
+  }
+
+  update(request?: UpdateChannelRequest): Promise<StreamResponse<UpdateChannelResponse>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.updateChannel({ id: this.id, type: this.type, ...request });
+  }
+
+  deleteDraft(request?: { parent_id?: string }): Promise<StreamResponse<Response>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.deleteDraft({ id: this.id, type: this.type, ...request });
+  }
+
+  getDraft(request?: { parent_id?: string }): Promise<StreamResponse<GetDraftResponse>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.getDraft({ id: this.id, type: this.type, ...request });
+  }
+
+  createDraft(request: CreateDraftRequest): Promise<StreamResponse<CreateDraftResponse>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.createDraft({ id: this.id, type: this.type, ...request });
+  }
+
+  sendEvent(request: SendEventRequest): Promise<StreamResponse<EventResponse>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.sendEvent({ id: this.id, type: this.type, ...request });
+  }
+
+  deleteChannelFile(request?: { url?: string }): Promise<StreamResponse<Response>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.deleteChannelFile({ id: this.id, type: this.type, ...request });
+  }
+
+  uploadChannelFile(
+    request?: UploadChannelFileRequest,
+  ): Promise<StreamResponse<UploadChannelFileResponse>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.uploadChannelFile({ id: this.id, type: this.type, ...request });
+  }
+
+  hide(request?: HideChannelRequest): Promise<StreamResponse<HideChannelResponse>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.hideChannel({ id: this.id, type: this.type, ...request });
+  }
+
+  deleteChannelImage(request?: { url?: string }): Promise<StreamResponse<Response>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.deleteChannelImage({ id: this.id, type: this.type, ...request });
+  }
+
+  uploadChannelImage(
+    request?: UploadChannelRequest,
+  ): Promise<StreamResponse<UploadChannelResponse>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.uploadChannelImage({ id: this.id, type: this.type, ...request });
+  }
+
+  updateMemberPartial(
+    request?: UpdateMemberPartialRequest,
+  ): Promise<StreamResponse<UpdateMemberPartialResponse>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.updateMemberPartial({ id: this.id, type: this.type, ...request });
+  }
+
+  sendMessage(request: SendMessageRequest): Promise<StreamResponse<SendMessageResponse>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.sendMessage({ id: this.id, type: this.type, ...request });
+  }
+
+  getManyMessages(request: {
+    ids: Array<string>;
+  }): Promise<StreamResponse<GetManyMessagesResponse>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.getManyMessages({ id: this.id, type: this.type, ...request });
+  }
+
+  getOrCreate(
+    request?: ChannelGetOrCreateRequest & { connection_id?: string },
+  ): Promise<StreamResponse<ChannelStateResponse>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.getOrCreateChannel({ id: this.id, type: this.type, ...request });
+  }
+
+  markRead(request?: MarkReadRequest): Promise<StreamResponse<MarkReadResponse>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.markRead({ id: this.id, type: this.type, ...request });
+  }
+
+  show(request?: ShowChannelRequest): Promise<StreamResponse<ShowChannelResponse>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.showChannel({ id: this.id, type: this.type, ...request });
+  }
+
+  stopWatching(
+    request?: ChannelStopWatchingRequest & { connection_id?: string },
+  ): Promise<StreamResponse<Response>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.stopWatchingChannel({ id: this.id, type: this.type, ...request });
+  }
+
+  truncate(
+    request?: TruncateChannelRequest,
+  ): Promise<StreamResponse<TruncateChannelResponse>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.truncateChannel({ id: this.id, type: this.type, ...request });
+  }
+
+  markUnread(request?: MarkUnreadRequest): Promise<StreamResponse<Response>> {
+    if (!this.id) {
+      throw new Error(
+        `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
+      );
+    }
+
+    return this.chatApi.markUnread({ id: this.id, type: this.type, ...request });
+  }
+}