plugnmeet-sdk-js 1.2.0 → 1.2.2

package/dist/types/activeRoomsInfo.d.ts

@@ -0,0 +1,6 @@
+import { Room } from './activeRoomInfo';
+export type ActiveRoomsInfoResponse = {
+    status: boolean;
+    msg: string;
+    rooms?: Array<Room>;
+};

package/dist/types/clientFiles.d.ts

@@ -0,0 +1,6 @@
+export type ClientFilesResponse = {
+    status: boolean;
+    msg: string;
+    css?: Array<string>;
+    js?: Array<string>;
+};

package/dist/types/createRoom.d.ts

@@ -0,0 +1,83 @@
+export type CreateRoomParams = {
+    room_id: string;
+    max_participants?: number;
+    empty_timeout?: number;
+    metadata: RooMetadata;
+};
+export type RooMetadata = {
+    room_title: string;
+    welcome_message?: string;
+    webhook_url?: string;
+    logout_url?: string;
+    room_features: RoomFeaturesParams;
+    default_lock_settings?: LockSettingsParams;
+};
+export type RoomFeaturesParams = {
+    allow_webcams: boolean;
+    mute_on_start: boolean;
+    allow_screen_share: boolean;
+    allow_rtmp: boolean;
+    admin_only_webcams: boolean;
+    allow_view_other_webcams: boolean;
+    allow_view_other_users_list: boolean;
+    recording_features: RecordingFeaturesParams;
+    chat_features: ChatFeaturesParams;
+    shared_note_pad_features?: SharedNotePadFeaturesParams;
+    whiteboard_features?: WhiteboardFeaturesParams;
+    external_media_player_features?: ExternalMediaPlayerFeatures;
+    waiting_room_features?: WaitingRoomFeatures;
+    breakout_room_features?: BreakoutRoomFeatures;
+};
+export type RecordingFeaturesParams = {
+    is_allow: boolean;
+    is_allow_cloud: boolean;
+    is_allow_local: boolean;
+    enable_auto_cloud_recording: boolean;
+};
+export type ChatFeaturesParams = {
+    allow_chat: boolean;
+    allow_file_upload: boolean;
+    allowed_file_types: Array<string>;
+    max_file_size: number;
+};
+export type SharedNotePadFeaturesParams = {
+    allowed_shared_note_pad: boolean;
+};
+export type WhiteboardFeaturesParams = {
+    allowed_whiteboard: boolean;
+};
+export type ExternalMediaPlayerFeatures = {
+    allowed_external_media_player: boolean;
+};
+export type WaitingRoomFeatures = {
+    is_active: boolean;
+    waiting_room_msg?: string;
+};
+export type BreakoutRoomFeatures = {
+    is_allow: boolean;
+};
+export type LockSettingsParams = {
+    lock_microphone?: boolean;
+    lock_webcam?: boolean;
+    lock_screen_sharing?: boolean;
+    lock_whiteboard?: boolean;
+    lock_shared_notepad?: boolean;
+    lock_chat?: boolean;
+    lock_chat_send_message?: boolean;
+    lock_chat_file_share?: boolean;
+};
+export type CreateRoomResponse = {
+    status: boolean;
+    msg: string;
+    roomInfo?: CreateRoomResponseRoomInfo;
+};
+export type CreateRoomResponseRoomInfo = {
+    sid: string;
+    name: string;
+    max_participants: number;
+    empty_timeout: number;
+    creation_time: number;
+    turn_password: string;
+    enabled_codecs: Array<any>;
+    metadata: string;
+};

package/dist/types/deleteRecordings.d.ts

@@ -0,0 +1,7 @@
+export type DeleteRecordingsParams = {
+    record_id: string;
+};
+export type DeleteRecordingsResponse = {
+    status: boolean;
+    msg: string;
+};

package/dist/types/endRoom.d.ts

@@ -0,0 +1,7 @@
+export type EndRoomParams = {
+    room_id: string;
+};
+export type EndRoomResponse = {
+    status: boolean;
+    msg: string;
+};

package/dist/types/fetchRecordings.d.ts

@@ -0,0 +1,27 @@
+export type FetchRecordingsParams = {
+    room_ids: Array<string>;
+    from?: number;
+    limit?: number;
+    order_by?: 'ASC' | 'DESC';
+};
+export type FetchRecordingsResponse = {
+    status: boolean;
+    msg: string;
+    result?: FetchRecordingsResult;
+};
+export type FetchRecordingsResult = {
+    total_recordings: number;
+    from: number;
+    limit: number;
+    order_by: string;
+    recordings_list: Array<RecordingInfo>;
+};
+export type RecordingInfo = {
+    record_id: string;
+    room_id: string;
+    room_sid: string;
+    file_path: string;
+    file_size: number;
+    creation_time: number;
+    room_creation_time: number;
+};

package/dist/types/isRoomActive.d.ts

@@ -0,0 +1,7 @@
+export type IsRoomActiveParams = {
+    room_id: string;
+};
+export type IsRoomActiveResponse = {
+    status: boolean;
+    msg: string;
+};

package/dist/types/joinToken.d.ts

@@ -0,0 +1,21 @@
+import { LockSettingsParams } from './createRoom';
+export type JoinTokenParams = {
+    room_id: string;
+    user_info: JoinTokenUserInfo;
+};
+export type JoinTokenUserInfo = {
+    name: string;
+    user_id: string;
+    is_admin: boolean;
+    is_hidden: boolean;
+    user_metadata?: JoinTokenUserMetadata;
+};
+export type JoinTokenUserMetadata = {
+    profile_pic?: string;
+    lock_settings?: LockSettingsParams;
+};
+export type JoinTokenResponse = {
+    status: boolean;
+    msg: string;
+    token?: string;
+};

package/package.json

@@ -1,21 +1,23 @@
 {
   "name": "plugnmeet-sdk-js",
-  "version": "1.2.0",
-  "type": "module",
+  "version": "1.2.2",
   "description": "plugNmeet JS SDK",
   "author": "Jibon L. Costa",
   "license": "MIT",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    ".": "./index.js"
-  },
-  "typesVersions": {
-    "*": {
-      "index.d.ts": ["index.d.ts"]
-    }
+    "types": "./dist/src/index.d.ts",
+    "import": "./dist/index.js",
+    "require": "./dist/cjs/index.js"
   },
+  "files": [
+    "dist",
+    "src"
+  ],
   "scripts": {
     "start": "rm -rf ./dist && concurrently -c \"red,green\" --kill-others \"tsc --watch -p . --outDir ./dist && esw -w --ext '.ts','.js' --fix\"",
-    "build": "rm -rf ./dist && tsc -p . --outDir ./dist",
+    "build": "rm -rf ./dist && tsc -p tsconfig.json && tsc -p tsconfig-cjs.json",
     "build-docs": "typedoc --sort source-order"
   },
   "devDependencies": {

package/src/PlugNmeet.ts

@@ -0,0 +1,255 @@
+import { prepareAPI, sendRequest } from './api';
+import { CreateRoomParams, CreateRoomResponse } from './types/createRoom';
+import { JoinTokenParams, JoinTokenResponse } from './types/joinToken';
+import { IsRoomActiveParams, IsRoomActiveResponse } from './types/isRoomActive';
+import {
+  ActiveRoomInfoParams,
+  ActiveRoomInfoResponse,
+} from './types/activeRoomInfo';
+import { ActiveRoomsInfoResponse } from './types/activeRoomsInfo';
+import { EndRoomParams, EndRoomResponse } from './types/endRoom';
+import {
+  FetchRecordingsParams,
+  FetchRecordingsResponse,
+} from './types/fetchRecordings';
+import {
+  DeleteRecordingsParams,
+  DeleteRecordingsResponse,
+} from './types/deleteRecordings';
+import {
+  RecordingDownloadTokenParams,
+  RecordingDownloadTokenResponse,
+} from './types/RecordingDownloadToken';
+import { ClientFilesResponse } from './types/clientFiles';
+
+export class PlugNmeet {
+  protected defaultPath = '/auth';
+
+  /**
+   * @param serverUrl plugNmeet server URL
+   * @param apiKey plugNmeet API_Key
+   * @param apiSecret plugNmeet API_Secret
+   */
+  constructor(serverUrl: string, apiKey: string, apiSecret: string) {
+    prepareAPI(serverUrl + this.defaultPath, apiKey, apiSecret);
+  }
+
+  /**
+   * Create new room
+   * @param params: CreateRoomParams
+   * @returns Promise<CreateRoomResponse>
+   */
+  public async createRoom(
+    params: CreateRoomParams,
+  ): Promise<CreateRoomResponse> {
+    const output = await sendRequest('/room/create', params);
+    if (!output.status) {
+      return {
+        status: false,
+        msg: output.response,
+      };
+    }
+
+    return {
+      status: output.response.status,
+      msg: output.response.msg,
+      roomInfo: output.response.roomInfo,
+    };
+  }
+
+  /**
+   * Generate join token
+   * @param params: JoinTokenParams
+   * @returns Promise<JoinTokenResponse>
+   */
+  public async getJoinToken(
+    params: JoinTokenParams,
+  ): Promise<JoinTokenResponse> {
+    const output = await sendRequest('/room/getJoinToken', params);
+    if (!output.status) {
+      return {
+        status: false,
+        msg: output.response,
+      };
+    }
+
+    return {
+      status: output.response.status,
+      msg: output.response.msg,
+      token: output.response.token,
+    };
+  }
+
+  /**
+   * If room is active or not
+   * @param params: IsRoomActiveParams
+   * @returns Promise<IsRoomActiveResponse>
+   */
+  public async isRoomActive(
+    params: IsRoomActiveParams,
+  ): Promise<IsRoomActiveResponse> {
+    const output = await sendRequest('/room/isRoomActive', params);
+    if (!output.status) {
+      return {
+        status: false,
+        msg: output.response,
+      };
+    }
+
+    return {
+      status: output.response.status,
+      msg: output.response.msg,
+    };
+  }
+
+  /**
+   * Get active room information
+   * @param params: ActiveRoomInfoParams
+   * @returns Promise<ActiveRoomInfoResponse>
+   */
+  public async getActiveRoomInfo(
+    params: ActiveRoomInfoParams,
+  ): Promise<ActiveRoomInfoResponse> {
+    const output = await sendRequest('/room/getActiveRoomInfo', params);
+    if (!output.status) {
+      return {
+        status: false,
+        msg: output.response,
+      };
+    }
+
+    return {
+      status: output.response.status,
+      msg: output.response.msg,
+      room: output.response.room,
+    };
+  }
+
+  /**
+   * Get all active rooms
+   * @returns Promise<ActiveRoomsInfoResponse>
+   */
+  public async getActiveRoomsInfo(): Promise<ActiveRoomsInfoResponse> {
+    const output = await sendRequest('/room/getActiveRoomsInfo', {});
+    if (!output.status) {
+      return {
+        status: false,
+        msg: output.response,
+      };
+    }
+
+    return {
+      status: output.response.status,
+      msg: output.response.msg,
+      rooms: output.response.rooms,
+    };
+  }
+
+  /**
+   * End active room
+   * @param params: EndRoomParams
+   * @returns Promise<EndRoomResponse>
+   */
+  public async endRoom(params: EndRoomParams): Promise<EndRoomResponse> {
+    const output = await sendRequest('/room/endRoom', params);
+    if (!output.status) {
+      return {
+        status: false,
+        msg: output.response,
+      };
+    }
+
+    return {
+      status: output.response.status,
+      msg: output.response.msg,
+    };
+  }
+
+  /**
+   * Fetch recordings
+   * @param params: FetchRecordingsParams
+   * @returns Promise<FetchRecordingsResponse>
+   */
+  public async fetchRecordings(
+    params: FetchRecordingsParams,
+  ): Promise<FetchRecordingsResponse> {
+    const output = await sendRequest('/recording/fetch', params);
+    if (!output.status) {
+      return {
+        status: false,
+        msg: output.response,
+      };
+    }
+
+    return {
+      status: output.response.status,
+      msg: output.response.msg,
+      result: output.response.result,
+    };
+  }
+
+  /**
+   * Delete recording
+   * @param params: DeleteRecordingsParams
+   * @returns Promise<DeleteRecordingsResponse>
+   */
+  public async deleteRecordings(
+    params: DeleteRecordingsParams,
+  ): Promise<DeleteRecordingsResponse> {
+    const output = await sendRequest('/recording/delete', params);
+    if (!output.status) {
+      return {
+        status: false,
+        msg: output.response,
+      };
+    }
+
+    return {
+      status: output.response.status,
+      msg: output.response.msg,
+    };
+  }
+
+  /**
+  * @returns Promise<ClientFilesResponse>
+  */
+  public async getClientFiles(): Promise<ClientFilesResponse> {
+    const output = await sendRequest('/getClientFiles', {});
+    if (!output.status) {
+      return {
+        status: false,
+        msg: output.response,
+      };
+    }
+
+    return {
+      status: output.response.status,
+      msg: output.response.msg,
+      css: output.response.css,
+      js: output.response.js,
+    };
+  }
+
+  /**
+   * Generate token to download recording
+   * @param params: RecordingDownloadTokenParams
+   * @returns Promise<RecordingDownloadTokenResponse>
+   */
+  public async getRecordingDownloadToken(
+    params: RecordingDownloadTokenParams,
+  ): Promise<RecordingDownloadTokenResponse> {
+    const output = await sendRequest('/recording/getDownloadToken', params);
+    if (!output.status) {
+      return {
+        status: false,
+        msg: output.response,
+      };
+    }
+
+    return {
+      status: output.response.status,
+      msg: output.response.msg,
+      token: output.response.token,
+    };
+  }
+}

package/src/api.ts

@@ -0,0 +1,92 @@
+import http from 'http';
+import https, { RequestOptions } from 'https';
+import { createHmac } from 'crypto';
+
+let mainOptions: RequestOptions,
+  isSecure = true, _apiKey = "", _apiSecret = "";
+
+export type APIResponse = {
+  status: boolean;
+  response: any;
+};
+
+export const prepareAPI = (
+  apiEndPointURL: string,
+  apiKey: string,
+  apiSecret: string,
+) => {
+  _apiKey = apiKey;
+  _apiSecret = apiSecret;
+
+  const url = new URL(apiEndPointURL);
+  let port = url.protocol === 'https:' ? 443 : 80;
+  isSecure = url.protocol === 'https:' ?? false;
+
+  // use port if supplied with url
+  if (url.port) {
+    port = Number(url.port);
+  }
+
+  mainOptions = {
+    hostname: url.hostname,
+    path: url.pathname,
+    method: 'POST',
+    port,
+  };
+};
+
+const prepareHeader = (body: string) => {
+  const signature = createHmac('sha256', _apiSecret)
+    .update(body)
+    .digest('hex');
+
+  const headers = {
+    'Content-Type': 'application/json',
+    'API-KEY': _apiKey,
+    'HASH-SIGNATURE': signature,
+  };
+
+  return headers;
+};
+
+export const sendRequest = async (path: string, body: any) => {
+  return new Promise<APIResponse>((resolve) => {
+    const output: APIResponse = {
+      status: false,
+      response: undefined,
+    };
+
+    const chunk = JSON.stringify(body);
+
+    const options = { ...mainOptions };
+    options.path += path;
+    options.headers = prepareHeader(chunk);
+
+    const req = (isSecure ? https : http).request(options, (res) => {
+      const body: Array<Uint8Array> = [];
+      res.on('data', (chunk) => body.push(chunk));
+
+      res.on('end', () => {
+        const resString = Buffer.concat(body).toString();
+
+        try {
+          output.status = true;
+          output.response = JSON.parse(resString);
+        } catch (error) {
+          output.status = false;
+          output.response = error;
+        }
+
+        resolve(output);
+      });
+    });
+
+    req.on('error', (error) => {
+      output.response = error.message;
+      resolve(output);
+    });
+
+    req.write(chunk);
+    req.end();
+  });
+};

package/src/index.ts

@@ -0,0 +1,48 @@
+export {
+  RooMetadata,
+  CreateRoomParams,
+  CreateRoomResponse,
+  CreateRoomResponseRoomInfo,
+  LockSettingsParams,
+  RoomFeaturesParams,
+  RecordingFeaturesParams,
+  ChatFeaturesParams,
+  SharedNotePadFeaturesParams,
+  WhiteboardFeaturesParams,
+  ExternalMediaPlayerFeatures,
+  WaitingRoomFeatures,
+  BreakoutRoomFeatures,
+} from './types/createRoom';
+export {
+  JoinTokenParams,
+  JoinTokenResponse,
+  JoinTokenUserMetadata,
+  JoinTokenUserInfo,
+} from './types/joinToken';
+export { IsRoomActiveParams, IsRoomActiveResponse } from './types/isRoomActive';
+export {
+  Room,
+  ActiveRoomInfoParams,
+  ActiveRoomInfoResponse,
+  ParticipantInfo,
+  ActiveRoomInfo,
+} from './types/activeRoomInfo';
+export { ActiveRoomsInfoResponse } from './types/activeRoomsInfo';
+export { EndRoomParams, EndRoomResponse } from './types/endRoom';
+export {
+  FetchRecordingsParams,
+  FetchRecordingsResponse,
+  FetchRecordingsResult,
+  RecordingInfo,
+} from './types/fetchRecordings';
+export {
+  DeleteRecordingsParams,
+  DeleteRecordingsResponse,
+} from './types/deleteRecordings';
+export {
+  RecordingDownloadTokenParams,
+  RecordingDownloadTokenResponse,
+} from './types/RecordingDownloadToken';
+export { ClientFilesResponse } from './types/clientFiles';
+
+export { PlugNmeet } from './PlugNmeet';

package/src/types/RecordingDownloadToken.ts

@@ -0,0 +1,9 @@
+export type RecordingDownloadTokenParams = {
+  record_id: string;
+};
+
+export type RecordingDownloadTokenResponse = {
+  status: boolean;
+  msg: string;
+  token?: string;
+};

package/src/types/activeRoomInfo.ts

@@ -0,0 +1,38 @@
+export type ActiveRoomInfoParams = {
+  room_id: string;
+};
+
+export type ActiveRoomInfoResponse = {
+  status: boolean;
+  msg: string;
+  room?: Room;
+};
+
+export type Room = {
+  room_info: ActiveRoomInfo;
+  participants_info: Array<ParticipantInfo>;
+};
+
+export type ActiveRoomInfo = {
+  room_title: string;
+  room_id: string;
+  sid: string;
+  joined_participants: number;
+  is_running: boolean;
+  is_recording: boolean;
+  is_active_rtmp: boolean;
+  webhook_url: string;
+  creation_time: number;
+  metadata: string;
+};
+
+export type ParticipantInfo = {
+  sid: string;
+  identity: string;
+  state: string;
+  metadata: string;
+  joined_at: number;
+  name: string;
+  version: number;
+  permission: any;
+};