fixed linting issues

Author: Kushagra Singh Bisen

src/server/NotificationServiceHTTPServer.ts

@@ -24,7 +24,6 @@ export class NotificationServiceHTTPServer {
     /**
      * Creates an instance of NotificationServiceHTTPServer.
      * @param {number} port - The port where the HTTP server will listen.
-     * @param {string[]} pod_url - The location of the Solid Pod from which the notifications are retrieved.
      * @param {*} logger - The logger object.
      * @memberof NotificationServiceHTTPServer
      */
@@ -172,6 +171,10 @@ export class NotificationServiceHTTPServer {
         response.end('OK');
     }
 
+    /**
+     * Sends a message to the WebSocket server.
+     * @param {string} message - The message to send to the WebSocket server.
+     */
     public send_to_websocket_server(message: string) {
         if (this.connection.connected) {
             this.connection.sendUTF(message);
@@ -183,6 +186,10 @@ export class NotificationServiceHTTPServer {
         }
     }
 
+    /**
+     * Connects to the WebSocket server.
+     * @param {string} wss_url - The URL of the WebSocket server.
+     */
     public async connect_to_websocket_server(wss_url: string) {
         this.client.connect(wss_url, 'solid-stream-notifications-aggregator');
         this.client.on('connect', (connection: typeof websocket.connection) => {
@@ -195,6 +202,11 @@ export class NotificationServiceHTTPServer {
         });
     }
 
+    /**
+     * Checks if the resource location is a container.
+     * @param {string} resource_location - The location of the resource.
+     * @returns {boolean} - Returns true if the resource location is a container. Returns false if the resource location is not a container.
+     */
     public check_if_container(resource_location: string): boolean {
         if (resource_location.endsWith('/')) {
             return true;

src/server/WebSocketServerHandler.ts

@@ -1,22 +1,30 @@
 import * as WebSocket from 'websocket';
-import { CacheService } from '../service/CacheService';
 import { SubscribeNotification } from '../service/SubscribeNotification';
 import { extract_ldp_inbox } from '../utils/Util';
 
+/**
+ *
+ */
 export class WebSocketServerHandler {
 
     public websocket_server: any;
     public websocket_connections: Map<string, WebSocket[]>;
     public subscribe_notification: SubscribeNotification;
 
-
+    /**
+     * Creates an instance of WebSocketServerHandler.
+     * @param {WebSocket.server} websocket_server - The WebSocket server.
+     */
     constructor(websocket_server: WebSocket.server) {
         this.websocket_server = websocket_server;
         this.websocket_connections = new Map<string, WebSocket[]>();
         this.subscribe_notification = new SubscribeNotification();
     }
 
-    public async handle_communication(cache_service: CacheService) {
+    /**
+     * Handles the communication for the WebSocket server.
+     */
+    public async handle_communication() {
         console.log(`Handling the communication for the WebSocket server.`);
         this.websocket_server.on('connect', (connection: any) => {
             console.log(`Connection received from the client with address: ${connection.remoteAddress}`);
@@ -30,19 +38,19 @@ export class WebSocketServerHandler {
                     const ws_message = JSON.parse(message_utf8);
                     if (Object.keys(ws_message).includes('subscribe')) {
                         console.log(`Received a subscribe message from the client.`);
-                        let stream_to_subscribe = ws_message.subscribe;
-                        for (let stream of stream_to_subscribe) {
+                        const stream_to_subscribe = ws_message.subscribe;
+                        for (const stream of stream_to_subscribe) {
                             console.log(`Subscribed to the stream: ${stream}`);
                             this.set_connections(stream, connection);
                         }
                     }
                     else if (Object.keys(ws_message).includes('event')) {
                         console.log(`Received a new event message from the client.`);
-                        let connection = this.websocket_connections.get(ws_message.stream);
+                        const connection = this.websocket_connections.get(ws_message.stream);
                         if (connection !== undefined) {
                             for (const [stream, connections] of this.websocket_connections) {
                                 if (stream == ws_message.stream) {
-                                    for (let connection of connections) {
+                                    for (const connection of connections) {
                                         connection.send(JSON.stringify(ws_message));
                                     }
                                 }
@@ -64,9 +72,14 @@ export class WebSocketServerHandler {
         });
     }
 
+    /**
+     * Sets the connections for the WebSocket server's Map.
+     * @param {string} subscribed_stream - The subscribed stream.
+     * @param {WebSocket} connection - The WebSocket connection.
+     */
     public async set_connections(subscribed_stream: string, connection: WebSocket){
         if (!this.websocket_connections.has(subscribed_stream)) {   
-            let stream_inbox = await extract_ldp_inbox(subscribed_stream) as string;            
+            const stream_inbox = await extract_ldp_inbox(subscribed_stream) as string;            
             this.subscribe_notification.subscribe_inbox(stream_inbox);                     
             this.websocket_connections.set(subscribed_stream, [connection]);
         }

src/service/CacheService.ts

@@ -118,6 +118,11 @@ export class CacheService {
     }
 
 
+    /**
+     * Get the most recent key-value pair from the Redis cache.
+     * @param {string} ldes_stream - The LDES stream to get the most recent key-value pair from.    
+     * @returns {Promise<{ key: string, value: string }>} - A promise that resolves to an object containing the most recent key-value pair in the cache.
+     */
     async get_recent_key_value(ldes_stream: string): Promise<{ key: string, value: string }> {
         try {
             // example of a key is, stream:http://localhost:3000/aggregation_pod/aggregation/:1710250027636
@@ -143,11 +148,20 @@ export class CacheService {
 
 
 
+    /**
+     * Sets the time to live for a key in the Redis cache.
+     * @param {string} key - The key to set the time to live for.
+     * @param {number} time_to_live - The time to live in seconds.
+     * @returns {Promise<void>} - A promise that resolves when the time to live is set.
+     */
     async setTimeToLive(key: string, time_to_live: number) {
         // setting the time to live for the key in seconds.
         await this.client.expire(key, time_to_live);
     }
 
+    /**
+     * Clears the cache.
+     */
     async clearCache() {
         await this.client.flushall();
     }

src/service/SubscribeNotification.ts

@@ -47,6 +47,11 @@ export class SubscribeNotification {
         }
     }
 
+    /**
+     * Subscribes to the notification server for a specific inbox location.
+     * @param {string} inbox_location - The inbox location to subscribe to.
+     * @returns {(Promise<boolean | undefined>)} - Returns a promise with a boolean or undefined. If the subscription is successful, it returns true. If the subscription fails, it throws an error.
+     */
     public async subscribe_inbox(inbox_location:string): Promise<boolean | undefined> {
         const subscription_server = await extract_subscription_server(inbox_location);
         if (subscription_server === undefined) {