@sendbird/sendbird-platform-sdk-typescript 2.0.0 → 2.1.1

package/src/api/generated/util.ts

@@ -0,0 +1,37 @@
+/**
+ * Returns if a specific http code is in a given code range
+ * where the code range is defined as a combination of digits
+ * and "X" (the letter X) with a length of 3
+ *
+ * @param codeRange string with length 3 consisting of digits and "X" (the letter X)
+ * @param code the http status code to be checked against the code range
+ */
+export function isCodeInRange(codeRange: string, code: number): boolean {
+    // This is how the default value is encoded in OAG
+    if (codeRange === "0") {
+        return true;
+    }
+    if (codeRange == code.toString()) {
+        return true;
+    } else {
+        const codeString = code.toString();
+        if (codeString.length != codeRange.length) {
+            return false;
+        }
+        for (let i = 0; i < codeString.length; i++) {
+            if (codeRange.charAt(i) != "X" && codeRange.charAt(i) != codeString.charAt(i)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+
+/**
+* Returns if it can consume form
+*
+* @param consumes array
+*/
+export function canConsumeForm(contentTypes: string[]): boolean {
+    return contentTypes.indexOf('multipart/form-data') !== -1
+}

package/src/types/FileCompat.ts

@@ -0,0 +1,7 @@
+export interface FileInfo {
+  name: string;
+  uri: string;
+  type: string;
+}
+
+export type FileCompat = File | Blob | FileInfo;

package/tests/integration/bot.test.ts

@@ -6,6 +6,8 @@ import {
   CreateABotRequest,
   CreateAGroupChannelRequest,
   GroupChannelApi,
+  SendABotMessageRequest,
+  HttpFile,
 } from "../../index";
 import { hasValidField } from "./helper";
 import {
@@ -13,6 +15,8 @@ import {
   MASTER_USER_ID,
   USERS,
 } from "./constants";
+import FileLoader, { FileAsset } from "../utils/fileLoader";
+import { readFileSync } from 'fs';
 
 describe("Bot API", () => {
   const APP_ID = process.env.APP_ID || "";
@@ -119,9 +123,9 @@ describe("Bot API", () => {
       const BOT_NICKNAME = "test-integration-bot-nickname";
       const BOT_USER_ID = "test-integration-bot-user-id";
       const request: CreateABotRequest = {
-        botCallbackUrl: "callbacn-url",
+        botCallbackUrl: "https://example.com/callback",
         botNickname: BOT_NICKNAME,
-        botProfileUrl: "string",
+        botProfileUrl: "https://example.com/profile.jpg",
         botType: "CUSTOMIZED_BOT",
         /**
          * Specifies the unique ID of a bot. The length is limited to 80 characters.
@@ -183,4 +187,362 @@ describe("Bot API", () => {
       console.warn("ignore error in cleanup", e);
     }
   });
+
+  it("should send MESG message using bot", async () => {
+    const CHANNEL_URL = "test-bot-mesg-channel-url";
+    const BOT_USER_ID = `test-bot-mesg-user-id-${Date.now()}`;
+    const BOT_NICKNAME = "test-bot-mesg-nickname";
+    
+    // Cleanup first
+    try {
+      await groupChannelApi.deleteAGroupChannel({
+        channelUrl: CHANNEL_URL,
+        apiToken: API_TOKEN,
+      });
+    } catch (e) {
+      console.warn("Failed to delete channel:", e);
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    // Create group channel
+    const request: CreateAGroupChannelRequest = {
+      accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
+      blockSdkUserChannelJoin: true,
+      channelUrl: CHANNEL_URL,
+      coverUrl: "empty",
+      customType: "data",
+      data: "data",
+      invitationStatus: {
+        MASTER_USER_ID: "joined",
+      },
+      inviterId: MASTER_USER_ID,
+      isDistinct: false,
+      isEphemeral: true,
+      isPublic: true,
+      isSuper: true,
+      name: "test-mesg-channel",
+      operatorIds: [],
+      strict: true,
+      users: USERS.map((id) => ({ userId: id })),
+    };
+
+    const createGroupChannelresponse = await groupChannelApi.createAGroupChannel({
+      apiToken: API_TOKEN,
+      createAGroupChannelRequest: request,
+    });
+
+    expect(createGroupChannelresponse).toHaveProperty("channelUrl");
+    expect(createGroupChannelresponse.channelUrl).toBe(CHANNEL_URL);
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // Check if bot exists, if not create one
+    let botUserId = BOT_USER_ID;
+    try {
+      const listBotsResponse = await botApi.listBots({
+        apiToken: API_TOKEN,
+      });
+      
+      if (listBotsResponse.bots && listBotsResponse.bots.length > 0) {
+        // Use existing bot
+        botUserId = listBotsResponse.bots[0].bot?.botUserid || BOT_USER_ID;
+      } else {
+        // Create new bot
+        const botRequest: CreateABotRequest = {
+          botCallbackUrl: "https://example.com/callback",
+          botNickname: BOT_NICKNAME,
+          botProfileUrl: "https://example.com/profile.jpg",
+          botType: "CUSTOMIZED_BOT",
+          botUserid: BOT_USER_ID,
+          isPrivacyMode: true,
+          channelInvitationPreference: 0,
+          enableMarkAsRead: true,
+          showMember: true,
+        };
+
+        const createABotResponse = await botApi.createABot({
+          createABotRequest: botRequest,
+          apiToken: API_TOKEN,
+        });
+
+        expect(createABotResponse).toHaveProperty("bot");
+        expect(createABotResponse.bot).toHaveProperty("botUserid");
+        expect(createABotResponse.bot.botUserid).toBe(BOT_USER_ID);
+        botUserId = BOT_USER_ID;
+      }
+    } catch (error) {
+      console.warn("Failed to list bots, creating new bot:", error);
+      // Create new bot as fallback
+      const botRequest: CreateABotRequest = {
+        botCallbackUrl: "https://example.com/callback",
+        botNickname: BOT_NICKNAME,
+        botProfileUrl: "https://example.com/profile.jpg",
+        botType: "CUSTOMIZED_BOT",
+        botUserid: BOT_USER_ID,
+        isPrivacyMode: true,
+        channelInvitationPreference: 0,
+        enableMarkAsRead: true,
+        showMember: true,
+      };
+
+      const createABotResponse = await botApi.createABot({
+        createABotRequest: botRequest,
+        apiToken: API_TOKEN,
+      });
+
+      expect(createABotResponse).toHaveProperty("bot");
+      expect(createABotResponse.bot).toHaveProperty("botUserid");
+      expect(createABotResponse.bot.botUserid).toBe(BOT_USER_ID);
+      botUserId = BOT_USER_ID;
+    }
+
+    // Join bot to channel
+    await botApi.joinChannels({
+      botUserid: botUserId,
+      joinChannelsRequest: {
+        channelUrls: [CHANNEL_URL],
+      },
+      apiToken: API_TOKEN,
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // Send MESG message
+    const messageRequest: SendABotMessageRequest = {
+      messageType: "MESG",
+      channelUrl: CHANNEL_URL,
+      message: "Hello! This is a test message from the bot.",
+      customType: "bot_message",
+      data: "test data",
+      sendPush: true,
+      markAsRead: false,
+    };
+
+    const sendMessageResponse = await botApi.sendABotMessage({
+      botUserid: botUserId,
+      messageType: messageRequest.messageType,
+      channelUrl: messageRequest.channelUrl,
+      apiToken: API_TOKEN,
+      message: messageRequest.message
+    });
+
+
+
+    expect(sendMessageResponse).toBeDefined();
+    expect(sendMessageResponse).toHaveProperty("message");
+    expect(sendMessageResponse.message).toHaveProperty("message");
+    expect(sendMessageResponse.message?.message).toBe(messageRequest.message);
+    expect(sendMessageResponse.message).toHaveProperty("type");
+    expect(sendMessageResponse.message?.type).toBe("MESG");
+    expect(sendMessageResponse.message).toHaveProperty("channelUrl");
+    expect(sendMessageResponse.message?.channelUrl).toBe(CHANNEL_URL);
+
+
+    // Leave bot from channel
+    await botApi.leaveAGroupChannel({
+      botUserid: botUserId,
+      channelUrl: CHANNEL_URL,
+      apiToken: API_TOKEN,
+    });
+
+    // Cleanup last
+    try {
+      await groupChannelApi.deleteAGroupChannel({
+        channelUrl: CHANNEL_URL,
+        apiToken: API_TOKEN,
+      });
+    } catch (e) {
+      console.warn("ignore error in cleanup", e);
+    }
+  });
+
+  it("should send FILE message using bot", async () => {
+    const CHANNEL_URL = "test-bot-file-channel-url";
+    const BOT_USER_ID = `test-bot-file-user-id-${Date.now()}`;
+    const BOT_NICKNAME = "test-bot-file-nickname";
+    
+    // Cleanup first
+    try {
+      await groupChannelApi.deleteAGroupChannel({
+        channelUrl: CHANNEL_URL,
+        apiToken: API_TOKEN,
+      });
+    } catch (e) {
+      console.warn("Failed to delete channel:", e);
+    }
+
+    await new Promise((resolve) => setTimeout(resolve, 500));
+
+    // Create group channel
+    const request: CreateAGroupChannelRequest = {
+      accessCode: GLOBAL_GROUP_CHANNEL_ACCESS_CODE,
+      blockSdkUserChannelJoin: true,
+      channelUrl: CHANNEL_URL,
+      coverUrl: "empty",
+      customType: "data",
+      data: "data",
+      invitationStatus: {
+        MASTER_USER_ID: "joined",
+      },
+      inviterId: MASTER_USER_ID,
+      isDistinct: false,
+      isEphemeral: true,
+      isPublic: true,
+      isSuper: true,
+      name: "test-mesg-channel",
+      operatorIds: [],
+      strict: true,
+      users: USERS.map((id) => ({ userId: id })),
+    };
+
+    const createGroupChannelresponse = await groupChannelApi.createAGroupChannel({
+      apiToken: API_TOKEN,
+      createAGroupChannelRequest: request,
+    });
+
+    expect(createGroupChannelresponse).toHaveProperty("channelUrl");
+    expect(createGroupChannelresponse.channelUrl).toBe(CHANNEL_URL);
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    // Check if bot exists, if not create one
+    let botUserId = BOT_USER_ID;
+    try {
+      const listBotsResponse = await botApi.listBots({
+        apiToken: API_TOKEN,
+      });
+      
+      if (listBotsResponse.bots && listBotsResponse.bots.length > 0) {
+        // Use existing bot
+        botUserId = listBotsResponse.bots[0].bot?.botUserid || BOT_USER_ID;
+      } else {
+        // Create new bot
+        const botRequest: CreateABotRequest = {
+          botCallbackUrl: "https://example.com/callback",
+          botNickname: BOT_NICKNAME,
+          botProfileUrl: "https://example.com/profile.jpg",
+          botType: "CUSTOMIZED_BOT",
+          botUserid: BOT_USER_ID,
+          isPrivacyMode: true,
+          channelInvitationPreference: 0,
+          enableMarkAsRead: true,
+          showMember: true,
+        };
+
+        const createABotResponse = await botApi.createABot({
+          createABotRequest: botRequest,
+          apiToken: API_TOKEN,
+        });
+
+        expect(createABotResponse).toHaveProperty("bot");
+        expect(createABotResponse.bot).toHaveProperty("botUserid");
+        expect(createABotResponse.bot.botUserid).toBe(BOT_USER_ID);
+        botUserId = BOT_USER_ID;
+      }
+    } catch (error) {
+      console.warn("Failed to list bots, creating new bot:", error);
+      // Create new bot as fallback
+      const botRequest: CreateABotRequest = {
+        botCallbackUrl: "https://example.com/callback",
+        botNickname: BOT_NICKNAME,
+        botProfileUrl: "https://example.com/profile.jpg",
+        botType: "CUSTOMIZED_BOT",
+        botUserid: BOT_USER_ID,
+        isPrivacyMode: true,
+        channelInvitationPreference: 0,
+        enableMarkAsRead: true,
+        showMember: true,
+      };
+
+      const createABotResponse = await botApi.createABot({
+        createABotRequest: botRequest,
+        apiToken: API_TOKEN,
+      });
+
+      expect(createABotResponse).toHaveProperty("bot");
+      expect(createABotResponse.bot).toHaveProperty("botUserid");
+      expect(createABotResponse.bot.botUserid).toBe(BOT_USER_ID);
+      botUserId = BOT_USER_ID;
+    }
+
+    // Join bot to channel
+    await botApi.joinChannels({
+      botUserid: botUserId,
+      joinChannelsRequest: {
+        channelUrls: [CHANNEL_URL],
+      },
+      apiToken: API_TOKEN,
+    });
+
+    await new Promise((resolve) => setTimeout(resolve, 100));
+
+    const filePath = './tests/asset/image/test_75kb.jpg';
+    const fileContent = readFileSync(filePath);
+    const file: HttpFile = {
+      name: "test_75kb.jpg",
+      data: fileContent,
+    };
+
+    
+    const testFileObject = await new FileLoader({ name: FileAsset.IMAGE_75kb }).load();
+    
+    // Send FILE message
+    const messageRequest: SendABotMessageRequest = {
+      messageType: "FILE",
+      channelUrl: CHANNEL_URL,
+      customType: "bot_message",
+      data: "test data",
+      sendPush: true,
+      markAsRead: false,
+      file: file, 
+    };
+
+    // Convert FileCompat to HttpFile
+    const httpFile: HttpFile = {
+      name: testFileObject.name,
+      data: Buffer.from(await testFileObject.arrayBuffer())
+    };
+
+    const sendMessageResponse = await botApi.sendABotMessage({
+      botUserid: botUserId,
+      messageType: messageRequest.messageType,
+      channelUrl: messageRequest.channelUrl,
+      apiToken: API_TOKEN,
+      file: httpFile,
+      customType: messageRequest.customType,
+      data: messageRequest.data,
+      sendPush: messageRequest.sendPush,
+      markAsRead: messageRequest.markAsRead
+    });
+
+
+
+    expect(sendMessageResponse).toBeDefined();
+    expect(sendMessageResponse).toHaveProperty("message");
+    expect(sendMessageResponse.message).toHaveProperty("type");
+    expect(sendMessageResponse.message?.type).toBe("FILE");
+    expect(sendMessageResponse.message).toHaveProperty("channelUrl");
+    expect(sendMessageResponse.message?.channelUrl).toBe(CHANNEL_URL);
+    expect(sendMessageResponse.message).toHaveProperty("file");
+    expect(sendMessageResponse.message?.file).toBeDefined();
+
+
+    // Leave bot from channel
+    await botApi.leaveAGroupChannel({
+      botUserid: botUserId,
+      channelUrl: CHANNEL_URL,
+      apiToken: API_TOKEN,
+    });
+
+    // Cleanup last
+    try {
+      await groupChannelApi.deleteAGroupChannel({
+        channelUrl: CHANNEL_URL,
+        apiToken: API_TOKEN,
+      });
+    } catch (e) {
+      console.warn("ignore error in cleanup", e);
+    }
+  });
 });

package/tests/integration/user.test.ts

@@ -396,10 +396,6 @@ describe("User API", () => {
     expect(createAUserResponse.accessToken).toBe("");
     expect(typeof createAUserResponse.accessToken).toBe("string");
 
-    expect(createAUserResponse).toHaveProperty("sessionTokens");
-    expect(createAUserResponse.sessionTokens).toStrictEqual([]);
-    expect(Array.isArray(createAUserResponse.sessionTokens)).toBeTruthy();
-
     expect(createAUserResponse).toHaveProperty("isOnline");
     expect(createAUserResponse.isOnline).toBe(false);
     expect(typeof createAUserResponse.isOnline).toBe("boolean");
@@ -465,10 +461,6 @@ describe("User API", () => {
     expect(viewAUserResponse.isShadowBlocked).toBe(false);
     expect(typeof viewAUserResponse.isShadowBlocked).toBe("boolean");
 
-    expect(viewAUserResponse).toHaveProperty("sessionTokens");
-    expect(viewAUserResponse.sessionTokens).toStrictEqual([]);
-    expect(Array.isArray(viewAUserResponse.sessionTokens)).toBeTruthy();
-
     expect(viewAUserResponse).toHaveProperty("isOnline");
     expect(viewAUserResponse.isOnline).toBe(false);
     expect(typeof viewAUserResponse.isOnline).toBe("boolean");
@@ -547,10 +539,6 @@ describe("User API", () => {
     expect(updateAUserResponse.isShadowBlocked).toBe(false);
     expect(typeof updateAUserResponse.isShadowBlocked).toBe("boolean");
 
-    expect(updateAUserResponse).toHaveProperty("sessionTokens");
-    expect(updateAUserResponse.sessionTokens).toStrictEqual([]);
-    expect(Array.isArray(updateAUserResponse.sessionTokens)).toBeTruthy();
-
     expect(updateAUserResponse).toHaveProperty("isOnline");
     expect(updateAUserResponse.isOnline).toBe(false);
     expect(typeof updateAUserResponse.isOnline).toBe("boolean");

package/tests/utils/fileLoader.ts

@@ -0,0 +1,46 @@
+import { readFileSync } from 'fs';
+const mimeTypes = require('mime-types');
+
+export enum FileAsset {
+  IMAGE_20kb = 'image/test_20kb.jpg',
+  IMAGE_75kb = 'image/test_75kb.jpg',
+  IMAGE_5MB = 'image/test_5mb.jpg',
+  IMAGE_25MB = 'image/test_25mb.bmp',
+}
+
+const base64toBlob = (base64Data: string, name: string, contentType: string = '') => {
+  const sliceSize = 1024;
+  const byteCharacters = atob(base64Data);
+  const bytesLength = byteCharacters.length;
+  const slicesCount = Math.ceil(bytesLength / sliceSize);
+  const byteArrays = new Array(slicesCount);
+  for (let sliceIndex = 0; sliceIndex < slicesCount; ++sliceIndex) {
+    const begin = sliceIndex * sliceSize;
+    const end = Math.min(begin + sliceSize, bytesLength);
+    const bytes = new Array(end - begin);
+    for (let offset = begin, i = 0; offset < end; ++i, ++offset) {
+      bytes[i] = byteCharacters[offset].charCodeAt(0);
+    }
+    byteArrays[sliceIndex] = new Uint8Array(bytes);
+  }
+  return new File(byteArrays, name, { type: contentType });
+};
+
+interface FileLoaderProperties {
+  name: FileAsset;
+}
+
+export default class FileLoader {
+  private _asset: FileAsset;
+
+  constructor({ name }: FileLoaderProperties) {
+    this._asset = name;
+  }
+  async load(): Promise<File> {
+    const path = `${__dirname}/../asset/${this._asset}`;
+    const buffer = readFileSync(path);
+    const type = mimeTypes.lookup(path);
+    const base64 = buffer.toString('base64');
+    return base64toBlob(base64, this._asset, typeof type === 'string' ? type : undefined);
+  }
+}