configurapi-runner-ws 1.0.0

package/README.md

@@ -0,0 +1,5 @@
+# configurapi-runner-ws
+
+- Use `Event` for an incoming data.
+- User `Response` for a response data.
+- connectionId is available at `event.request.headers.connectionId`

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "configurapi-runner-ws",
+  "version": "1.0.0",
+  "description": "Websocket runner for configurapi.",
+  "bin": {
+    "configurapi-runner-ws": "src/app.mjs"
+  },
+  "main": "src/index.js",
+  "scripts": {
+    "test": "cd test && mocha ./"
+  },
+  "files": [
+    "src/*"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://gitlab.com/mappies/configurapi-runner-ws.git"
+  },
+  "keywords": [
+    "configurapi",
+    "websocket"
+  ],
+  "author": "Nithiwat Kampanya",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://gitlab.com/mappies/configurapi-runner-ws/issues"
+  },
+  "homepage": "https://gitlab.com/mappies/configurapi-runner-ws#readme",
+  "dependencies": {
+    "commander": "^14.0.1",
+    "configurapi": "^1.9.0",
+    "dotenv": "^17.2.3",
+    "one-liner": "^1.3.0",
+    "ws": "^8.18.3"
+  }
+}

package/src/app.mjs

@@ -0,0 +1,55 @@
+#!/usr/bin/env node
+
+import { Command } from 'commander';
+import App from './index.js'
+import oneliner from 'one-liner'
+import * as fs from 'fs';
+
+///////////////////////////////////
+// Utility functions
+///////////////////////////////////
+function format(prefix, str)
+{
+    let time = new Date().toISOString();
+    return `${time} ${prefix}: ${oneliner(str)}`;
+}
+function logTrace(s)
+{
+    console.log(format('Trace', s));
+}
+function logError(s)
+{
+    console.error(format('Error', s));
+}
+function logDebug(s)
+{
+    console.log(format('Debug', s));
+}
+
+///////////////////////////////////
+// Process arguments
+///////////////////////////////////
+const commander = new Command();
+commander.option('-p, --port [number]', 'Port number')
+         .option('--s-port [number]', 'Secure port number')
+         .option('-f, --file [path]', 'Path to the config file')
+         .option('--key [path]', 'Path to the private key file (.key)')
+         .option('--cert [path]', 'Path to the certificate file (.pem)')
+         .option('-k, --keep-alive [number]', 'The number of milliseconds of inactivity a server needs to wait. Default to 0 which disable the keep alive behavior')
+         .parse(process.argv);
+
+let port = commander.port ? commander.port : 9090;
+let sPort = commander.sPort ? commander.sPort : 9443;
+let configPath = commander.file ? commander.file : 'config.yaml';
+let keepAliveTimeout = commander.keepAlive ? commander.keepAlive : (process.env.CONFIGURAPI_RUNNER_SELF_KEEP_ALIVE || 0);
+let key = commander.key ? fs.readFileSync(commander.key) : undefined;
+let cert = commander.cert ? fs.readFileSync(commander.cert) : undefined;
+
+///////////////////////////////////
+// Start the API
+///////////////////////////////////
+let app = new App();
+app.on('error', (s) => {logError(s);});
+app.on('debug', (s) => {logDebug(s);});
+app.on('trace', (s) => {logTrace(s);});
+await app.run({port: port, configPath:configPath, keepAliveTimeout:keepAliveTimeout, key: key, cert: cert, sPort: sPort});

package/src/index.js

@@ -0,0 +1,134 @@
+require('dotenv').config();
+const http = require('http');
+const https = require('https');
+const WsAdapter = require('./wsAdapter');
+const events = require('events');
+const Configurapi = require('configurapi');
+const { WebSocketServer } = require('ws');
+const { randomUUID } = require("node:crypto");
+
+module.exports = class HttpRunner extends events.EventEmitter 
+{
+    constructor() 
+    {
+        super();
+
+        this.port = 8000;
+        this.sPort = 8443;
+        this.configPath = "config.yaml";
+        this.service = undefined;
+        this.keepAliveTimeout = 0;
+        this.key = undefined;
+        this.cert = undefined;
+    }
+
+    async run(options) 
+    {
+        this._handleOptions(options);
+
+        let config = Configurapi.Config.load(this.configPath);
+
+        this.service = new Configurapi.Service(config);
+        this.service.on("trace", (s) => this.emit("trace", s));
+        this.service.on("debug", (s) => this.emit("debug", s));
+        this.service.on("error", (s) => this.emit("error", s));
+        await this.service.init();
+
+        let httpServer;
+
+        if(this.cert && this.key && this.sPort)
+        {
+            httpServer = https.createServer({key: this.key, cert: this.cert});
+
+            httpServer.keepAliveTimeout = this.keepAliveTimeout;
+            httpServer.listen(this.sPort);
+
+            this.emit("trace", "Secure Server is listening...");
+        }
+        else
+        {
+            httpServer = http.createServer();
+
+            httpServer.keepAliveTimeout = this.keepAliveTimeout;
+            httpServer.listen(this.port);
+            
+            this.emit("trace", "Server is listening..."+this.port);
+        }
+
+        const wss = new WebSocketServer({ server: httpServer, path: "/ws" })
+
+        wss.on("connection", async (ws, req) => 
+        {
+            const connectionId = randomUUID();
+            ws.connectionId = connectionId;
+          
+            this.emit("trace", `[connect] ${connectionId}`);
+          
+            ws.on("message", async (data) => 
+            {
+                const incomingMessage = typeof data === "string" ? data : data.toString("utf8");
+
+                this._requestListener(ws, incomingMessage);
+            });
+          
+            ws.on("close", (code, reason) => 
+            {
+                const reasonMessage = reason && reason.length ? reason.toString("utf8") : "";
+
+                this.emit("trace", `[disconnect] ${connectionId} (${code}${reasonMessage ? ` - ${reasonMessage}` : ""})`);
+            });
+          
+            ws.on("error", (err) => 
+            {
+                // Note: 'error' will often be followed by 'close'
+                const message = err instanceof Error ? err.message : err;
+                this.emit("error", `${connectionId} - ${message}`);
+            });
+        });
+    }
+
+    _handleOptions(options) 
+    {
+        if (!options) return;
+
+        if ('port' in options) this.port = options.port;
+        if ('configPath' in options) this.configPath = options.configPath;
+        if ('keepAliveTimeout' in options) this.keepAliveTimeout = options.keepAliveTimeout;
+        if ('key' in options) this.key = options.key;
+        if ('cert' in options) this.cert = options.cert;
+        if ('sPort' in options) this.sPort = options.sPort;
+    }
+
+    async _requestListener(ws, incomingMessage) 
+    {
+        try 
+        {
+            let event = new Configurapi.Event(await WsAdapter.toRequest(ws, incomingMessage));
+
+            await this.service.process(event);
+            
+            await WsAdapter.write(ws, event.response);
+        }
+        catch (error) 
+        {
+            let response = new Configurapi.ErrorResponse(error, error instanceof SyntaxError ? 400 : 500);
+
+            try
+            {
+                await WsAdapter.write(ws, response);
+            }
+            catch(err)
+            {
+                try
+                {
+                    this.emit("error", JSON.stringify(err));
+                }
+                catch(errorFromListner)
+                {
+                    console.log(errorFromListner);
+                }
+            }
+        }
+    }
+
+};

package/src/wsAdapter.js

@@ -0,0 +1,48 @@
+const Configurapi = require('configurapi');
+const { WebSocket } = require('ws');
+
+module.exports = {
+    write: async function(ws, message)
+    {
+        // If the connection is disconnected, ignore.
+        if (ws.readyState !== WebSocket.OPEN) return;
+
+        await new Promise((resolve, reject)=>
+        {
+            try
+            {
+                ws.send(JSON.stringify(message), (err) => {
+                    if(err) 
+                    {
+                        return reject(err);
+                    }
+                    else
+                    {
+                        return resolve();
+                    }
+                });
+            }
+            catch(e)
+            {
+                reject(e)
+            }
+        });
+    },
+
+    toRequest: async function(ws, incomingMessage)
+    {        
+        let data = JSON.parse(incomingMessage);
+
+        let request = new Configurapi.Request();
+
+        request.method = '';
+        request.headers = data.headers || {};
+        request.name =  data.name || undefined;
+        request.query = data.query || {};
+        request.payload = data.payload || undefined;
+        
+        request.headers['connectionId'] = ws.connectionId;
+        
+        return request;
+    }
+};