@stream-io/node-sdk 0.4.25 → 0.5.0

package/src/StreamClient.ts

@@ -4,8 +4,16 @@ import { StreamVideoClient } from './StreamVideoClient';
 import crypto from 'crypto';
 import { StreamChatClient } from './StreamChatClient';
 import { CallTokenPayload, UserTokenPayload } from './types';
-import { QueryBannedUsersPayload, UserRequest } from './gen/models';
+import {
+  FileUploadRequest,
+  ImageUploadRequest,
+  QueryBannedUsersPayload,
+  UserRequest,
+} from './gen/models';
 import { StreamModerationClient } from './StreamModerationClient';
+import { ApiClient } from './ApiClient';
+import { StreamFeedsClient } from './StreamFeedsClient';
+import { File } from 'buffer';
 
 export interface StreamClientOptions {
   timeout?: number;
@@ -19,6 +27,7 @@ export class StreamClient extends CommonApi {
   public readonly video: StreamVideoClient;
   public readonly chat: StreamChatClient;
   public readonly moderation: StreamModerationClient;
+  public readonly feeds: StreamFeedsClient;
   public readonly options: StreamClientOptions = {};
 
   private static readonly DEFAULT_TIMEOUT = 3000;
@@ -38,36 +47,40 @@ export class StreamClient extends CommonApi {
     const timeout = config?.timeout ?? StreamClient.DEFAULT_TIMEOUT;
     const chatBaseUrl = config?.basePath ?? 'https://chat.stream-io-api.com';
     const videoBaseUrl = config?.basePath ?? 'https://video.stream-io-api.com';
-    super({
+    const feedsBaseUrl = config?.basePath ?? 'https://video.stream-io-api.com';
+    const chatApiClient = new ApiClient({
       apiKey,
       token,
-      timeout,
       baseUrl: chatBaseUrl,
+      timeout,
       agent: config?.agent as RequestInit['dispatcher'],
     });
 
-    this.video = new StreamVideoClient({
-      streamClient: this,
+    const videoApiClient = new ApiClient({
       apiKey,
       token,
-      timeout,
       baseUrl: videoBaseUrl,
-      agent: config?.agent as RequestInit['dispatcher'],
-    });
-    this.chat = new StreamChatClient({
-      apiKey,
-      token,
       timeout,
-      baseUrl: chatBaseUrl,
       agent: config?.agent as RequestInit['dispatcher'],
     });
-    this.moderation = new StreamModerationClient({
+
+    const feedsApiClient = new ApiClient({
       apiKey,
       token,
+      baseUrl: feedsBaseUrl,
       timeout,
-      baseUrl: chatBaseUrl,
       agent: config?.agent as RequestInit['dispatcher'],
     });
+
+    super(chatApiClient);
+
+    this.video = new StreamVideoClient({
+      streamClient: this,
+      apiClient: videoApiClient,
+    });
+    this.chat = new StreamChatClient(this.apiClient);
+    this.moderation = new StreamModerationClient(chatApiClient);
+    this.feeds = new StreamFeedsClient(feedsApiClient);
   }
 
   upsertUsers = (users: UserRequest[]) => {
@@ -84,6 +97,30 @@ export class StreamClient extends CommonApi {
     return this.chat.queryBannedUsers(request);
   };
 
+  // @ts-expect-error API spec says file should be a string
+  uploadFile = (request: Omit<FileUploadRequest, 'file'> & { file: File }) => {
+    return super.uploadFile({
+      // @ts-expect-error API spec says file should be a string
+      file: request.file,
+      // @ts-expect-error form data will only work if this is a string
+      user: JSON.stringify(request.user),
+    });
+  };
+
+  // @ts-expect-error API spec says file should be a string
+  uploadImage = (
+    request: Omit<ImageUploadRequest, 'file'> & { file: File },
+  ) => {
+    return super.uploadImage({
+      // @ts-expect-error API spec says file should be a string
+      file: request.file,
+      // @ts-expect-error form data will only work if this is a string
+      user: JSON.stringify(request.user),
+      // @ts-expect-error form data will only work if this is a string
+      upload_sizes: JSON.stringify(request.upload_sizes),
+    });
+  };
+
   /**
    *
    * @param payload

package/src/StreamFeed.ts

@@ -0,0 +1,7 @@
+import { FeedApi } from './gen/feeds/FeedApi';
+
+export class StreamFeed extends FeedApi {
+  get fid() {
+    return `${this.group}:${this.id}`;
+  }
+}

package/src/StreamFeedsClient.ts

@@ -0,0 +1,8 @@
+import { FeedsApi } from './gen/feeds/FeedsApi';
+import { StreamFeed } from './StreamFeed';
+
+export class StreamFeedsClient extends FeedsApi {
+  feed = (group: string, id: string) => {
+    return new StreamFeed(this, group, id);
+  };
+}

package/src/StreamVideoClient.ts

@@ -1,7 +1,7 @@
+import { ApiClient } from './ApiClient';
 import { VideoApi } from './gen/video/VideoApi';
 import { StreamCall } from './StreamCall';
 import type { StreamClient } from './StreamClient';
-import type { ApiConfig } from './types';
 // eslint-disable-next-line @typescript-eslint/prefer-ts-expect-error
 /** @ts-ignore Optional dependency */
 import type {
@@ -15,9 +15,12 @@ export class StreamVideoClient extends VideoApi {
 
   constructor({
     streamClient,
-    ...apiConfig
-  }: ApiConfig & { streamClient: StreamClient }) {
-    super(apiConfig);
+    apiClient,
+  }: {
+    streamClient: StreamClient;
+    apiClient: ApiClient;
+  }) {
+    super(apiClient);
     this.streamClient = streamClient;
   }
 
@@ -54,9 +57,9 @@ export class StreamVideoClient extends VideoApi {
     });
 
     const realtimeClient = doCreateRealtimeClient({
-      baseUrl: this.apiConfig.baseUrl,
+      baseUrl: this.streamClient.apiClient.apiConfig.baseUrl,
       call: options.call,
-      streamApiKey: this.apiConfig.apiKey,
+      streamApiKey: this.streamClient.apiClient.apiConfig.apiKey,
       streamUserToken: token,
       openAiApiKey: options.openAiApiKey,
       model: options.model,

package/src/gen/chat/ChannelApi.ts

@@ -1,5 +1,4 @@
-import { ChatApi } from './ChatApi';
-import { StreamResponse } from '../../types';
+import { StreamResponse, ChatApi } from '../../gen-imports';
 import {
   ChannelGetOrCreateRequest,
   ChannelStateResponse,
@@ -36,281 +35,292 @@ export class ChannelApi {
   constructor(
     protected chatApi: ChatApi,
     public readonly type: string,
-    public id?: string,
+    public id: string | undefined,
   ) {}
 
-  delete = (request?: {
+  delete(request?: {
     hard_delete?: boolean;
-  }): Promise<StreamResponse<DeleteChannelResponse>> => {
+  }): 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 = (
+  updateChannelPartial(
     request?: UpdateChannelPartialRequest,
-  ): Promise<StreamResponse<UpdateChannelPartialResponse>> => {
+  ): 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 = (
+  update(
     request?: UpdateChannelRequest,
-  ): Promise<StreamResponse<UpdateChannelResponse>> => {
+  ): 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?: {
+  deleteDraft(request?: {
     parent_id?: string;
     user_id?: string;
-  }): Promise<StreamResponse<Response>> => {
+  }): 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?: {
+  getDraft(request?: {
     parent_id?: string;
     user_id?: string;
-  }): Promise<StreamResponse<GetDraftResponse>> => {
+  }): 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 });
-  };
+  }
 
-  sendEvent = (
-    request: SendEventRequest,
-  ): Promise<StreamResponse<EventResponse>> => {
+  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 });
-  };
+  }
 
-  deleteFile = (request?: {
-    url?: string;
-  }): Promise<StreamResponse<Response>> => {
+  deleteFile(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.deleteFile({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  uploadFile = (
+  uploadFile(
     request?: FileUploadRequest,
-  ): Promise<StreamResponse<FileUploadResponse>> => {
+  ): Promise<StreamResponse<FileUploadResponse>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.uploadFile({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  hide = (
+  hide(
     request?: HideChannelRequest,
-  ): Promise<StreamResponse<HideChannelResponse>> => {
+  ): 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,
     });
-  };
+  }
 
-  deleteImage = (request?: {
-    url?: string;
-  }): Promise<StreamResponse<Response>> => {
+  deleteImage(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.deleteImage({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  uploadImage = (
+  uploadImage(
     request?: ImageUploadRequest,
-  ): Promise<StreamResponse<ImageUploadResponse>> => {
+  ): Promise<StreamResponse<ImageUploadResponse>> {
     if (!this.id) {
       throw new Error(
         `Channel isn't yet created, call getOrCreateDistinctChannel() before this operation`,
       );
     }
+
     return this.chatApi.uploadImage({
       id: this.id,
       type: this.type,
       ...request,
     });
-  };
+  }
 
-  updateMemberPartial = (
+  updateMemberPartial(
     request?: UpdateMemberPartialRequest & { user_id?: string },
-  ): Promise<StreamResponse<UpdateMemberPartialResponse>> => {
+  ): 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 = (
+  sendMessage(
     request: SendMessageRequest,
-  ): Promise<StreamResponse<SendMessageResponse>> => {
+  ): 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: {
+  getManyMessages(request: {
     ids: string[];
-  }): Promise<StreamResponse<GetManyMessagesResponse>> => {
+  }): 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 = (
+  getOrCreate(
     request?: ChannelGetOrCreateRequest,
-  ): Promise<StreamResponse<ChannelStateResponse>> => {
+  ): 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 = (
+  markRead(
     request?: MarkReadRequest,
-  ): Promise<StreamResponse<MarkReadResponse>> => {
+  ): 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 = (
+  show(
     request?: ShowChannelRequest,
-  ): Promise<StreamResponse<ShowChannelResponse>> => {
+  ): 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,
     });
-  };
+  }
 
-  truncate = (
+  truncate(
     request?: TruncateChannelRequest,
-  ): Promise<StreamResponse<TruncateChannelResponse>> => {
+  ): 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>> => {
+  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,
     });
-  };
+  }
 }