systemlynx 1.8.2 → 1.9.3

package/systemlynx/ServerManager/ServerManager.js

@@ -1,12 +1,17 @@
 "use strict";
-const SystemLynxServer = require("./components/Server");
-const SystemLynxRouter = require("./components/Router");
+const createServer = require("./components/Server");
+const createRouter = require("./components/Router");
 const SocketEmitter = require("./components/SocketEmitter");
-const SystemLynxWebSocket = require("./components/WebSocketServer");
+const createWebSocket = require("./components/WebSocketServer");
 const parseMethods = require("./components/parseMethods");
 const shortId = require("shortid");
+const randomPort = () => parseInt(Math.random() * parseInt(Math.random() * 10000)) + 1023;
+const createSSLServer = (app, options) => {
+  const https = require("https");
+  return https.createServer(options, app);
+};
 
-module.exports = function SystemLynxServerManager() {
+module.exports = function createServerManager(customServer, customWebSocketServer) {
   let serverConfigurations = {
     route: null,
     port: null,
@@ -16,21 +21,27 @@ module.exports = function SystemLynxServerManager() {
     useREST: false,
     useService: true,
     staticRouting: false,
-    middleware: [],
+    ssl: { key: "", cert: "" },
+    validators: { $all: [] },
   };
-  const server = SystemLynxServer();
-  const router = SystemLynxRouter(server, () => serverConfigurations);
-  const { SocketServer, WebSocket } = SystemLynxWebSocket();
+  const server = createServer(customServer);
+  const router = createRouter(server, () => serverConfigurations);
+  const { SocketServer, WebSocket } = createWebSocket(customWebSocketServer);
   const moduleQueue = [];
   const modules = [];
 
   const ServerManager = { server, WebSocket };
 
   ServerManager.startService = (options) => {
-    let { route, host = "localhost", port, socketPort, staticRouting } = options;
+    let {
+      route,
+      host = "localhost",
+      port,
+      socketPort = randomPort(),
+      staticRouting,
+      ssl,
+    } = options;
 
-    socketPort =
-      socketPort || parseInt(Math.random() * parseInt(Math.random() * 10000)) + 1023;
     const namespace = staticRouting ? route : shortId();
     SocketServer.listen(socketPort);
     SocketEmitter.apply(ServerManager, [namespace, WebSocket]);
@@ -38,7 +49,8 @@ module.exports = function SystemLynxServerManager() {
     route = route.charAt(0) === "/" ? route.substr(1) : route;
     route =
       route.charAt(route.length - 1) === "/" ? route.substr(route.length - 1) : route;
-    const serviceUrl = `http://${host}:${port}/${route}`;
+    const protocol = ssl ? "https" : "http";
+    const serviceUrl = `${protocol}://${host}:${port}/${route}`;
 
     serverConfigurations = {
       ...serverConfigurations,
@@ -57,46 +69,44 @@ module.exports = function SystemLynxServerManager() {
       SystemLynxService: true,
     };
 
-    const selectModules = (moduleList) =>
-      moduleList.reduce(
-        (sum, moduleName) =>
-          sum.concat(modules.find(({ name }) => name === moduleName) || []),
-        []
-      );
-
     server.get(`/${route}`, (req, res) => {
       //The route will return connection data for the service including an array of
       //modules (objects) which contain instructions on how to make request to each object
-      const { query } = req;
-
-      res.json({
-        ...connectionData,
-        modules: query.modules ? selectModules(query.modules.split(",")) : modules,
-      });
+      res.json({ ...connectionData, modules });
     });
 
-    return new Promise((resolve) =>
-      server.listen(port, () => {
+    return new Promise((resolve) => {
+      const _server = ssl ? createSSLServer(server, ssl) : server;
+      _server.listen(port, () => {
         console.log(`[SystemLynx][Service]: Listening on ${serviceUrl}`);
         moduleQueue.forEach(({ name, Module, reserved_methods }) =>
           ServerManager.addModule(name, Module, reserved_methods)
         );
         moduleQueue.length = 0;
         resolve(connectionData);
-      })
-    );
+      });
+    });
   };
 
   ServerManager.addModule = (name, Module, reserved_methods = []) => {
-    const { host, route, serviceUrl, staticRouting, useService, useREST, socketPort } =
-      serverConfigurations;
+    const {
+      host,
+      route,
+      serviceUrl,
+      staticRouting,
+      useService,
+      useREST,
+      socketPort,
+      validators,
+    } = serverConfigurations;
 
     if (!serviceUrl) return moduleQueue.push({ name, Module, reserved_methods });
-    const methods = parseMethods(Module, ["on", "emit", ...reserved_methods], useREST);
+    const exclude_methods = ["on", "emit", "before", "$clearEvent", ...reserved_methods];
+    const methods = parseMethods(Module, exclude_methods, useREST);
     const namespace = staticRouting ? name : shortId();
 
     SocketEmitter.apply(Module, [namespace, WebSocket]);
-
+    const _validators = [...validators.$all, ...(validators[name] || [])];
     if (useService) {
       const path = staticRouting ? `${route}/${name}` : `${shortId()}/${shortId()}`;
 
@@ -106,19 +116,56 @@ module.exports = function SystemLynxServerManager() {
         name,
         methods,
       });
-      methods.forEach((method) => router.addService(Module, path, method, name));
+      methods.forEach((method) => {
+        const nsp = `${name}.${method.fn}`;
+        const customValidators = [..._validators, ...(validators[nsp] || [])];
+        router.addService(Module, path, method, name, customValidators);
+      });
     }
     if (useREST)
       methods.forEach((method) => {
+        const nsp = `${name}.${method.fn}`;
+        const customValidators = [..._validators, ...(validators[nsp] || [])];
         switch (method.fn) {
           case "get":
           case "put":
           case "post":
           case "delete":
-            router.addREST(Module, `${route}/${name}`, method, name);
+            router.addREST(Module, `${route}/${name}`, method, name, customValidators);
         }
       });
   };
+  ServerManager.addRouteHandler = (...args) => {
+    const name = typeof args[0] === "string" ? args.shift() : "$all";
+    args.forEach(async (middleware) => {
+      if (Array.isArray(middleware)) {
+        middleware.map(addMiddleware);
+      } else {
+        addMiddleware(middleware);
+      }
+    });
 
+    function addMiddleware(middleware) {
+      if (!serverConfigurations.validators[name])
+        serverConfigurations.validators[name] = [];
+      serverConfigurations.validators[name].push(async function (req, res, next) {
+        try {
+          await middleware(req, res, next);
+        } catch (error) {
+          res.sendError(error);
+        }
+      });
+    }
+  };
   return ServerManager;
 };
+
+//creating an ssl setup with openssl cli
+//1. `openssl genrsa -out key.pem` to generate a private key
+//2. create a certificate signing request using the key we just generated
+// `openssl req -new -key key.pem -out csr.pem`
+//3. Answer the prompts in the terminal
+//4. use the newly generate csr to generate a ssl certificate
+// openssl x509 -req -days 365 -in csr.pem -signkey key.pem -out cert.pem
+//(x509 is the standard to use for the certificate, days are the number of day the cert is valid)
+//5. csr.pem is no longer needed

package/systemlynx/ServerManager/components/Router.js

@@ -3,8 +3,8 @@ const isObject = (value) =>
 const isEmpty = (obj) => Object.getOwnPropertyNames(obj).length === 0;
 const isPromise = (p) => typeof p === "object" && typeof (p || {}).then === "function";
 
-module.exports = function SystemLynxRouter(server, config) {
-  const addService = (Module, route, { fn, method }, module_name) => {
+module.exports = function createRouter(server, config) {
+  const addService = (Module, route, { fn, method }, module_name, validators) => {
     server[method](
       [`/${route}/${fn}`, `/sf/${route}/${fn}`, `/mf/${route}/${fn}`],
       (req, res, next) => {
@@ -13,11 +13,13 @@ module.exports = function SystemLynxRouter(server, config) {
         req.Module = Module;
         next();
       },
-      routeHandler
+      setHelpers,
+      validators,
+      requestHandler
     );
   };
 
-  const addREST = (Module, route, { method }, module_name) => {
+  const addREST = (Module, route, { method }, module_name, validators) => {
     server[method](
       [`/${route}`],
       (req, res, next) => {
@@ -26,12 +28,15 @@ module.exports = function SystemLynxRouter(server, config) {
         req.Module = Module;
         next();
       },
-      routeHandler
+      setHelpers,
+      validators,
+      requestHandler
     );
   };
 
-  const routeHandler = (req, res) => {
-    const { query, file, files, body, fn, Module, module_name, method } = req;
+  const setHelpers = (req, res, next) => {
+    const { fn, module_name, query, file, files, body, method, Module } = req;
+
     const { serviceUrl } = config();
     const presets = { serviceUrl, module_name, fn };
     const unhandledMessage = `[SystemLynx]: handled error While calling ${module_name}.${fn}(...)`;
@@ -44,12 +49,12 @@ module.exports = function SystemLynxRouter(server, config) {
         ...error,
         status,
         message,
-        SystemLynxServiceError: true,
+        SystemLynxService: true,
       });
     };
 
     const sendResponse = (returnValue) => {
-      const status = (returnValue || {}).status || 200;
+      const status = (returnValue || {}).status >= 100 ? returnValue.status : 200;
       if (status < 400) {
         res.status(status).json({
           ...presets,
@@ -68,11 +73,25 @@ module.exports = function SystemLynxRouter(server, config) {
         status: 404,
       });
 
-    try {
+    const getArguments = () => {
       const args = body.__arguments || [];
       if (!isEmpty(query) && !args.length) args.push(query);
-      if (isObject(args[0]) && method === "PUT") args[0] = { ...args[0], file, files };
+      if (isObject(args[0]) && method === "PUT")
+        args[0] = { ...args[0], ...(file && { file }), ...(files && { files }) };
+      return args;
+    };
+    req.arguments = getArguments();
+    res.sendError = sendError;
+    res.sendResponse = sendResponse;
+    next();
+  };
+
+  const requestHandler = (req, res) => {
+    const { fn, Module } = req;
+    const { sendError, sendResponse } = res;
 
+    try {
+      const args = req.arguments;
       const results = Module[fn].apply({ ...Module, req, res }, args);
 
       if (isPromise(results)) {

package/systemlynx/ServerManager/components/Server.js

@@ -1,10 +1,11 @@
 //express server, socket.io server and middleware needed for SystemLynx basic functionality
-
-module.exports = function SystemLynxServer() {
+const clearFolder = require("./clearFolder");
+const clearTempFolder = clearFolder.bind({}, "./temp");
+module.exports = function createServer(customServer) {
   const cwd = process.cwd();
   //express server
   const express = require("express");
-  const server = express();
+  const server = customServer || express();
   //express middleware
   const multer = require("multer");
   //express file upload middleware setup
@@ -17,19 +18,21 @@ module.exports = function SystemLynxServer() {
       cb(null, `${shortId()}.${mime.getExtension(file.mimetype)}`),
   });
   //multi-file and single-file upload middleware functions
-  const sf = multer({ storage: storage }).single("file");
-  const mf = multer({ storage: storage }).array("files");
+  const sf = multer({ storage }).single("file");
+  const mf = multer({ storage }).array("files");
   //the sf and mf functions are used to a extract file from the req during a file upload
   //a property named file and files will be added to the req object respectively
   const singleFileUpload = (req, res, next) =>
     sf(req, res, (err) => {
-      if (err) res.json(errorResponseBuilder(err));
-      else next();
+      if (err) return res.json(err);
+      res.on("finish", clearTempFolder);
+      next();
     });
   const multiFileUpload = (req, res, next) =>
     mf(req, res, (err) => {
-      if (err) res.json(errorResponseBuilder(err));
-      else next();
+      if (err) return res.json(err);
+      res.on("finish", clearTempFolder);
+      next();
     });
 
   server.use("/sf", singleFileUpload);
@@ -37,15 +40,16 @@ module.exports = function SystemLynxServer() {
   server.use(express.static(cwd + "/public"));
   server.use(express.json({ limit: "5mb" }));
 
-  server.use((req, res, next) => {
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT ,DELETE");
-    res.setHeader(
-      "Access-Control-Allow-Headers",
-      "X-Requested-With,content-type, Authorization"
-    );
-    next();
-  });
+  !customServer &&
+    server.use((req, res, next) => {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT ,DELETE");
+      res.setHeader(
+        "Access-Control-Allow-Headers",
+        "X-Requested-With,content-type, Authorization"
+      );
+      next();
+    });
 
   return server;
 };

package/systemlynx/ServerManager/components/SocketEmitter.js

@@ -1,9 +1,9 @@
 "use strict";
-const SystemLynxDispatcher = require("../../Dispatcher/Dispatcher");
+const createDispatcher = require("../../Dispatcher/Dispatcher");
 const shortid = require("shortid");
 module.exports = function SocketEmitter(namespace, WebSocket) {
   const Emitter =
-    (this || {}).on && (this || {}).emit ? this : SystemLynxDispatcher.apply(this);
+    (this || {}).on && (this || {}).emit ? this : createDispatcher.apply(this);
 
   const socket = WebSocket.of(`/${namespace}`);
   //use $emit to emit events locally only

package/systemlynx/ServerManager/components/WebSocketServer.js

@@ -1,6 +1,6 @@
-module.exports = function SystemLynxWebWebSocket() {
+module.exports = function createWebSocket(server) {
   const express = require("express");
-  const SocketServer = require("http").Server(express());
+  const SocketServer = require("http").Server(server || express());
   const WebSocket = require("socket.io")(SocketServer);
 
   return { WebSocket, SocketServer };

package/systemlynx/ServerManager/components/clearFolder.js

@@ -0,0 +1,10 @@
+const fs = require("fs");
+const path = require("path");
+module.exports = function clearFolder(folder) {
+  fs.readdir(folder, (err, files) => {
+    if (err) return console.error(err);
+    files.forEach((file) => {
+      fs.unlink(path.join(folder, file), (err) => err && console.error(err));
+    });
+  });
+};

package/systemlynx/ServerManager/components/parseMethods.js

@@ -1,6 +1,6 @@
 const parseMethods = (obj, reserved_methods = [], useREST) => {
   const methods = [];
-  const REST_methods = ["get", "put", "post", "delete"];
+  const REST_methods = ["get", "put", "post", "delete", "options"];
   const props = Object.getOwnPropertyNames(obj);
 
   props.forEach((fn) => {

package/systemlynx/ServerManager/tests/ServerManager.test.js

@@ -1,21 +1,28 @@
 const { expect } = require("chai");
-const SystemLynxServerManager = require("../ServerManager");
+const createServerManager = require("../ServerManager");
 const request = require("request");
 
-describe("SystemLynxServerManager function", () => {
+describe("createServerManager function", () => {
   it("should return an ServerManager instance", () => {
-    const ServerManager = SystemLynxServerManager();
+    const ServerManager = createServerManager();
 
     expect(ServerManager)
       .to.be.an("Object")
-      .that.has.all.keys(["startService", "addModule", "server", "WebSocket"])
+      .that.has.all.keys([
+        "startService",
+        "addModule",
+        "addRouteHandler",
+        "server",
+        "WebSocket",
+      ])
       .that.respondsTo("startService")
-      .that.respondsTo("addModule");
+      .that.respondsTo("addModule")
+      .that.respondsTo("addRouteHandler");
   });
 });
 describe("ServerManager", () => {
   it("should be able use ServerManager.startService to start a server that will accept requests for Module Connection Data on the given route", async () => {
-    const ServerManager = SystemLynxServerManager();
+    const ServerManager = createServerManager();
     const route = "/testService";
     const port = 4400;
     const url = `http://localhost:${port}${route}`;
@@ -43,7 +50,7 @@ describe("ServerManager", () => {
   });
 
   it("should be able to use the ServerManager.addModule method to add data to the ServerManager instance that can be accessed via a GET request", async () => {
-    const ServerManager = SystemLynxServerManager();
+    const ServerManager = createServerManager();
     const route = "/testService";
     const port = 4634;
     const url = `http://localhost:${port}${route}`;
@@ -78,7 +85,7 @@ describe("ServerManager", () => {
   });
 
   it("should be able call ServerManager.addModule method before or after calling ServerManager.startService", async () => {
-    const ServerManager = SystemLynxServerManager();
+    const ServerManager = createServerManager();
     const route = "/testService";
     const port = 4500;
     const url = `http://localhost:${port}${route}`;
@@ -117,13 +124,13 @@ describe("ServerManager", () => {
 
 describe("ServerManager.startService(ServerConfiguration)", () => {
   it("should be able to use the useREST=true property to create a REST API route for any method with the name 'get', 'put', 'post' or 'delete'", async () => {
-    const ServerManager = SystemLynxServerManager();
+    const ServerManager = createServerManager();
     const route = "/testAPI";
     const port = 8372;
     const url = `http://localhost:${port}${route}`;
     const name = "testObject";
     const object = {
-      get: () => (null, { REST_TEST_PASSED: true }),
+      get: () => ({ REST_TEST_PASSED: true }),
       put: () => {},
       post: () => {},
       delete: () => {},
@@ -156,7 +163,7 @@ describe("ServerManager.startService(ServerConfiguration)", () => {
   });
 
   it("should be able to use the staticRouting=true property to create static routes to the Modules", async () => {
-    const ServerManager = SystemLynxServerManager();
+    const ServerManager = createServerManager();
     const route = "/testAPI";
     const port = 2233;
     const url = `http://localhost:${port}${route}`;
@@ -192,4 +199,110 @@ describe("ServerManager.startService(ServerConfiguration)", () => {
       status: 200,
     });
   });
+
+  it("should be able to use the ServerManager.addRouteHandler method to add additional route handling", async () => {
+    const ServerManager = createServerManager();
+    const route = "/testAPI";
+    const port = 5454;
+    const url = `http://localhost:${port}${route}`;
+    const name = "testObject";
+    const object = {
+      get: function () {
+        const { req } = this;
+        return {
+          SERVICE_TEST_PASSED: true,
+          $allHandlerAdded: req.$allHandlerAdded,
+          putHandlerAdded: req.putHandlerAdded,
+        };
+      },
+      put: function () {
+        const { req } = this;
+        return {
+          SERVICE_TEST_PASSED: true,
+          $allHandlerAdded: req.$allHandlerAdded,
+          putHandlerAdded: req.putHandlerAdded,
+        };
+      },
+      test: function () {
+        return { SERVICE_TEST_PASSED: false };
+      },
+    };
+
+    ServerManager.addRouteHandler((req, res, next) => {
+      req.$allHandlerAdded = true;
+      next();
+    });
+    ServerManager.addRouteHandler(`${name}.put`, (req, res, next) => {
+      req.putHandlerAdded = true;
+      next();
+    });
+    ServerManager.addRouteHandler(`${name}.test`, (req, res, next) => {
+      res.sendError({ status: 400, message: "tested passed" });
+    });
+    ServerManager.addModule(name, object);
+    await ServerManager.startService({
+      route,
+      port,
+      staticRouting: true,
+      useREST: true,
+    });
+
+    const results = await new Promise((resolve) => {
+      request({ url: `${url}/${name}/get`, json: true }, (err, res, body) => {
+        resolve(body);
+      });
+    });
+
+    expect(results).to.deep.equal({
+      returnValue: {
+        SERVICE_TEST_PASSED: true,
+        $allHandlerAdded: true,
+      },
+      fn: "get",
+      message: "[SystemLynx][response]: testObject.get(...) returned successfully",
+      module_name: "testObject",
+      serviceUrl: "http://localhost:5454/testAPI",
+      status: 200,
+    });
+
+    const result2 = await new Promise((resolve) => {
+      request(
+        { url: `${url}/${name}/put`, json: true, method: "PUT" },
+        (err, res, body) => {
+          resolve(body);
+        }
+      );
+    });
+
+    expect(result2).to.deep.equal({
+      returnValue: {
+        SERVICE_TEST_PASSED: true,
+        $allHandlerAdded: true,
+        putHandlerAdded: true,
+      },
+      fn: "put",
+      message: "[SystemLynx][response]: testObject.put(...) returned successfully",
+      module_name: "testObject",
+      serviceUrl: "http://localhost:5454/testAPI",
+      status: 200,
+    });
+
+    const result3 = await new Promise((resolve) => {
+      request(
+        { url: `${url}/${name}/test`, json: true, method: "PUT" },
+        (err, res, body) => {
+          resolve(body);
+        }
+      );
+    });
+
+    expect(result3).to.deep.equal({
+      message: "tested passed",
+      fn: "test",
+      module_name: "testObject",
+      serviceUrl: "http://localhost:5454/testAPI",
+      status: 400,
+      SystemLynxService: true,
+    });
+  });
 });

package/systemlynx/Service/Service.js

@@ -1,22 +1,41 @@
 "use strict";
-const SystemLynxServerManager = require("../ServerManager/ServerManager");
-const SystemLynxDispatcher = require("../Dispatcher/Dispatcher");
+const createServerManager = require("../ServerManager/ServerManager");
+const createDispatcher = require("../Dispatcher/Dispatcher");
 
-module.exports = function SystemLynxService(systemContext = {}) {
-  const ServerManager = SystemLynxServerManager();
-  const { startService, server, WebSocket } = ServerManager;
-  const Service = { startService, server, WebSocket };
+module.exports = function createService(
+  customServer,
+  customWebSocketServer,
+  systemContext = {}
+) {
+  const ServerManager = createServerManager(customServer, customWebSocketServer);
+  const { startService, addRouteHandler, server, WebSocket } = ServerManager;
+  const Service = { startService, server, WebSocket, before: addRouteHandler };
 
   Service.module = function (name, constructor, reserved_methods = []) {
     const exclude_methods = reserved_methods.concat(
       Object.getOwnPropertyNames(systemContext)
     );
-
+    const before = (...args) => {
+      if (typeof args[0] === "string") {
+        const arg1 = args.shift();
+        const fn = arg1 === "$all" ? "" : `.${arg1}`;
+        addRouteHandler(`${name}${fn}`, ...args);
+      } else {
+        addRouteHandler(`${name}`, ...args);
+      }
+    };
     if (typeof constructor === "object" && constructor instanceof Object) {
-      const Module = SystemLynxDispatcher.apply({ ...constructor, ...systemContext }, [
-        undefined,
-        systemContext,
-      ]);
+      const Module = createDispatcher.apply(
+        {
+          ...Object.getOwnPropertyNames(constructor).reduce((obj, fn) => {
+            if (typeof constructor[fn] === "function") obj[fn] = constructor[fn];
+            return obj;
+          }, {}),
+          ...systemContext,
+          before,
+        },
+        [undefined, systemContext]
+      );
       ServerManager.addModule(name, Module, exclude_methods);
       return Module;
     }
@@ -25,7 +44,7 @@ module.exports = function SystemLynxService(systemContext = {}) {
       if (constructor.constructor.name === "AsyncFunction")
         throw `[SystemLynx][Module][Error]: Module(name, constructor) function cannot receive an async function as the constructor`;
 
-      const Module = SystemLynxDispatcher.apply(systemContext, [
+      const Module = createDispatcher.apply({ ...systemContext, before }, [
         undefined,
         systemContext,
       ]);