@stream-io/node-sdk 0.3.1 → 0.4.1

package/src/StreamClient.ts

@@ -1,129 +1,143 @@
-import { StreamChatClient } from './StreamChatClient';
-import { StreamVideoClient } from './StreamVideoClient';
-import {
-  APIError,
-  BanRequest,
-  BlockUsersRequest,
-  CheckPushRequest,
-  CreateDeviceRequest,
-  CreateGuestRequest,
-  CreateRoleRequest,
-  DeactivateUserRequest,
-  DeactivateUsersRequest,
-  DeleteDeviceRequest,
-  DeletePushProviderRequest,
-  DeleteRoleRequest,
-  DeleteUsersRequest,
-  ExportUserRequest,
-  ExportUsersRequest,
-  FlagRequest,
-  GetBlockedUsersRequest,
-  GetPermissionRequest,
-  GetTaskRequest,
-  ListDevicesRequest,
-  MuteUserRequest,
-  ProductchatApi,
-  PushProvider,
-  QueryBannedUsersRequest,
-  QueryUsersPayload,
-  ReactivateUserRequest,
-  ReactivateUsersRequest,
-  RestoreUsersRequest,
-  UnbanRequest,
-  UnblockUsersRequest,
-  UnmuteUserRequest,
-  UpdateAppRequest,
-  UpdateUserPartialRequest,
-  UpdateUsersRequest,
-  UserCustomEventRequest,
-} from './gen/chat';
-import {
-  Configuration,
-  ErrorContext,
-  FetchError,
-  HTTPQuery,
-  JSONApiResponse,
-  RequestContext,
-  ResponseContext,
-} from './gen/video';
-import { v4 as uuidv4 } from 'uuid';
 import { JWTServerToken, JWTUserToken } from './utils/create-token';
+import { CommonApi } from './gen/common/CommonApi';
+import { StreamVideoClient } from './StreamVideoClient';
 import crypto from 'crypto';
+import { StreamChatClient } from './StreamChatClient';
 import { CallTokenPayload, UserTokenPayload } from './types';
+import { QueryBannedUsersRequest, UserRequest } from './gen/models';
+import { StreamModerationClient } from './StreamModerationClient';
 
 export interface StreamClientOptions {
   timeout?: number;
   basePath?: string;
 }
 
-export class StreamClient {
+export class StreamClient extends CommonApi {
   public readonly video: StreamVideoClient;
   public readonly chat: StreamChatClient;
+  public readonly moderation: StreamModerationClient;
   public readonly options: StreamClientOptions = {};
-  private readonly chatApi: ProductchatApi;
-  private readonly token: string;
+
   private static readonly DEFAULT_TIMEOUT = 3000;
 
   /**
    *
    * @param apiKey
    * @param secret
-   * @param config can be a string, which will be interpreted as base path (deprecated), or a config object
+   * @param config config object
    */
   constructor(
-    private readonly apiKey: string,
+    readonly apiKey: string,
     private readonly secret: string,
-    readonly config?: string | StreamClientOptions,
+    readonly config?: StreamClientOptions,
   ) {
-    this.token = JWTServerToken(this.secret);
+    const token = JWTServerToken(secret);
+    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({ apiKey, token, timeout, baseUrl: chatBaseUrl });
+
+    this.video = new StreamVideoClient({
+      apiKey,
+      token,
+      timeout,
+      baseUrl: videoBaseUrl,
+    });
+    this.chat = new StreamChatClient({
+      apiKey,
+      token,
+      timeout,
+      baseUrl: chatBaseUrl,
+    });
+    this.moderation = new StreamModerationClient({
+      apiKey,
+      token,
+      timeout,
+      baseUrl: chatBaseUrl,
+    });
+  }
 
-    if (typeof config === 'string') {
-      this.options.basePath = config;
-      this.options.timeout = StreamClient.DEFAULT_TIMEOUT;
-    } else {
-      if (config) {
-        this.options = config;
-      }
-      this.options.timeout = config?.timeout ?? StreamClient.DEFAULT_TIMEOUT;
-    }
+  upsertUsers = (users: UserRequest[]) => {
+    const payload: Record<string, UserRequest> = {};
 
-    this.video = new StreamVideoClient(this);
-    this.chat = new StreamChatClient(this);
+    users.forEach((u) => {
+      payload[u.id] = u;
+    });
 
-    const chatConfiguration = this.getConfiguration();
-    /** @ts-expect-error */
-    this.chatApi = new ProductchatApi(chatConfiguration);
-  }
+    return this.updateUsers({ users: payload });
+  };
+
+  queryBannedUsers = (request?: { payload?: QueryBannedUsersRequest }) => {
+    return this.chat.queryBannedUsers(request);
+  };
+
+  /**
+   *
+   * @param payload
+   * - user_id - the id of the user the token is for
+   * - validity_in_seconds - how many seconds is the token valid for (starting from issued at), by default it's 1 hour, dicarded if exp is provided
+   * - exp - when the token expires, unix timestamp in seconds
+   * - iat - issued at date of the token, unix timestamp in seconds, by default it's now
+   */
+  generateUserToken = (
+    payload: {
+      user_id: string;
+      validity_in_seconds?: number;
+      exp?: number;
+      iat?: number;
+    } & Record<string, unknown>,
+  ) => {
+    const defaultIat = Math.floor((Date.now() - 1000) / 1000);
+    payload.iat = payload.iat ?? defaultIat;
+    const validityInSeconds = payload.validity_in_seconds ?? 60 * 60;
+    payload.exp = payload.exp ?? payload.iat + validityInSeconds;
+
+    return JWTUserToken(this.secret, payload as UserTokenPayload);
+  };
+
+  /**
+   *
+   * @param payload
+   * - user_id - the id of the user the token is for
+   * - validity_in_seconds - how many seconds is the token valid for (starting from issued at), by default it's 1 hour, dicarded if exp is provided
+   * - exp - when the token expires, unix timestamp in seconds
+   * - iat - issued at date of the token, unix timestamp in seconds, by default it's now
+   */
+  generateCallToken = (
+    payload: {
+      user_id: string;
+      role?: string;
+      call_cids: string[];
+      validity_in_seconds?: number;
+      exp?: number;
+      iat?: number;
+    } & Record<string, unknown>,
+  ) => {
+    return this.generateUserToken(payload);
+  };
 
   /**
    *
    * @param userID
    * @param exp
    * @param iat deprecated, the default date will be set internally
-   * @param call_cids this parameter is deprecated use `createCallToken` for call tokens
    * @returns
+   *
+   * @deprecated use generateUserToken instead
    */
-  createToken(
+  createToken = (
     userID: string,
     exp = Math.round(Date.now() / 1000) + 60 * 60,
     iat = Math.floor((Date.now() - 1000) / 1000),
-    call_cids?: string[],
-  ) {
+  ) => {
     const payload: UserTokenPayload = {
       user_id: userID,
       exp,
       iat,
     };
 
-    if (call_cids) {
-      console.warn(
-        `Use createCallToken method for creating call tokens, the "call_cids" param will be removed from the createToken method with version 0.2.0`,
-      );
-      payload.call_cids = call_cids;
-    }
-
     return JWTUserToken(this.secret, payload);
-  }
+  };
 
   /**
    *
@@ -132,13 +146,15 @@ export class StreamClient {
    * @param exp
    * @param iat this is deprecated, the current date will be set internally
    * @returns
+   *
+   * @deprecated use generateCallToken instead
    */
-  createCallToken(
+  createCallToken = (
     userIdOrObject: string | { user_id: string; role?: string },
     call_cids: string[],
     exp = Math.round(Date.now() / 1000) + 60 * 60,
     iat = Math.floor((Date.now() - 1000) / 1000),
-  ) {
+  ) => {
     const payload: CallTokenPayload = {
       exp,
       iat,
@@ -154,163 +170,6 @@ export class StreamClient {
     }
 
     return JWTUserToken(this.secret, payload);
-  }
-
-  createDevice = (createDeviceRequest: CreateDeviceRequest) => {
-    return this.chatApi.createDevice({ createDeviceRequest });
-  };
-
-  deleteDevice = (requestParameters: DeleteDeviceRequest) => {
-    return this.chatApi.deleteDevice(requestParameters);
-  };
-
-  listDevices = (requestParameters: ListDevicesRequest) => {
-    return this.chatApi.listDevices(requestParameters);
-  };
-
-  listPushProviders = () => {
-    return this.chatApi.listPushProviders();
-  };
-
-  deletePushProvider = (request: DeletePushProviderRequest) => {
-    return this.chatApi.deletePushProvider(request);
-  };
-
-  upsertPushProvider = (request: PushProvider) => {
-    return this.chatApi.upsertPushProvider({
-      upsertPushProviderRequest: { push_provider: request },
-    });
-  };
-
-  checkPush = (checkPushRequest: CheckPushRequest) => {
-    return this.chatApi.checkPush({ checkPushRequest });
-  };
-
-  createGuest = (createGuestRequest: CreateGuestRequest) => {
-    return this.chatApi.createGuest({ createGuestRequest });
-  };
-
-  banUser = (banRequest: BanRequest) => {
-    return this.chatApi.ban({ banRequest });
-  };
-
-  deactivateUser = (
-    deactivateUserRequest: DeactivateUserRequest & { user_id: string },
-  ) => {
-    return this.chatApi.deactivateUser({
-      deactivateUserRequest,
-      userId: deactivateUserRequest.user_id,
-    });
-  };
-
-  deactivateUsers = (deactivateUsersRequest: DeactivateUsersRequest) => {
-    return this.chatApi.deactivateUsers({ deactivateUsersRequest });
-  };
-
-  deleteUsers = (deleteUsersRequest: DeleteUsersRequest) => {
-    return this.chatApi.deleteUsers({ deleteUsersRequest });
-  };
-
-  exportUser = (request: ExportUserRequest) => {
-    return this.chatApi.exportUser(request);
-  };
-
-  exportUsers = (exportUsersRequest: ExportUsersRequest) => {
-    return this.chatApi.exportUsers({ exportUsersRequest });
-  };
-
-  flag = (flagRequest: FlagRequest) => {
-    return this.chatApi.flag({ flagRequest });
-  };
-
-  queryBannedUsers = (payload: QueryBannedUsersRequest) => {
-    return this.chatApi.queryBannedUsers({ payload });
-  };
-
-  queryUsers = (payload: QueryUsersPayload) => {
-    return this.chatApi.queryUsers({ payload });
-  };
-
-  reactivateUser = (
-    reactivateUserRequest: ReactivateUserRequest & { user_id: string },
-  ) => {
-    return this.chatApi.reactivateUser({
-      reactivateUserRequest,
-      userId: reactivateUserRequest.user_id,
-    });
-  };
-
-  reactivateUsers = (reactivateUsersRequest: ReactivateUsersRequest) => {
-    return this.chatApi.reactivateUsers({ reactivateUsersRequest });
-  };
-
-  restoreUsers = (restoreUsersRequest: RestoreUsersRequest) => {
-    return this.chatApi.restoreUsers({ restoreUsersRequest });
-  };
-
-  unbanUser = (request: UnbanRequest) => {
-    return this.chatApi.unban(request);
-  };
-
-  upsertUsers = (updateUsersRequest: UpdateUsersRequest) => {
-    return this.chatApi.updateUsers({ updateUsersRequest });
-  };
-
-  updateUsersPartial = (request: { users: UpdateUserPartialRequest[] }) => {
-    return this.chatApi.updateUsersPartial({
-      updateUsersPartialRequest: request,
-    });
-  };
-
-  muteUser = (muteUserRequest: MuteUserRequest) => {
-    return this.chatApi.muteUser({ muteUserRequest });
-  };
-
-  unmuteUser = (unmuteUserRequest: UnmuteUserRequest) => {
-    return this.chatApi.unmuteUser({ unmuteUserRequest });
-  };
-
-  sendCustomEventToUser = (userId: string, event: UserCustomEventRequest) => {
-    return this.chatApi.sendUserCustomEvent({
-      userId,
-      sendUserCustomEventRequest: { event },
-    });
-  };
-
-  createRole = (createRoleRequest: CreateRoleRequest) => {
-    return this.chatApi.createRole({ createRoleRequest });
-  };
-
-  deleteRole = (request: DeleteRoleRequest) => {
-    return this.chatApi.deleteRole(request);
-  };
-
-  getPermission = (request: GetPermissionRequest) => {
-    return this.chatApi.getPermission(request);
-  };
-
-  listPermissions = () => {
-    return this.chatApi.listPermissions();
-  };
-
-  listRoles = () => {
-    return this.chatApi.listRoles();
-  };
-
-  getAppSettings = () => {
-    return this.chatApi.getApp();
-  };
-
-  updateAppSettings = (updateAppRequest: UpdateAppRequest) => {
-    return this.chatApi.updateApp({ updateAppRequest });
-  };
-
-  getRateLimits = () => {
-    return this.chatApi.getRateLimits();
-  };
-
-  getTaskStatus = (request: GetTaskRequest) => {
-    return this.chatApi.getTask(request);
   };
 
   verifyWebhook = (requestBody: string | Buffer, xSignature: string) => {
@@ -326,107 +185,4 @@ export class StreamClient {
       return false;
     }
   };
-
-  blockUsers = (blockUsersRequest: BlockUsersRequest) => {
-    return this.chatApi.blockUsers({ blockUsersRequest });
-  };
-
-  unblockUsers = (unblockUsersRequest: UnblockUsersRequest) => {
-    return this.chatApi.unblockUsers({ unblockUsersRequest });
-  };
-
-  getBlockedUsers = (request: GetBlockedUsersRequest) => {
-    return this.chatApi.getBlockedUsers(request);
-  };
-
-  getConfiguration = (product: 'chat' | 'video' = 'chat') => {
-    return new Configuration({
-      apiKey: (name: string) => {
-        const mapping: Record<string, string> = {
-          'Stream-Auth-Type': 'jwt',
-          api_key: this.apiKey,
-          Authorization: this.token,
-        };
-
-        return mapping[name];
-      },
-      basePath:
-        this.options.basePath ??
-        (product === 'chat'
-          ? 'https://chat.stream-io-api.com'
-          : 'https://video.stream-io-api.com'),
-      headers: {
-        'X-Stream-Client': 'stream-node-' + process.env.PKG_VERSION,
-      },
-      middleware: [
-        {
-          pre: (context: RequestContext) => {
-            context.init.headers = {
-              ...context.init.headers,
-              'x-client-request-id': uuidv4(),
-              'Accept-Encoding': 'gzip',
-            };
-
-            return Promise.resolve(context);
-          },
-        },
-        {
-          // This should be the last post middleware because that will throw an error
-          // The Fetch API won't throw an error for HTTP error responses, which means the "onError" middleware won't be called so we need to throw error from "post" middleware
-          post: async (context: ResponseContext) => {
-            if (
-              (context.response && context.response.status < 200) ||
-              context.response.status >= 300
-            ) {
-              const response = new JSONApiResponse(context.response);
-              const value = (await response.value()) as APIError;
-              throw new Error(
-                `Stream error code ${value.code}: ${value.message}`,
-              );
-            }
-          },
-        },
-        {
-          pre: (context: RequestContext) => {
-            context.init.signal = AbortSignal.timeout(this.options.timeout!);
-
-            return Promise.resolve(context);
-          },
-          onError: (context: ErrorContext) => {
-            const error = context.error as DOMException;
-            if (error.name === 'AbortError' || error.name === 'TimeoutError') {
-              throw new FetchError(
-                error,
-                `The request was aborted due to to the ${this.options.timeout}ms timeout, you can set the timeout in the StreamClient constructor`,
-              );
-            }
-
-            return Promise.resolve(context.response);
-          },
-        },
-      ],
-      // https://github.com/OpenAPITools/openapi-generator/issues/13222
-      queryParamsStringify: (params: HTTPQuery) => {
-        const newParams = [];
-        for (const k in params) {
-          const param = params[k];
-          if (Array.isArray(param)) {
-            newParams.push(`${k}=${encodeURIComponent(param.join(','))}`);
-          } else if (typeof param === 'object') {
-            newParams.push(`${k}=${encodeURIComponent(JSON.stringify(param))}`);
-          } else {
-            if (
-              typeof param === 'string' ||
-              typeof param === 'number' ||
-              typeof param === 'boolean'
-            ) {
-              newParams.push(`${k}=${encodeURIComponent(param)}`);
-            }
-          }
-        }
-
-        return newParams.join('&');
-      },
-    });
-  };
 }

package/src/StreamModerationClient.ts

@@ -0,0 +1,3 @@
+import { ModerationApi } from './gen/moderation/ModerationApi';
+
+export class StreamModerationClient extends ModerationApi {}

package/src/StreamVideoClient.ts

@@ -1,100 +1,8 @@
+import { VideoApi } from './gen/video/VideoApi';
 import { StreamCall } from './StreamCall';
-import { StreamClient } from './StreamClient';
-import {
-  CheckExternalStorageRequest,
-  DeleteCallTypeRequest,
-  DeleteExternalStorageRequest,
-  GetCallTypeRequest,
-  ProductvideoApi,
-  VideoCreateCallTypeRequest,
-  VideoCreateExternalStorageRequest,
-  VideoQueryCallStatsRequest,
-  VideoQueryCallsRequest,
-  VideoUpdateCallTypeRequest,
-  VideoUpdateExternalStorageRequest,
-} from './gen/video';
-
-export class StreamVideoClient {
-  private readonly apiClient: ProductvideoApi;
-
-  constructor(private readonly streamClient: StreamClient) {
-    const configuration = this.streamClient.getConfiguration('video');
-    this.apiClient = new ProductvideoApi(configuration);
-  }
 
+export class StreamVideoClient extends VideoApi {
   call = (type: string, id: string) => {
-    return new StreamCall(this.streamClient, type, id);
-  };
-
-  queryCalls = (request?: VideoQueryCallsRequest) => {
-    return this.apiClient.queryCalls({
-      videoQueryCallsRequest: request ?? {},
-    });
-  };
-
-  queryCallStatistics = (
-    videoQueryCallStatsRequest?: VideoQueryCallStatsRequest,
-  ) => {
-    return this.apiClient.queryCallStats({
-      videoQueryCallStatsRequest: videoQueryCallStatsRequest ?? {},
-    });
-  };
-
-  createCallType = (videoCreateCallTypeRequest: VideoCreateCallTypeRequest) => {
-    return this.apiClient.createCallType({
-      videoCreateCallTypeRequest,
-    });
-  };
-
-  deleteCallType = (request: DeleteCallTypeRequest) => {
-    return this.apiClient.deleteCallType(request);
-  };
-
-  getCallType = (request: GetCallTypeRequest) => {
-    return this.apiClient.getCallType(request);
-  };
-
-  listCallTypes = () => {
-    return this.apiClient.listCallTypes();
-  };
-
-  updateCallType = (
-    name: string,
-    videoUpdateCallTypeRequest: VideoUpdateCallTypeRequest,
-  ) => {
-    return this.apiClient.updateCallType({
-      name,
-      videoUpdateCallTypeRequest,
-    });
-  };
-
-  listExternalStorages = () => {
-    return this.apiClient.listExternalStorage();
-  };
-
-  createExternalStorage = (
-    videoCreateExternalStorageRequest: VideoCreateExternalStorageRequest,
-  ) => {
-    return this.apiClient.createExternalStorage({
-      videoCreateExternalStorageRequest,
-    });
-  };
-
-  deleteExternalStorage = (request: DeleteExternalStorageRequest) => {
-    return this.apiClient.deleteExternalStorage(request);
-  };
-
-  updateExternalStorage = (
-    name: string,
-    videoUpdateExternalStorageRequest: VideoUpdateExternalStorageRequest,
-  ) => {
-    return this.apiClient.updateExternalStorage({
-      name,
-      videoUpdateExternalStorageRequest,
-    });
-  };
-
-  checkExternalStorage = (request: CheckExternalStorageRequest) => {
-    return this.apiClient.checkExternalStorage(request);
+    return new StreamCall(this, type, id);
   };
 }