just-another-http-api 1.2.1 → 1.2.3

package/api.js

@@ -32,6 +32,9 @@ async function createServer ( config ) {
         if ( config.cors ) {
             app.register ( require ( '@fastify/cors' ), config.cors );
         }
+        if ( config.websocket?.enabled ){
+            app.register ( require ( '@fastify/websocket' ), config.websocket?.options );
+        }
         await uploads.initialiseUploads ( app, config );
         await caching.initialiseCaching ( app, config );
         await auth.initialiseAuth ( app, config );
@@ -83,12 +86,13 @@ function registerEndpoint ( app, endpoint, globalConfig ) {
 
         const fastifyMethod = translateLegacyMethods ( method.toLowerCase () );
         const handler = endpoint.handlers[ method ];
-        const wrappedHandler = fastifyHandlerWrapper ( handler, endpoint.handlers.config, globalConfig );
+        const wrappedHandler = fastifyHandlerWrapper ( handler, endpoint.handlers.config, globalConfig, method );
 
         app[ fastifyMethod ] ( 
             endpoint.path, 
             { 
-                preHandler: preHandlers
+                preHandler: preHandlers,
+                websocket: handlerConfig?.websocket || false,
             },
             wrappedHandler 
         );
@@ -104,22 +108,34 @@ function translateLegacyMethods ( method ) {
     }
 }
 
-function fastifyHandlerWrapper ( handler, config, globalConfig ) {
-    return async ( req, reply ) => {
-        try {
-            let response = await caching.checkRequestCache ( app, req, reply, config, globalConfig );
+function fastifyHandlerWrapper ( handler, config, globalConfig, method ) {
+    if ( config?.[ method ]?.websocket ){
+        return handler;
+    }
+    else {
+        return async ( req, reply ) => {
+            try {
+                let response;
+                if ( globalConfig?.cache?.enabled ){
+                    const request = { method: req.method, query: JSON.parse ( JSON.stringify ( req.query ) ), routeOptions: req.routeOptions };
+                    response = await caching.checkRequestCache ( app, request, reply, config, globalConfig );
                        
-            if ( !response ){
-                response = await handler ( req );
-                await caching.setRequestCache ( app, req, response, config, globalConfig );
-            }
+                    if ( !response ){
+                        response = await handler ( req );
+                        await caching.setRequestCache ( app, request, response, config, globalConfig );
+                    }
+                }
+                else {
+                    response = await handler ( req );
+                }
 
-            handleResponse ( reply, response, req.method, req.routeOptions.url );
-        }
-        catch ( error ) {
-            handleError ( reply, error );
-        }
-    };
+                handleResponse ( reply, response, req.method, req.routeOptions.url );
+            }
+            catch ( error ) {
+                handleError ( reply, error );
+            }
+        };
+    }
 };
 
 function handleResponse ( reply, response, method, path ) {

package/config/default.js

@@ -0,0 +1,7 @@
+module.exports = {
+    redis: {
+        port: process.env.REDIS_PORT || 6379,
+        host: process.env.REDIS_HOST || 'localhost',
+        prefix: process.env.REDIS_PREFIX || 'api:'
+    }
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "just-another-http-api",
-  "version": "1.2.1",
+  "version": "1.2.3",
   "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": {
@@ -30,6 +30,7 @@
     "@fastify/cors": "^8.4.1",
     "@fastify/jwt": "^7.2.3",
     "@fastify/redis": "^6.1.1",
+    "@fastify/websocket": "^8.2.0",
     "abstract-cache": "^1.0.1",
     "abstract-cache-redis": "^2.0.0",
     "fastify": "^4.24.3",
@@ -42,4 +43,4 @@
     "eip-cloud-services": "^1.1.0",
     "mocha": "^10.2.0"
   }
-}
+}

package/utils/WebsocketGroup.js

@@ -0,0 +1,60 @@
+const crypto = require ( 'crypto' );
+const { redis } = require ( 'eip-cloud-services' );
+
+class WebsocketGroup {
+    
+    constructor ( groupName ) {
+        this.groupName = groupName;
+        this.connections = new Map ();
+    }
+
+    async initialize () {
+        try {
+            await redis.subscribe ( `${this.groupName}_broadcast`, this.handleMessage.bind ( this ) );
+            await redis.subscribe ( `${this.groupName}_messageReceived`, this.handleUserMessage.bind ( this ) );
+        }
+        catch ( error ){
+            console.log ( error );
+        }
+    }
+    
+    handleMessage ( message ) {
+        this.broadcastMessageToClients ( message );
+    }
+
+    async handleUserMessage ( userMessage ) {
+        // don't really need to do anything with this message.
+    }
+
+    broadcastMessageToClients ( message ) {
+        this.connections.forEach ( conn => {
+            conn.socket.send ( JSON.stringify ( message ) );
+        } );
+    }
+
+    addNewConnection ( connection, connectionId = crypto.randomUUID () ) {
+        this.connections.set ( connectionId, connection );
+
+        connection.socket.on ( 'message', async message => {
+            const userMessage = {
+                groupName: this.groupName,
+                connectionId,
+                message: message.toString ()
+            };
+            await redis.publish ( `${this.groupName}_messageReceived`, JSON.stringify ( userMessage ) );
+        } );
+        
+        connection.socket.on ( 'close', () => {
+            this.connections.delete ( connectionId );
+        } );
+    
+        connection.socket.on ( 'error', error => {
+            console.error ( 'WebSocket error:', error );
+            this.connections.delete ( connectionId );
+        } );
+
+        return { connectionId, groupName: this.groupName, connection };
+    }
+}
+  
+module.exports = WebsocketGroup;

package/utils/websocketHandler.js

@@ -0,0 +1,14 @@
+const WebsocketGroup = require ( './WebsocketGroup' );
+
+const websocketGroups = {};
+
+const getGroupInstance = async ( groupName ) => {
+    if ( !websocketGroups[ groupName ] ) {
+        websocketGroups[ groupName ] = new WebsocketGroup ( groupName );
+        await websocketGroups[ groupName ].initialize ();
+    }
+    
+    return websocketGroups[ groupName ];
+};
+
+module.exports = getGroupInstance;