Add cache service and HTTP server implementation

Author: Kushagra Singh Bisen

package-lock.json

@@ -1,26 +1,34 @@
 {
-    "name": "insert-name-of-project-here",
+    "name": "solid-stream-notifications-cache",
     "version": "1.0.0",
-    "description": "insert-description-of-project-here",
+    "description": "A cache service to store the notification stream from a solid server",
     "main": "dist/index.js",
     "scripts": {
         "build": "npx tsc",
         "start": "node dist/index.js",
         "test": "jest --coverage",
+        "lint:ts": "eslint . --ext ts --report-unused-disable-directives --max-warnings 0",
+        "lint:ts:fix": "eslint . --ext ts --report-unused-disable-directives --max-warnings 0 --fix",
         "test:watch": "jest --watch"
     },
     "keywords": [],
     "author": "Kushagra Singh Bisen",
     "license": "ISC",
     "devDependencies": {
+        "@types/bunyan": "^1.8.11",
         "@types/jest": "^29.2.4",
+        "eslint": "^8.57.0",
+        "eslint-plugin-jest": "^27.9.0",
+        "eslint-plugin-jsdoc": "^48.2.0",
         "jest": "^29.3.1",
         "supertest": "^6.3.3",
         "ts-jest": "^29.0.3",
         "typescript": "^4.9.4"
     },
     "dependencies": {
         "@types/redis": "^4.0.11",
+        "@typescript-eslint/parser": "^7.1.0",
+        "bunyan": "^1.8.15",
         "redis": "^4.6.13"
     }
 }

package.json

@@ -0,0 +1,36 @@
+import { CacheServiceHTTPServer } from "./server/CacheServiceHTTPServer";
+import * as bunyan from "bunyan";
+import * as fs from 'fs';
+const program = require('commander');
+const log_file = fs.createWriteStream('./logs/info.log', { flags: 'a' });
+
+const logger = bunyan.createLogger({
+    name: 'solid-stream-notifications-cache',
+    streams: [
+        {
+            level: 'info',
+            stream: log_file
+        }
+    ],
+    serializers: {
+        log: (log_data: any) => {
+            return {
+                ...log_data,
+            }
+        }
+    }
+})
+
+program
+    .version('1.0.0')
+    .description('Solid Stream Notifications Cache Service')
+    .name('solid-stream-notifications-cache')
+
+program
+    .command('cache-notifications')
+    .description('Starts the cache service for notifications from the solid server(s).')
+    .option('-p, --port <port>', 'The port where the HTTP server will listen.', '8085')
+    .option('-p --pod <pod>', 'The location of the Solid Pod', 'http://localhost:3000/aggregation_pod/')
+    .action((options: any) => {
+        new CacheServiceHTTPServer(options.port, options.pod, logger);
+    });

src/index.ts

@@ -0,0 +1,96 @@
+import * as http from 'http';
+import { CacheService } from '../service/CacheService';
+
+/**
+ * A class for the HTTP server that interacts with the cache service to handle requests.
+ * It stores the notifications from the solid server(s) and allows clients to retrieve them.
+ * @class CacheServiceHTTPServer
+ */
+export class CacheServiceHTTPServer {
+    private readonly cacheService: CacheService;
+    private readonly server: http.Server;
+    private pod_url: string;
+    /**
+     * Creates an instance of CacheServiceHTTPServer.
+     * @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 CacheServiceHTTPServer
+     */
+    constructor(port: number, pod_url: string, logger: any) {
+        this.cacheService = new CacheService();
+        this.pod_url = pod_url;
+        this.server = http.createServer(this.request_handler.bind(this));
+        this.setupServer(port);
+    }
+    /**
+     * Sets up the HTTP server where it listens on the specified port as well as connects to the cache service.
+     * @private
+     * @param {number} port - The port where the HTTP server will listen.
+     * @memberof CacheServiceHTTPServer
+     */
+    private async setupServer(port: number) {
+        await this.cacheService.connect();
+        this.server.listen(port, () => {
+            console.log(`Server listening on port ${port}`);
+        });
+    }
+    /**
+     * Handles the requests to the HTTP server.
+     * @private
+     * @param {http.IncomingMessage} request - The request object.
+     * @param {http.ServerResponse} response - The response object.
+     * @returns {Promise<void>} - A promise which responses nothing.
+     * @memberof CacheServiceHTTPServer
+     */
+    private async request_handler(request: http.IncomingMessage, response: http.ServerResponse) {
+        if (request.method === 'POST') {
+            await this.handleNotificationPostRequest(request, response);
+        }
+        else if (request.method === 'GET') {
+            await this.handleClientGetRequest(request, response);
+        }
+        else if (request.method === 'DELETE') {
+            await this.handleNotificationDeleteRequest(request, response);
+        }
+        else {
+            response.writeHead(405, 'Method Not Allowed');
+            response.end('Method Not Allowed');
+        }
+    }
+    /**
+     * Handles the POST requests to the HTTP server, which are notifications from the solid server(s).
+     * @private
+     * @param {http.IncomingMessage} request - The request object.
+     * @param {http.ServerResponse} response - The response object.
+     * @returns {Promise<void>}
+     * @memberof CacheServiceHTTPServer
+     */
+    private async handleNotificationPostRequest(request: http.IncomingMessage, response: http.ServerResponse): Promise<void> {
+
+    }
+    /**
+     * Handles the GET requests to the HTTP server, which are requests from the clients to retrieve the notifications.
+     * @private
+     * @param {http.IncomingMessage} request - The request object.
+     * @param {http.ServerResponse} response - The response object.
+     * @returns {Promise<void>}
+     * @memberof CacheServiceHTTPServer
+     */
+    private async handleClientGetRequest(request: http.IncomingMessage, response: http.ServerResponse): Promise<void> {
+
+    }
+    /**
+     * Handles the DELETE requests to the HTTP server.
+     * @private
+     * @param {http.IncomingMessage} request - The request object.
+     * @param {http.ServerResponse} response - The response object.
+     * @returns {Promise<void>} - A promise which responses nothing.
+     * @memberof CacheServiceHTTPServer
+     */
+    private async handleNotificationDeleteRequest(request: http.IncomingMessage, response: http.ServerResponse): Promise<void> {
+
+    }
+
+
+}

src/server/HTTPServer.test.ts renamed to src/server/CacheServiceHTTPServer.test.ts

@@ -1,18 +1,34 @@
 import { createClient } from "redis";
-
+/**
+ * A service for interacting with the Redis cache.
+ * @class CacheService
+ */
 export class CacheService {
     private client: any;
+    /**
+     * Creates an instance of CacheService.
+     * @memberof CacheService
+     */
     constructor() {
         this.client = createClient({});
         this.setupListeners();
     }
-
+    /**
+     * Connects to the Redis cache.
+     * @returns {Promise<boolean>} - A promise that resolves to true if the connection is successful.
+     * @memberof CacheService
+     */
     async connect() {
         await this.client.connect();
         return true;
 
     }
 
+    /**
+     * Sets up the listeners for the Redis client.
+     * @private
+     * @memberof CacheService
+     */
     private setupListeners() {
         this.client.on("connect", () => {
             return true;
@@ -24,19 +40,41 @@ export class CacheService {
         });
     }
 
+    /**
+     * Sets a value in the Redis cache.
+     * @param {string} key - The key to set.
+     * @param {any} value - The value to set.
+     * @returns {Promise<void>} - A promise that resolves when the value is set.
+     * @memberof CacheService
+     */
     async set(key: any, value: any) {
         await this.client.set(key, value);
     }
-
-    async get(key: any) {
+    /**
+     * Gets a value from the Redis cache.
+     * @param {string} key - The key to get.
+     * @returns {Promise<any>} - The value of the key in the cache returned as a promise.
+     * @memberof CacheService
+     */
+    async get(key: string) {
         return await this.client.get(key);
     }
-
+    /**
+     * Disconnects from the Redis cache.
+     * @returns {Promise<void>}
+     * @memberof CacheService
+     */
     async disconnect() {
         await this.client.quit();
     }
 
-    async delete(key: any) {
+    /**
+     * Deletes a key from the Redis cache.
+     * @param {string} key - The key to delete.
+     * @returns {Promise<void>}
+     * @memberof CacheService
+     */
+    async delete(key: string) {
         await this.client.del(key);
     }
 }