vani-meeting-server 2.8.7 → 2.8.9

package/lib/ServerHandler.d.ts

@@ -26,6 +26,7 @@ export declare class ServerHandler {
     sfuHandler?: SFUHandler;
     isRedisConnected: boolean;
     testWebSocket?: WebSocket;
+    serverUUID: string;
     static instance: ServerHandler;
     static getInstance(): ServerHandler;
     constructor();

package/lib/ServerHandler.js

@@ -19,6 +19,7 @@ class ServerHandler {
     sfuHandler;
     isRedisConnected = true;
     testWebSocket = undefined;
+    serverUUID = (0, uuid_1.v4)();
     static instance = new ServerHandler();
     static getInstance() {
         return ServerHandler.instance;

package/lib/base/BaseSFUWebsocket.js

@@ -2,19 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseSFUWebsocket = void 0;
 const RedisHandler_1 = require("../lib/redis/RedisHandler");
+const ServerHandler_1 = require("../ServerHandler");
+const EventEmitterHandler_1 = require("../utility/EventEmitterHandler");
 class BaseSFUWebsocket {
     async redisBroadcastMessageToTopic(topic, data) {
-        RedisHandler_1.RedisHandler.getInstance().redisPublisher.publish(topic, JSON.stringify(data));
+        const stringifyData = JSON.stringify(data);
+        RedisHandler_1.RedisHandler.getInstance().redisPublisher.publish(topic, stringifyData);
+        EventEmitterHandler_1.EventEmitterHandler.getInstance().vaniEventEmitter.emit(topic, stringifyData);
     }
     //Utilility function
     prepareMutilSystemEvents(multiSystemEvent, roomId, data) {
-        return { type: multiSystemEvent, interfaceName: 'MultiSystemEventsBody', data: data, roomId: roomId };
+        return { type: multiSystemEvent, interfaceName: 'MultiSystemEventsBody', data: data, roomId: roomId, senderUUID: ServerHandler_1.ServerHandler.getInstance().serverUUID };
     }
     preapreClientMessageBody(shouldSendToSelf, senderParticipant, broadcastMessage) {
-        return { shouldSendToSelf, senderParticipant, broadcastMessage, interfaceName: 'ClientMessageBody' };
+        return { shouldSendToSelf, senderParticipant, broadcastMessage, interfaceName: 'ClientMessageBody', senderUUID: ServerHandler_1.ServerHandler.getInstance().serverUUID };
     }
     preapreWebSocketMessageBody(type, data) {
-        return { type, data, interfaceName: 'WebSocketMessageBody' };
+        return { type, data, interfaceName: 'WebSocketMessageBody', senderUUID: ServerHandler_1.ServerHandler.getInstance().serverUUID };
     }
 }
 exports.BaseSFUWebsocket = BaseSFUWebsocket;

package/lib/lib/redis/RedisHandler.d.ts

@@ -10,6 +10,7 @@ export declare enum RedisKeyType {
 export declare class RedisHandler {
     private static redisHandler?;
     private redisClient;
+    private localCacheDataStorage;
     redisPublisher: RedisClientType;
     redisSubscriber: RedisClientType;
     static getInstance(): RedisHandler;
@@ -18,6 +19,9 @@ export declare class RedisHandler {
     connectDB(): Promise<void>;
     cleanUp(): Promise<string | undefined>;
     cleanUpRoomId(roomId: string): Promise<void>;
+    private deleteKeyValueForLocalCache;
+    private getKeyValueForLocalCache;
+    private storeKeyValueForLocalCache;
     setIpForRoomId(roomId: string, ipAddress: string): Promise<void>;
     fetchIpsForRoomId(roomId: string): Promise<{
         ip: string;
@@ -35,4 +39,5 @@ export declare class RedisHandler {
     getAllRoomsId(): Promise<string[] | undefined>;
     private updateRoomCleanupTimeOut;
     releaseRedis: () => Promise<void>;
+    private cleanupLocalCache;
 }

package/lib/lib/redis/RedisHandler.js

@@ -19,7 +19,7 @@ var RedisKeyType;
 class RedisHandler {
     static redisHandler = new RedisHandler();
     redisClient;
-    // private redisRoomModelHash = new Map<string, RedisRoomModel>;
+    localCacheDataStorage = new Map;
     redisPublisher;
     redisSubscriber;
     static getInstance() {
@@ -98,17 +98,19 @@ class RedisHandler {
     async cleanUp() {
         try {
             if (ServerHandler_1.ServerHandler.getInstance().serverStartRequest.shouldCleanRedisOnStartUp) {
+                this.localCacheDataStorage = new Map;
                 return await this.redisClient.flushDb();
             }
         }
         catch (err) {
-            console.log("cleanUp", err);
+            // console.log("cleanUp", err)
         }
     }
     //Clean Room Id
     async cleanUpRoomId(roomId) {
         try {
             ServerHandler_1.ServerHandler.getInstance().serverStartRequest && ServerHandler_1.ServerHandler.getInstance().serverStartRequest.logLevel !== WebSocketServerStartRequest_1.LogLevel.None && console.log("Cleanup Room From Redis");
+            this.localCacheDataStorage.delete(roomId);
             await this.redisClient.del(roomId);
         }
         catch (err) {
@@ -116,6 +118,33 @@ class RedisHandler {
         }
     }
     //ip addresss
+    deleteKeyValueForLocalCache = (key, fieldOne) => {
+        if (!fieldOne) {
+            this.localCacheDataStorage.delete(key);
+        }
+        else {
+            if (this.localCacheDataStorage.has(key)) {
+                this.localCacheDataStorage.get(key)?.delete(fieldOne);
+            }
+        }
+    };
+    getKeyValueForLocalCache = (key, fieldOne) => {
+        const keyData = this.localCacheDataStorage.get(key);
+        if (keyData && keyData.has(fieldOne)) {
+            const data = keyData.get(fieldOne);
+            ServerHandler_1.ServerHandler.getInstance().serverStartRequest && ServerHandler_1.ServerHandler.getInstance().serverStartRequest.logLevel !== WebSocketServerStartRequest_1.LogLevel.None && console.log("CachedRedisResponse", data);
+            return data;
+        }
+        return undefined;
+    };
+    storeKeyValueForLocalCache = (key, fieldOne, fieldTwo) => {
+        let keyData = this.localCacheDataStorage.get(key);
+        if (!keyData) {
+            keyData = new Map();
+            this.localCacheDataStorage.set(key, keyData);
+        }
+        keyData.set(fieldOne, fieldTwo);
+    };
     async setIpForRoomId(roomId, ipAddress) {
         try {
             const oldIps = await this.fetchIpsForRoomId(roomId);
@@ -125,9 +154,10 @@ class RedisHandler {
                 return;
             }
             oldIps.push({ ip: ipAddress, port: ServerHandler_1.ServerHandler.getInstance().serverStartRequest.port });
-            await this.redisClient.hSet(roomId, RedisKeyType.IpAddress, JSON.stringify(oldIps));
+            this.storeKeyValueForLocalCache(roomId, RedisKeyType.IpAddress, JSON.stringify(oldIps));
+            /*await*/ this.redisClient.hSet(roomId, RedisKeyType.IpAddress, JSON.stringify(oldIps));
             this.updateRoomCleanupTimeOut(roomId);
-            await this.fetchIpsForRoomId(roomId);
+            // await this.fetchIpsForRoomId(roomId)
         }
         catch (err) {
             ServerHandler_1.ServerHandler.getInstance().serverStartRequest && ServerHandler_1.ServerHandler.getInstance().serverStartRequest.logLevel !== WebSocketServerStartRequest_1.LogLevel.None && console.log("setIpForRoomId", err);
@@ -138,7 +168,8 @@ class RedisHandler {
         //     this.fetchIpsForRoomId(roomId)
         // }, 10000)
         try {
-            const ipAddress = await this.redisClient.hGet(roomId, RedisKeyType.IpAddress);
+            const localCacheRedisData = this.getKeyValueForLocalCache(roomId, RedisKeyType.IpAddress);
+            const ipAddress = localCacheRedisData ? localCacheRedisData : await this.redisClient.hGet(roomId, RedisKeyType.IpAddress);
             if (ipAddress) {
                 ServerHandler_1.ServerHandler.getInstance().serverStartRequest && ServerHandler_1.ServerHandler.getInstance().serverStartRequest.logLevel !== WebSocketServerStartRequest_1.LogLevel.None && console.log("fetchIpsForRoomId", JSON.parse(ipAddress));
                 return JSON.parse(ipAddress);
@@ -157,7 +188,8 @@ class RedisHandler {
         try {
             const oldIps = await this.fetchIpsForRoomId(roomId);
             const newIps = oldIps.filter((eachOldIp) => !(eachOldIp.ip === ipAddress && eachOldIp.port === ServerHandler_1.ServerHandler.getInstance().serverStartRequest.port));
-            await this.redisClient.hSet(roomId, RedisKeyType.IpAddress, JSON.stringify(newIps));
+            this.storeKeyValueForLocalCache(roomId, RedisKeyType.IpAddress, JSON.stringify(newIps));
+            /*await*/ this.redisClient.hSet(roomId, RedisKeyType.IpAddress, JSON.stringify(newIps));
             this.updateRoomCleanupTimeOut(roomId);
         }
         catch (err) {
@@ -169,6 +201,7 @@ class RedisHandler {
         try {
             const messages = await this.fetchMessagesForRoom(roomId);
             messages.push(messagePayload);
+            // this.storeKeyValueForLocalCache(roomId, RedisKeyType.Messages, JSON.stringify(messages))
             await this.redisClient.hSet(roomId, RedisKeyType.Messages, JSON.stringify(messages));
             this.updateRoomCleanupTimeOut(roomId);
         }
@@ -178,7 +211,8 @@ class RedisHandler {
     }
     async fetchMessagesForRoom(roomId) {
         try {
-            const messages = await this.redisClient.hGet(roomId, RedisKeyType.Messages);
+            // const localCacheMessages = this.getKeyValueForLocalCache(roomId, RedisKeyType.Messages)
+            const messages = /*localCacheMessages ? localCacheMessages : */ await this.redisClient.hGet(roomId, RedisKeyType.Messages);
             if (messages) {
                 return JSON.parse(messages);
             }
@@ -194,7 +228,8 @@ class RedisHandler {
     //Meeting Time
     async storeMeetingTimeForRoom(roomId, time) {
         try {
-            await this.redisClient.hSet(roomId, RedisKeyType.MeetingTime, time ? time : new Date().getTime());
+            this.storeKeyValueForLocalCache(roomId, RedisKeyType.MeetingTime, time ? time : new Date().getTime());
+            /*await*/ this.redisClient.hSet(roomId, RedisKeyType.MeetingTime, time ? time : new Date().getTime());
             this.updateRoomCleanupTimeOut(roomId);
         }
         catch (err) {
@@ -204,7 +239,8 @@ class RedisHandler {
     }
     async fetchMeetingTimeForRoom(roomId) {
         try {
-            const meetingTime = await this.redisClient.hGet(roomId, RedisKeyType.MeetingTime);
+            const localCacheMessages = this.getKeyValueForLocalCache(roomId, RedisKeyType.MeetingTime);
+            const meetingTime = localCacheMessages ? localCacheMessages : await this.redisClient.hGet(roomId, RedisKeyType.MeetingTime);
             if (meetingTime) {
                 return +meetingTime;
             }
@@ -222,6 +258,7 @@ class RedisHandler {
         try {
             ServerHandler_1.ServerHandler.getInstance().serverStartRequest && ServerHandler_1.ServerHandler.getInstance().serverStartRequest.logLevel !== WebSocketServerStartRequest_1.LogLevel.None && console.log("removeParticipantForRoom", participant);
             const participantKey = RedisKeyType.Participants + ":" + participant.userId;
+            this.deleteKeyValueForLocalCache(roomId, participantKey);
             await this.redisClient.hDel(roomId, participantKey);
             // console.log("removeParticipantForRoom =====" , participantKey)
             // console.log(await this.getAllParticipants(roomId))
@@ -240,7 +277,8 @@ class RedisHandler {
             if (!participant.serverIpAddress) {
                 participant.serverIpAddress = await Constant_1.default.getPublicIp();
             }
-            await this.redisClient.hSet(roomId, participantKey, JSON.stringify(participant));
+            this.storeKeyValueForLocalCache(roomId, participantKey, JSON.stringify(participant));
+            /*await*/ this.redisClient.hSet(roomId, participantKey, JSON.stringify(participant));
             // console.log("addUpdateParticipantForRoom =====" , participantKey)
             // console.log(await this.getAllParticipants(roomId))
             // console.log("addUpdateParticipantForRoom +++++")
@@ -254,7 +292,8 @@ class RedisHandler {
     async getParticipantByUserId(roomId, userId) {
         try {
             const participantKey = RedisKeyType.Participants + ":" + userId;
-            const particpantString = await this.redisClient.hGet(roomId, participantKey);
+            const cahcedLocalData = this.getKeyValueForLocalCache(roomId, participantKey);
+            const particpantString = cahcedLocalData ? cahcedLocalData : await this.redisClient.hGet(roomId, participantKey);
             if (particpantString) {
                 return JSON.parse(particpantString);
             }
@@ -310,12 +349,26 @@ class RedisHandler {
         catch (err) {
             ServerHandler_1.ServerHandler.getInstance().serverStartRequest && ServerHandler_1.ServerHandler.getInstance().serverStartRequest.logLevel !== WebSocketServerStartRequest_1.LogLevel.None && console.log("updateRoomCleanupTimeOut", err);
         }
+        try {
+            this.cleanupLocalCache();
+        }
+        catch (e) {
+        }
     }
     releaseRedis = async () => {
         RedisHandler.redisHandler = undefined;
         this.redisClient.disconnect();
         this.redisPublisher.disconnect();
         this.redisSubscriber.disconnect();
+        this.cleanupLocalCache();
+    };
+    cleanupLocalCache = async () => {
+        try {
+            if (this.localCacheDataStorage && this.localCacheDataStorage.size > 1000) {
+                this.localCacheDataStorage = new Map();
+            }
+        }
+        catch (err) { }
     };
 }
 exports.RedisHandler = RedisHandler;

package/lib/models/Event.d.ts

@@ -5,6 +5,7 @@ import { Participant } from "./Participant";
 export declare enum VaniEvent {
     OnNewMeetingStarted = "onNewMeetingStarted",
     OnNewMeetingEnded = "onNewMeetingEnded",
+    OnLocalRedisMessage = "onLocalRedisMessage",
     OnNewMeetingStartedOnCurrentServer = "OnNewMeetingStartedOnCurrentServer",
     OnAllParticipantLeftOnServer = "OnAllParticipantLeftOnServer",
     OnUserJoined = "onUserJoined",
@@ -24,6 +25,7 @@ interface VaniConnectionEvents {
     [VaniEvent.OnNewMeetingEnded]: (roomId: string) => any;
     [VaniEvent.OnAllParticipantLeftOnServer]: (roomId: string) => any;
     [VaniEvent.OnUserJoined]: (participant: Participant) => any;
+    [VaniEvent.OnLocalRedisMessage]: (message: any) => any;
     [VaniEvent.OnUserLeft]: (participant: Participant) => any;
     [VaniEvent.OnServerStarted]: () => any;
     [VaniEvent.OnPlainTransportCreated]: (plainTransportCreatedCallback: PlainTransportCreatedCallback) => any;

package/lib/models/Event.js

@@ -5,6 +5,7 @@ var VaniEvent;
 (function (VaniEvent) {
     VaniEvent["OnNewMeetingStarted"] = "onNewMeetingStarted";
     VaniEvent["OnNewMeetingEnded"] = "onNewMeetingEnded";
+    VaniEvent["OnLocalRedisMessage"] = "onLocalRedisMessage";
     VaniEvent["OnNewMeetingStartedOnCurrentServer"] = "OnNewMeetingStartedOnCurrentServer";
     VaniEvent["OnAllParticipantLeftOnServer"] = "OnAllParticipantLeftOnServer";
     VaniEvent["OnUserJoined"] = "onUserJoined";

package/lib/sfu/SFUEachRoomHandler.d.ts

@@ -75,6 +75,7 @@ export declare class SFUEachRoomHandler extends BaseSFUWebsocket implements SFUE
     createPlainTransportAndConsumeProducer: (plainTransportPayload: PlainTransportPayload, producer: Producer) => Promise<void>;
     private consumeProducerForPlainTransport;
     private redisSubscribeToTopic;
+    private onLocalRedisMessage;
     private onRedisMessage;
     cleanUp(): Promise<void>;
 }

package/lib/sfu/SFUEachRoomHandler.js

@@ -489,12 +489,24 @@ class SFUEachRoomHandler extends BaseSFUWebsocket_1.BaseSFUWebsocket {
         const isListenerAlreadyExist = this.redisSubscribtionDetails.find((eachRedisSubscribtionDetails) => eachRedisSubscribtionDetails.topic === topic);
         if (!isListenerAlreadyExist) {
             const listener = (data) => {
-                this.onRedisMessage(JSON.parse(data));
+                // this.onRedisMessage(JSON.parse(data))
+                const parsedData = JSON.parse(data);
+                if (parsedData && parsedData.senderUUID && parsedData.senderUUID === ServerHandler_1.ServerHandler.getInstance().serverUUID) {
+                    return;
+                }
+                this.onRedisMessage(parsedData);
             };
             await RedisHandler_1.RedisHandler.getInstance().redisSubscriber.subscribe(topic, listener);
+            EventEmitterHandler_1.EventEmitterHandler.getInstance().vaniEventEmitter.on(topic, this.onLocalRedisMessage);
             this.redisSubscribtionDetails.push({ topic, listener });
         }
     }
+    onLocalRedisMessage = async (data) => {
+        const stringifiedData = data;
+        if (stringifiedData) {
+            this.onRedisMessage(JSON.parse(stringifiedData));
+        }
+    };
     onRedisMessage = async (data) => {
         if (data.interfaceName === 'MultiSystemEventsBody') {
             ServerHandler_1.ServerHandler.getInstance().serverStartRequest && ServerHandler_1.ServerHandler.getInstance().serverStartRequest.logLevel !== WebSocketServerStartRequest_1.LogLevel.None && console.log("MultiSystemEventsBody recived ", data);
@@ -523,6 +535,7 @@ class SFUEachRoomHandler extends BaseSFUWebsocket_1.BaseSFUWebsocket {
         RedisHandler_1.RedisHandler.getInstance().deleteIpForRoomId(this.roomId, await Constant_1.default.getPublicIp());
         this.redisSubscribtionDetails.forEach((eachRedisSubscribtionDetails) => {
             RedisHandler_1.RedisHandler.getInstance().redisSubscriber.unsubscribe(eachRedisSubscribtionDetails.topic, eachRedisSubscribtionDetails.listener);
+            EventEmitterHandler_1.EventEmitterHandler.getInstance().vaniEventEmitter.off(eachRedisSubscribtionDetails.topic, this.onLocalRedisMessage);
         });
         this.redisSubscribtionDetails = [];
         this.eachRoomMutliserverHandler?.cleanUp();

package/lib/utility/Constant.d.ts

@@ -1,6 +1,6 @@
-import { RtpCodecCapability } from "mediasoup/node/lib/rtpParametersTypes";
+import { RouterRtpCodecCapability } from "mediasoup/node/lib/rtpParametersTypes";
 import { ConnectionProtocol } from "../models/WebSocketServerStartRequest";
-export declare const mediaCodecs: RtpCodecCapability[];
+export declare const mediaCodecs: RouterRtpCodecCapability[];
 export declare function webrtcTransportConfiguration(perferProtocol: ConnectionProtocol): Promise<{
     listenIps: {
         ip: string;

package/lib/websocket/EachSocketConnectionHandler.d.ts

@@ -91,18 +91,21 @@ export interface WebSocketMessageBody {
     interfaceName: 'WebSocketMessageBody';
     type: WebSocketEvents;
     data?: any;
+    senderUUID?: any;
 }
 export interface MultiSystemEventsBody {
     interfaceName: 'MultiSystemEventsBody';
     type: MultiSystemEvents;
     data?: any;
     roomId: string;
+    senderUUID?: any;
 }
 export interface ClientMessageBody {
     interfaceName: 'ClientMessageBody';
     shouldSendToSelf: boolean;
     senderParticipant: Participant;
     broadcastMessage: WebSocketMessageBody;
+    senderUUID?: any;
 }
 export interface RediSubsciptionDetail {
     topic: string;
@@ -145,4 +148,5 @@ export declare class EachSocketConnectionHandler extends BaseSFUWebsocket {
     private onRedisMessage;
     private subscribeToRedisMessages;
     private redisSubscribeToTopic;
+    private onLocalRedisMessage;
 }

package/lib/websocket/EachSocketConnectionHandler.js

@@ -409,6 +409,7 @@ class EachSocketConnectionHandler extends BaseSFUWebsocket_1.BaseSFUWebsocket {
         }
         this.redisSubscribtionDetails.forEach((eachRedisSubscribtionDetails) => {
             RedisHandler_1.RedisHandler.getInstance().redisSubscriber.unsubscribe(eachRedisSubscribtionDetails.topic, eachRedisSubscribtionDetails.listener);
+            EventEmitterHandler_1.EventEmitterHandler.getInstance().vaniEventEmitter.off(eachRedisSubscribtionDetails.topic, this.onLocalRedisMessage);
         });
         this.redisSubscribtionDetails = [];
     }
@@ -463,20 +464,34 @@ class EachSocketConnectionHandler extends BaseSFUWebsocket_1.BaseSFUWebsocket {
         // }
     }
     async subscribeToRedisMessages() {
-        RedisHandler_1.RedisHandler.getInstance().redisSubscriber.on('message', (roomId, messageInString) => {
-            const message = JSON.parse(messageInString);
-            console.debug(message);
-        });
+        // EventEmitterHandler.getInstance().vaniEventEmitter.off(VaniEvent.OnLocalRedisMessage, this.onLocalRedisMessage)
+        // EventEmitterHandler.getInstance().vaniEventEmitter.on(VaniEvent.OnLocalRedisMessage, this.onLocalRedisMessage)
+        // RedisHandler.getInstance().redisSubscriber.on('message', (roomId, messageInString) => {
+        //     const message = JSON.parse(messageInString);
+        //     // console.debug(message)
+        // })
     }
     async redisSubscribeToTopic(topic) {
         const isListenerAlreadyExist = this.redisSubscribtionDetails.find((eachRedisSubscribtionDetails) => eachRedisSubscribtionDetails.topic === topic);
         if (!isListenerAlreadyExist) {
             const listener = (data) => {
-                this.onRedisMessage(JSON.parse(data));
+                const parsedData = JSON.parse(data);
+                if (parsedData && parsedData.senderUUID && parsedData.senderUUID === ServerHandler_1.ServerHandler.getInstance().serverUUID) {
+                    return;
+                }
+                this.onRedisMessage(parsedData);
             };
             RedisHandler_1.RedisHandler.getInstance().redisSubscriber.subscribe(topic, listener);
+            EventEmitterHandler_1.EventEmitterHandler.getInstance().vaniEventEmitter.on(topic, this.onLocalRedisMessage);
             this.redisSubscribtionDetails.push({ topic, listener });
         }
     }
+    onLocalRedisMessage = async (data) => {
+        const stringifiedData = data;
+        if (stringifiedData) {
+            ServerHandler_1.ServerHandler.getInstance().serverStartRequest && ServerHandler_1.ServerHandler.getInstance().serverStartRequest.logLevel !== WebSocketServerStartRequest_1.LogLevel.None && console.log("onLocalRedisMessage", stringifiedData);
+            this.onRedisMessage(JSON.parse(stringifiedData));
+        }
+    };
 }
 exports.EachSocketConnectionHandler = EachSocketConnectionHandler;

package/lib/websocket/WebSocketHandler.js

@@ -28,7 +28,7 @@ class WebSocketHandler {
     connect() {
         this.wss.on("connection", (socket, req) => {
             this.lastKnownWebSocketStatusIsActive = true;
-            console.log("On New Connection", req.url);
+            // console.log("On New Connection", req.url)
             if (req.url && req.url.includes("serverstatuscheck")) {
                 return;
             }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vani-meeting-server",
-  "version": "2.8.7",
+  "version": "2.8.9",
   "description": "Vani Meeting Server SDK",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -31,11 +31,11 @@
     "dotenv": "^16.0.2",
     "express": "^4.18.1",
     "helmet": "^6.0.0",
-    "mediasoup": "3.16.0",
+    "mediasoup": "3.19.13",
     "public-ip": "4.0.3",
     "typescript": "^5.6.2",
     "uuid": "^9.0.0",
-    "ws": "^8.18.2"
+    "ws": "^8.18.3"
   },
   "devDependencies": {
     "@types/uuid": "^8.3.4",