just-another-http-api 1.2.4 → 1.2.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "just-another-http-api",
-  "version": "1.2.4",
+  "version": "1.2.6",
   "description": "A framework built on top of fastify aimed at removing the need for any network or server configuration. ",
   "homepage": "https://github.com/OllieEdge/just-another-http-api#readme",
   "repository": {

package/utils/WebsocketGroup.js

@@ -3,35 +3,57 @@ const { redis } = require ( 'eip-cloud-services' );
 
 class WebsocketGroup {
     
-    constructor ( groupName ) {
+    constructor ( groupName, destroy, messageReceivedHandler, connectionClosedHandler ) {
+        this.timeOfCreation = Date.now ();
         this.groupName = groupName;
+        this.destroy = destroy;
+        this.groupUuid = crypto.randomUUID ().substring ( 0, 8 );
         this.connections = new Map ();
+        this.messageReceivedHandler = messageReceivedHandler || ( async () => {} );
+        this.connectionClosedHandler = connectionClosedHandler;
     }
 
     async initialize () {
         try {
-            await redis.subscribe ( `${this.groupName}_broadcast`, this.handleMessage.bind ( this ) );
-            await redis.subscribe ( `${this.groupName}_messageReceived`, this.handleUserMessage.bind ( this ) );
+            await redis.subscribe ( `${this.groupName}_individualMessage`, this.#handleIndividualMessage.bind ( this ) );
+            await redis.subscribe ( `${this.groupName}_broadcast`, this.#broadcastMessageToClients.bind ( this ) );
+            await redis.subscribe ( `${this.groupName}_messageReceived`, this.#handleUserMessage.bind ( this ) );
         }
         catch ( error ){
-            console.log ( error );
+            console.error ( error );
         }
     }
     
-    handleMessage ( message ) {
-        this.broadcastMessageToClients ( message );
+    async #handleUserMessage ( jsonMessage ) {
+        const userMessage = JSON.parse ( jsonMessage );
+        await this.messageReceivedHandler ( userMessage );
     }
 
-    async handleUserMessage ( userMessage ) {
-        // don't really need to do anything with this message.
-    }
-
-    broadcastMessageToClients ( message ) {
+    #broadcastMessageToClients ( message ) {
         this.connections.forEach ( conn => {
-            conn.socket.send ( JSON.stringify ( message ) );
+            conn.socket.send ( typeof message === 'string' ? message : JSON.stringify ( message ) );
         } );
     }
 
+    #handleIndividualMessage ( individualMessage ) {
+        const { connectionId, message } = JSON.parse ( individualMessage );
+        if(this.connections.has(connectionId)) {
+            this.connections.get(connectionId).socket.send(message);
+        }
+    }
+
+    getConnections () {
+        return this.connections;
+    }
+
+    individualMessage ( connectionId, message ) {
+        redis.publish ( `${this.groupName}_individualMessage`, JSON.stringify ( { connectionId, message } ) );
+    }  
+
+    broadcastMessage ( message ) {
+        redis.publish ( `${this.groupName}_broadcast`, JSON.stringify ( message ) );
+    }
+
     addNewConnection ( connection, connectionId = crypto.randomUUID () ) {
         this.connections.set ( connectionId, connection );
 
@@ -46,15 +68,37 @@ class WebsocketGroup {
         
         connection.socket.on ( 'close', () => {
             this.connections.delete ( connectionId );
+            this.#clean(connectionId);
         } );
-    
+        
         connection.socket.on ( 'error', error => {
             console.error ( 'WebSocket error:', error );
             this.connections.delete ( connectionId );
+            this.#clean(connectionId);
         } );
 
         return { connectionId, groupName: this.groupName, connection };
     }
+
+    async #clean (connectionId) {
+
+        if ( this.connectionClosedHandler !== null && typeof this.connectionClosedHandler === 'function') {
+            try{
+                await this.connectionClosedHandler ( {groupName:this.groupName, connectionId} );
+            }
+            catch (error) {
+                console.error('Error in connectionClosedHandler:', error);
+            }
+        }
+
+        if ( this.connections.size === 0 ) {
+            this.connections.clear ();
+            await redis.unsubscribe ( `${this.groupName}_individualMessage` );
+            await redis.unsubscribe ( `${this.groupName}_broadcast` );
+            await redis.unsubscribe ( `${this.groupName}_messageReceived` );
+            this.destroy(this.groupName);
+        }
+    }
 }
   
 module.exports = WebsocketGroup;

package/utils/websocketHandler.js

@@ -2,13 +2,19 @@ const WebsocketGroup = require ( './WebsocketGroup' );
 
 const websocketGroups = {};
 
-const getGroupInstance = async ( groupName ) => {
-    if ( !websocketGroups[ groupName ] ) {
-        websocketGroups[ groupName ] = new WebsocketGroup ( groupName );
+const getGroupInstance = async ( groupName, messageReceivedHandler, connectionClosedHandler ) => {
+    if ( !websocketGroups[ groupName ] && messageReceivedHandler && connectionClosedHandler ) {
+        websocketGroups[ groupName ] = new WebsocketGroup ( groupName, removeGroupInstance, messageReceivedHandler, connectionClosedHandler );
         await websocketGroups[ groupName ].initialize ();
     }
     
-    return websocketGroups[ groupName ];
+    return websocketGroups[ groupName ] || null;
 };
 
+const removeGroupInstance = async groupName => {
+    if ( websocketGroups[ groupName ] ) {
+        delete websocketGroups[ groupName ];
+    }
+}
+
 module.exports = getGroupInstance;