vani-meeting-server 1.1.0 → 1.1.2

package/lib/ServerHandler.d.ts

@@ -9,5 +9,6 @@ export declare class ServerHandler {
     sfuHandler?: SFUHandler;
     static instance: ServerHandler;
     static getInstance(): ServerHandler;
+    constructor();
     initWithServerStartRequest(serverStartRequest: WebSocketServerStartRequest): Promise<void>;
 }

package/lib/ServerHandler.js

@@ -1,35 +1,32 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { RedisHandler } from "./lib/redis/RedisHandler";
-import { WebSocketServerStartRequest } from "./models/WebSocketServerStartRequest";
-import { SFUHandler } from "./sfu/SFUHandler";
-import { WebSocketHandler } from "./websocket/WebSocketHandler";
-export class ServerHandler {
-    constructor() {
-        this.serverStartRequest = new WebSocketServerStartRequest();
-    }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServerHandler = void 0;
+const RedisHandler_1 = require("./lib/redis/RedisHandler");
+const WebSocketServerStartRequest_1 = require("./models/WebSocketServerStartRequest");
+const SFUHandler_1 = require("./sfu/SFUHandler");
+const WebSocketHandler_1 = require("./websocket/WebSocketHandler");
+class ServerHandler {
+    serverStartRequest = new WebSocketServerStartRequest_1.WebSocketServerStartRequest();
+    rediHandler;
+    webSocketHandler;
+    sfuHandler;
+    static instance = new ServerHandler();
     static getInstance() {
         return ServerHandler.instance;
     }
-    initWithServerStartRequest(serverStartRequest) {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.serverStartRequest = serverStartRequest;
-            this.rediHandler = RedisHandler.getInstance();
-            yield this.rediHandler.connectDB();
-            yield this.rediHandler.cleanUp();
-            console.info("On Redis Connected");
-            this.webSocketHandler = new WebSocketHandler();
-            this.webSocketHandler.connect();
-            this.sfuHandler = SFUHandler.getInstance();
-            this.sfuHandler.init();
-        });
+    constructor() {
+        console.log("ServerHandler constructor");
+    }
+    async initWithServerStartRequest(serverStartRequest) {
+        this.serverStartRequest = serverStartRequest;
+        this.rediHandler = RedisHandler_1.RedisHandler.getInstance();
+        await this.rediHandler.connectDB();
+        await this.rediHandler.cleanUp();
+        console.info("On Redis Connected");
+        this.webSocketHandler = new WebSocketHandler_1.WebSocketHandler();
+        this.webSocketHandler.connect();
+        this.sfuHandler = SFUHandler_1.SFUHandler.getInstance();
+        this.sfuHandler.init();
     }
 }
-ServerHandler.instance = new ServerHandler();
+exports.ServerHandler = ServerHandler;

package/lib/base/BaseSFUWebsocket.js

@@ -1,18 +1,10 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { RedisHandler } from "../lib/redis/RedisHandler";
-export class BaseSFUWebsocket {
-    redisBroadcastMessageToTopic(topic, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            RedisHandler.getInstance().redisPublisher.publish(topic, JSON.stringify(data));
-        });
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseSFUWebsocket = void 0;
+const RedisHandler_1 = require("../lib/redis/RedisHandler");
+class BaseSFUWebsocket {
+    async redisBroadcastMessageToTopic(topic, data) {
+        RedisHandler_1.RedisHandler.getInstance().redisPublisher.publish(topic, JSON.stringify(data));
     }
     //Utilility function
     preapreClientMessageBody(shouldSendToSelf, senderParticipant, broadcastMessage) {
@@ -22,3 +14,4 @@ export class BaseSFUWebsocket {
         return { type, data, interfaceName: 'WebSocketMessageBody' };
     }
 }
+exports.BaseSFUWebsocket = BaseSFUWebsocket;

package/lib/index.js

@@ -1,3 +1,19 @@
-export * from './models/Event';
-export * from './models/WebSocketServerStartRequest';
-export * from './ServerHandler';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./models/Event"), exports);
+__exportStar(require("./models/WebSocketServerStartRequest"), exports);
+__exportStar(require("./ServerHandler"), exports);

package/lib/lib/redis/RedisHandler.js

@@ -1,135 +1,112 @@
-var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, _arguments || [])).next());
-    });
-};
-import { createClient } from "redis";
-import { Participant } from "../../models/Participant";
-import { ServerHandler } from "../../ServerHandler";
-export var RedisKeyType;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RedisHandler = exports.RedisKeyType = void 0;
+const redis_1 = require("redis");
+const Participant_1 = require("../../models/Participant");
+const ServerHandler_1 = require("../../ServerHandler");
+var RedisKeyType;
 (function (RedisKeyType) {
     RedisKeyType["Messages"] = "messages";
     RedisKeyType["MeetingTime"] = "meetingTime";
     RedisKeyType["Participants"] = "participants";
-})(RedisKeyType || (RedisKeyType = {}));
-export class RedisHandler {
+})(RedisKeyType = exports.RedisKeyType || (exports.RedisKeyType = {}));
+class RedisHandler {
+    static redisHandler = new RedisHandler();
+    redisClient;
+    // private redisRoomModelHash = new Map<string, RedisRoomModel>;
+    redisPublisher;
+    redisSubscriber;
     constructor() {
-        this.redisClient = createClient({ url: ServerHandler.getInstance().serverStartRequest.redisUrl, database: ServerHandler.getInstance().serverStartRequest.redisDBIndex });
-        this.redisSubscriber = createClient({ url: ServerHandler.getInstance().serverStartRequest.redisUrl });
-        this.redisPublisher = createClient({ url: ServerHandler.getInstance().serverStartRequest.redisUrl });
+        this.redisClient = (0, redis_1.createClient)({ url: ServerHandler_1.ServerHandler.getInstance().serverStartRequest.redisUrl, database: ServerHandler_1.ServerHandler.getInstance().serverStartRequest.redisDBIndex });
+        this.redisSubscriber = (0, redis_1.createClient)({ url: ServerHandler_1.ServerHandler.getInstance().serverStartRequest.redisUrl });
+        this.redisPublisher = (0, redis_1.createClient)({ url: ServerHandler_1.ServerHandler.getInstance().serverStartRequest.redisUrl });
     }
     static getInstance() {
         return this.redisHandler;
     }
-    connectDB() {
-        return __awaiter(this, void 0, void 0, function* () {
-            this.redisClient.on("connect", (data) => {
-                console.info('Redis has been connected successfully.', data);
-            });
-            this.redisClient.on('end', (err) => {
-                console.error('Redis connection has been closed.', err);
-            });
-            this.redisClient.on('error', (err) => {
-                console.error('Unknown exception occurred at Redis', err);
-            });
-            yield this.redisClient.connect();
-            yield this.redisSubscriber.connect();
-            yield this.redisPublisher.connect();
-            // await this.redisClient.hSet("rooms","123","HSETObject")
-            // console.log(await this.redisClient.hGet("rooms","123"))
+    async connectDB() {
+        this.redisClient.on("connect", (data) => {
+            console.info('Redis has been connected successfully.', data);
         });
-    }
-    cleanUp() {
-        return __awaiter(this, void 0, void 0, function* () {
-            return yield this.redisClient.flushDb();
+        this.redisClient.on('end', (err) => {
+            console.error('Redis connection has been closed.', err);
+        });
+        this.redisClient.on('error', (err) => {
+            console.error('Unknown exception occurred at Redis', err);
         });
+        await this.redisClient.connect();
+        await this.redisSubscriber.connect();
+        await this.redisPublisher.connect();
+        // await this.redisClient.hSet("rooms","123","HSETObject")
+        // console.log(await this.redisClient.hGet("rooms","123"))
+    }
+    async cleanUp() {
+        return await this.redisClient.flushDb();
     }
     //Clean Room Id
-    cleanUpRoomId(roomId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.redisClient.del(roomId);
-        });
+    async cleanUpRoomId(roomId) {
+        await this.redisClient.del(roomId);
     }
     //Messages
-    storeMesagesForRoom(roomId, messagePayload) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const messages = yield this.fetchMessagesForRoom(roomId);
-            messages.push(messagePayload);
-            yield this.redisClient.hSet(roomId, RedisKeyType.Messages, JSON.stringify(messages));
-            this.updateRoomCleanupTimeOut(roomId);
-        });
+    async storeMesagesForRoom(roomId, messagePayload) {
+        const messages = await this.fetchMessagesForRoom(roomId);
+        messages.push(messagePayload);
+        await this.redisClient.hSet(roomId, RedisKeyType.Messages, JSON.stringify(messages));
+        this.updateRoomCleanupTimeOut(roomId);
     }
-    fetchMessagesForRoom(roomId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const messages = yield this.redisClient.hGet(roomId, RedisKeyType.Messages);
-            if (messages) {
-                return JSON.parse(messages);
-            }
-            else {
-                return [];
-            }
-        });
+    async fetchMessagesForRoom(roomId) {
+        const messages = await this.redisClient.hGet(roomId, RedisKeyType.Messages);
+        if (messages) {
+            return JSON.parse(messages);
+        }
+        else {
+            return [];
+        }
     }
     //Meeting Time
-    storeMeetingTimeForRoom(roomId, time) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.redisClient.hSet(roomId, RedisKeyType.MeetingTime, time ? time : new Date().getTime());
-            this.updateRoomCleanupTimeOut(roomId);
-        });
+    async storeMeetingTimeForRoom(roomId, time) {
+        await this.redisClient.hSet(roomId, RedisKeyType.MeetingTime, time ? time : new Date().getTime());
+        this.updateRoomCleanupTimeOut(roomId);
     }
-    fetchMeetingTimeForRoom(roomId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const meetingTime = yield this.redisClient.hGet(roomId, RedisKeyType.MeetingTime);
-            if (meetingTime) {
-                return +meetingTime;
-            }
-            else {
-                return undefined;
-            }
-        });
+    async fetchMeetingTimeForRoom(roomId) {
+        const meetingTime = await this.redisClient.hGet(roomId, RedisKeyType.MeetingTime);
+        if (meetingTime) {
+            return +meetingTime;
+        }
+        else {
+            return undefined;
+        }
     }
     //Users
-    removeParticipantForRoom(roomId, participant) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const participantKey = RedisKeyType.Participants + ":" + participant.userId;
-            yield this.redisClient.hDel(roomId, participantKey);
-            this.updateRoomCleanupTimeOut(roomId);
-        });
+    async removeParticipantForRoom(roomId, participant) {
+        const participantKey = RedisKeyType.Participants + ":" + participant.userId;
+        await this.redisClient.hDel(roomId, participantKey);
+        this.updateRoomCleanupTimeOut(roomId);
     }
-    addUpdateParticipantForRoom(roomId, participant) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const participantKey = RedisKeyType.Participants + ":" + participant.userId;
-            yield this.redisClient.hSet(roomId, participantKey, JSON.stringify(participant));
-            this.updateRoomCleanupTimeOut(roomId);
-        });
+    async addUpdateParticipantForRoom(roomId, participant) {
+        const participantKey = RedisKeyType.Participants + ":" + participant.userId;
+        await this.redisClient.hSet(roomId, participantKey, JSON.stringify(participant));
+        this.updateRoomCleanupTimeOut(roomId);
     }
-    getParticipantByUserId(roomId, userId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const participantKey = RedisKeyType.Participants + ":" + userId;
-            const particpantString = yield this.redisClient.hGet(roomId, participantKey);
-            if (particpantString) {
-                return JSON.parse(particpantString);
-            }
-            return undefined;
-        });
+    async getParticipantByUserId(roomId, userId) {
+        const participantKey = RedisKeyType.Participants + ":" + userId;
+        const particpantString = await this.redisClient.hGet(roomId, participantKey);
+        if (particpantString) {
+            return JSON.parse(particpantString);
+        }
+        return undefined;
     }
-    getAllParticipants(roomId) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const particpantsInStringify = yield this.redisClient.hGetAll(roomId);
-            const participants = [];
-            if (particpantsInStringify) {
-                Object.entries(particpantsInStringify).forEach(([key, value]) => {
-                    if (key.includes(RedisKeyType.Participants)) {
-                        participants.push(Object.assign(new Participant(), JSON.parse(value)));
-                    }
-                });
-            }
-            return participants;
-        });
+    async getAllParticipants(roomId) {
+        const particpantsInStringify = await this.redisClient.hGetAll(roomId);
+        const participants = [];
+        if (particpantsInStringify) {
+            Object.entries(particpantsInStringify).forEach(([key, value]) => {
+                if (key.includes(RedisKeyType.Participants)) {
+                    participants.push(Object.assign(new Participant_1.Participant(), JSON.parse(value)));
+                }
+            });
+        }
+        return participants;
     }
     // private getRediRoomModelForRoomId(roomId: string): RedisRoomModel {
     //     if (this.redisRoomModelHash.has(roomId)) {
@@ -142,7 +119,7 @@ export class RedisHandler {
     //     }
     // }
     updateRoomCleanupTimeOut(roomId) {
-        this.redisClient.expire(roomId, ServerHandler.getInstance().serverStartRequest.redisRoomDestoryTimeOutInSec);
+        this.redisClient.expire(roomId, ServerHandler_1.ServerHandler.getInstance().serverStartRequest.redisRoomDestoryTimeOutInSec);
     }
 }
-RedisHandler.redisHandler = new RedisHandler();
+exports.RedisHandler = RedisHandler;

package/lib/models/Event.js

@@ -1,8 +1,11 @@
-export var VaniEvent;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VaniEvent = void 0;
+var VaniEvent;
 (function (VaniEvent) {
     VaniEvent["OnNewMeetingStarted"] = "onNewMeetingStarted";
     VaniEvent["OnNewMeetingEnded"] = "onNewMeetingEnded";
     VaniEvent["OnUserJoined"] = "onUserJoined";
     VaniEvent["OnUserLeft"] = "onUserLeft";
     VaniEvent["OnServerStarted"] = "onServerStarted";
-})(VaniEvent || (VaniEvent = {}));
+})(VaniEvent = exports.VaniEvent || (exports.VaniEvent = {}));

package/lib/models/MessagePayload.js

@@ -1,29 +1,26 @@
-export var ChatMessageType;
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessagePayload = exports.ChatSendVia = exports.ChatMessageType = void 0;
+var ChatMessageType;
 (function (ChatMessageType) {
     ChatMessageType["Chat"] = "chat";
     ChatMessageType["File"] = "file";
     ChatMessageType["Info"] = "info";
-})(ChatMessageType || (ChatMessageType = {}));
-export var ChatSendVia;
+})(ChatMessageType = exports.ChatMessageType || (exports.ChatMessageType = {}));
+var ChatSendVia;
 (function (ChatSendVia) {
     ChatSendVia["WebSocket"] = "WebSocket";
     ChatSendVia["DataChannel"] = "DataChannel";
-})(ChatSendVia || (ChatSendVia = {}));
-export class MessagePayload {
-    constructor() {
-        this.to = "all";
-        this.extraData = {};
-        // public sender? :Participant;
-        this.shouldPresist = false;
-        this.time = new Date().getTime();
-        this.chatSendVia = ChatSendVia.WebSocket;
-        // constructor( _message : string)
-        // constructor( _message : string ,  _to: string )
-        // constructor(_message : string , _to: string = "all"  , _sender ? : Participant , _type : ChatMessageType | string = ChatMessageType.Chat) { 
-        //   this.message = _message;
-        //   this.to = _to;
-        //   this.sender = _sender;
-        //   this.type = _type;
-        // }   
-    }
+})(ChatSendVia = exports.ChatSendVia || (exports.ChatSendVia = {}));
+class MessagePayload {
+    message;
+    to = "all";
+    extraData = {};
+    type;
+    senderUserId;
+    // public sender? :Participant;
+    shouldPresist = false;
+    time = new Date().getTime();
+    chatSendVia = ChatSendVia.WebSocket;
 }
+exports.MessagePayload = MessagePayload;

package/lib/models/Participant.js

@@ -1,20 +1,19 @@
-export class Participant {
-    constructor() {
-        this.isAdmin = false;
-        this.isAudioBlockedByAdmin = false;
-        this.isVideoBlockedByAdmin = false;
-        this.isMessageBlockedByAdmin = false;
-        this.isWhiteboardBlockedByAdmin = true;
-        this.isScreenshareBlockedByAdmin = false;
-        this.isVideoEnable = false;
-        this.isAudioEnable = false;
-        this.isStartMeetingCalled = false;
-        this.isRecordingUser = false;
-        // constructor(_userId: string, _roomId: string, _userData: any = {}, _isAdmin: boolean = false) {
-        //     this.userId = _userId;
-        //     this.roomId = _roomId;
-        //     this.userData = _userData;
-        //     this.isAdmin = _isAdmin;
-        // }
-    }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Participant = void 0;
+class Participant {
+    userId;
+    userData;
+    isAdmin = false;
+    isAudioBlockedByAdmin = false;
+    isVideoBlockedByAdmin = false;
+    isMessageBlockedByAdmin = false;
+    isWhiteboardBlockedByAdmin = true;
+    isScreenshareBlockedByAdmin = false;
+    roomId;
+    isVideoEnable = false;
+    isAudioEnable = false;
+    isStartMeetingCalled = false;
+    isRecordingUser = false;
 }
+exports.Participant = Participant;

package/lib/models/WebSocketServerStartRequest.js

@@ -1,11 +1,13 @@
-export class WebSocketServerStartRequest {
-    constructor() {
-        this.port = 4010;
-        this.redisUrl = "redis://127.0.0.1:6378";
-        this.redisDBIndex = 5;
-        this.redisRoomDestoryTimeOutInSec = 1800;
-        this.rtcMinPort = 40000;
-        this.rtcMaxPort = 59999;
-        this.isTCPConnection = false;
-    }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WebSocketServerStartRequest = void 0;
+class WebSocketServerStartRequest {
+    port = 4010;
+    redisUrl = "redis://127.0.0.1:6378";
+    redisDBIndex = 5;
+    redisRoomDestoryTimeOutInSec = 1800;
+    rtcMinPort = 40000;
+    rtcMaxPort = 59999;
+    isTCPConnection = false;
 }
+exports.WebSocketServerStartRequest = WebSocketServerStartRequest;