systemlynx 1.8.2 → 1.8.3

package/systemlynx/Client/components/ClientModule.js

@@ -1,17 +1,21 @@
 "use strict";
 const ServiceRequestHandler = require("./ServiceRequestHandler");
 const SocketDispatcher = require("./SocketDispatcher");
+const getProtocol = (url) => url.match(/^(\w+):\/\//)[0];
+
 module.exports = function SystemLynxClientModule(
+  httpClient,
   { methods, namespace, route, connectionData, name },
-  { port, host },
+  { port, host, serviceUrl },
   reconnectService,
   systemContext
 ) {
   const events = {};
-  const ClientModule = this || {};
+  const ClientModule = {};
 
   ClientModule.__setConnection = (host, port, route, namespace) => {
     ClientModule.__connectionData = () => ({ route, host, port });
+
     SocketDispatcher.apply(ClientModule, [namespace, events, systemContext]);
   };
   ClientModule.__setConnection(host, port, route, namespace);
@@ -24,9 +28,11 @@ module.exports = function SystemLynxClientModule(
 
     if (typeof cb === "function") cb();
   };
-
+  const protocol = getProtocol(serviceUrl);
   methods.forEach(({ method, fn }) => {
     ClientModule[fn] = ServiceRequestHandler.apply(ClientModule, [
+      httpClient,
+      protocol,
       method,
       fn,
       reconnectService,

package/systemlynx/Client/components/ServiceRequestHandler.js

@@ -1,5 +1,4 @@
 "use strict";
-const HttpClient = require("../../HttpClient/HttpClient")();
 const isObject = (value) =>
   typeof value === "object" ? (!value ? false : !Array.isArray(value)) : false;
 
@@ -9,53 +8,58 @@ const makeQuery = (data) =>
     "?"
   );
 module.exports = function ServiceRequestHandler(
+  httpClient,
+  protocol,
   method,
   fn,
   reconnectService,
   reconnectModule
 ) {
   const ClientModule = this;
-
   return function sendRequest() {
     const __arguments = Array.from(arguments);
 
     const tryRequest = (cb, errCount = 0) => {
       const { route, port, host } = ClientModule.__connectionData();
-      const singleFileURL = `http://${host}:${port}/sf${route}/${fn}`;
-      const multiFileURL = `http://${host}:${port}/mf${route}/${fn}`;
-      const defaultURL = `http://${host}:${port}${route}/${fn}`;
+      const singleFileURL = `${protocol}${host}:${port}/sf${route}/${fn}`;
+      const multiFileURL = `${protocol}${host}:${port}/mf${route}/${fn}`;
+      const defaultURL = `${protocol}${host}:${port}${route}/${fn}`;
       const { file, files } = __arguments[0] || {};
       const url = file ? singleFileURL : files ? multiFileURL : defaultURL;
 
       if (url === defaultURL)
-        HttpClient.request({
-          url: `${url}${
-            method === "get" && isObject(__arguments[0]) ? makeQuery(__arguments[0]) : ""
-          }`,
-          method,
-          body: { __arguments },
-        })
+        httpClient
+          .request({
+            url: `${url}${
+              method === "get" && isObject(__arguments[0])
+                ? makeQuery(__arguments[0])
+                : ""
+            }`,
+            method,
+            body: { __arguments },
+          })
           .then((results) => cb(null, results))
           .catch((err) => ErrorHandler(err, errCount, cb));
       else
-        HttpClient.upload({
-          url,
-          method,
-          formData: { ...__arguments[0], __arguments },
-        })
+        httpClient
+          .upload({
+            url,
+            method,
+            formData: { ...__arguments[0], __arguments },
+          })
           .then((results) => cb(null, results))
           .catch((err) => ErrorHandler(err, errCount, cb));
     };
 
     const ErrorHandler = (err, errCount, cb) => {
-      if (err.SystemLynxServiceError) {
+      if (err.SystemLynxService) {
         cb(err);
       } else if (errCount <= 3) {
         console.log(err);
         errCount++;
         if (reconnectModule) reconnectModule(() => tryRequest(cb, errCount));
         else reconnectService(() => tryRequest(cb, errCount));
-      } else throw Error(`[SystemLynx][Service][Error]: Invalid route:${err}`);
+      } else console.error(Error(`[SystemLynx][Service][Error]: Invalid route:${err}`));
     };
 
     return new Promise((resolve, reject) =>

package/systemlynx/Client/components/SocketDispatcher.js

@@ -1,12 +1,12 @@
 "use strict";
 const io = require("socket.io-client");
-const SystemLynxDispatcher = require("../../Dispatcher/Dispatcher");
+const createDispatcher = require("../../Dispatcher/Dispatcher");
 
 module.exports = function SocketDispatcher(namespace, events = {}, systemContext) {
   const dispatcher =
     (this || {}).on && (this || {}).emit
       ? this
-      : SystemLynxDispatcher.apply(this, [events, systemContext]);
+      : createDispatcher.apply(this, [events, systemContext]);
   const socket = io.connect(namespace);
   socket.on("dispatch", (event) => dispatcher.emit(event.name, event.data, event));
   socket.on("disconnect", () => {

package/systemlynx/Client/components/loadConnectionData.js

@@ -1,10 +1,12 @@
-const HttpClient = require("../../HttpClient/HttpClient")();
-
-module.exports = function loadConnectionData(url, { limit = 10, wait = 150 } = {}) {
+module.exports = function loadConnectionData(
+  httpClient,
+  url,
+  { limit = 3, wait = 1000 } = {}
+) {
   const errors = [];
 
   return new Promise(function getData(resolve) {
-    HttpClient.request({ method: "GET", url }, (err, results) => {
+    httpClient.request({ method: "GET", url }, (err, results) => {
       if (err) {
         errors.push(err);
 

package/systemlynx/Client/tests/Client.test.js

@@ -1,14 +1,14 @@
 const { expect } = require("chai");
-const SystemLynxClient = require("../Client");
-const SystemLynxService = require("../../Service/Service");
-const Service = SystemLynxService();
+const createClient = require("../Client");
+const createService = require("../../Service/Service");
+const Service = createService();
 const port = 6757;
 const route = "service-test";
 const url = `http://localhost:${port}/${route}`;
 
-describe("SystemLynxClient()", () => {
+describe("createClient()", () => {
   it("should return a SystemLynx Client", () => {
-    const Client = SystemLynxClient();
+    const Client = createClient();
     expect(Client)
       .to.be.an("object")
       .that.has.property("loadService")
@@ -36,13 +36,21 @@ describe("Client", () => {
     );
 
     await Service.startService({ route, port });
-    const Client = SystemLynxClient();
+    const Client = createClient();
     const buAPI = await Client.loadService(url);
 
     expect(buAPI)
       .to.be.an("object")
-      .that.has.all.keys("emit", "on", "resetConnection", "disconnect", "orders")
+      .that.has.all.keys(
+        "emit",
+        "on",
+        "$clearEvent",
+        "resetConnection",
+        "disconnect",
+        "orders"
+      )
       .that.respondsTo("emit")
+      .that.respondsTo("$clearEvent")
       .that.respondsTo("on")
       .that.respondsTo("resetConnection")
       .that.respondsTo("disconnect");
@@ -52,6 +60,7 @@ describe("Client", () => {
       .that.has.all.keys(
         "emit",
         "on",
+        "$clearEvent",
         "disconnect",
         "__setConnection",
         "__connectionData",
@@ -61,8 +70,10 @@ describe("Client", () => {
         "noArgTest"
       )
       .that.respondsTo("emit")
+      .that.respondsTo("$clearEvent")
       .that.respondsTo("on")
       .that.respondsTo("emit")
+      .that.respondsTo("$clearEvent")
       .that.respondsTo("__setConnection")
       .that.respondsTo("__connectionData")
       .that.respondsTo("action1")
@@ -74,7 +85,7 @@ describe("Client", () => {
 
 describe("Service", () => {
   it("should be able to call methods from the frontend client to the backend Module", async () => {
-    const Client = SystemLynxClient();
+    const Client = createClient();
     const buAPI = await Client.loadService(url);
 
     const results = await buAPI.orders.action1({ code: 3 });
@@ -89,7 +100,7 @@ describe("Service", () => {
     });
   });
   it("should be able to send multiple arguments to the backend Module", async () => {
-    const Client = SystemLynxClient();
+    const Client = createClient();
     const buAPI = await Client.loadService(url);
     const arg1 = 4,
       arg2 = 5,
@@ -107,7 +118,7 @@ describe("Service", () => {
   });
 
   it("should be able to send no arguments and use a promise", async () => {
-    const Client = SystemLynxClient();
+    const Client = createClient();
     const buAPI = await Client.loadService(url);
     const results = await buAPI.orders.noArgTest();
 
@@ -122,13 +133,13 @@ describe("Service", () => {
     const route = "test-service";
     const port = "8980";
     const url = `http://localhost:${port}/${route}`;
-    const Service = SystemLynxService();
+    const Service = createService();
     const eventTester = Service.module("eventTester", function () {
       this.sendEvent = () => this.emit(eventName, { testPassed: true });
     });
     await Service.startService({ route, port });
 
-    const Client = SystemLynxClient();
+    const Client = createClient();
 
     const buAPI = await Client.loadService(url);
     setTimeout(() => eventTester.emit(eventName, { testPassed: true }), 500);
@@ -148,8 +159,8 @@ describe("Service", () => {
   });
 
   it("should be able to send REST http requests", async () => {
-    const Client = SystemLynxClient();
-    const Service = SystemLynxService();
+    const Client = createClient();
+    const Service = createService();
     const route = "rest-tester";
     const port = "8492";
     const url = `http://localhost:${port}/${route}`;
@@ -183,7 +194,7 @@ describe("Service", () => {
   });
 
   it("should be able to use 'useReturnValue' configuration option to enable synchronous return values from Module methods", async () => {
-    const service = SystemLynxService();
+    const service = createService();
     const route = "sync/test";
     const port = 4920;
     const host = "localhost";
@@ -199,7 +210,7 @@ describe("Service", () => {
       port,
       host,
     });
-    const Client = SystemLynxClient();
+    const Client = createClient();
     const { AsyncMath } = await Client.loadService(url);
     const results = await AsyncMath.max(10, 2);
     expect(results).to.equal(10);

package/systemlynx/Client/tests/SocketDispatcher.test.js

@@ -1,6 +1,7 @@
 const { expect } = require("chai");
 const SocketDispatcher = require("../components/SocketDispatcher");
-const { WebSocket, SocketServer } = require("../../ServerManager/components/WebSocketServer")();
+const { WebSocket, SocketServer } =
+  require("../../ServerManager/components/WebSocketServer")();
 
 const namespace = "test-namespace";
 const port = 4592;
@@ -14,9 +15,10 @@ describe("SocketDispatcher", () => {
   it("should return an EventDispatcher object with methods on and emit", async () => {
     expect(dispatcher)
       .to.be.an("object")
-      .that.has.all.keys("on", "emit", "disconnect")
+      .that.has.all.keys("on", "emit", "$clearEvent", "disconnect")
       .that.respondsTo("on")
       .that.respondsTo("emit")
+      .that.respondsTo("$clearEvent")
       .that.respondsTo("disconnect");
   });
   it("Should be able to emit and handle events", (done) => {
@@ -25,19 +27,25 @@ describe("SocketDispatcher", () => {
       done();
     });
     dispatcher.on("connect", () => console.log(`I'm all the way connected!`));
-    setTimeout(() => socket.emit("dispatch", { name: eventName, data: { testPassed: true } }), 500);
+    setTimeout(
+      () => socket.emit("dispatch", { name: eventName, data: { testPassed: true } }),
+      500
+    );
   });
 });
 
 describe("SocketDispatcher.apply()", () => {
   const eventName = "testing-event";
-  const dispatcher = SocketDispatcher.apply({}, [`http://localhost:${port}/${namespace}`]);
+  const dispatcher = SocketDispatcher.apply({}, [
+    `http://localhost:${port}/${namespace}`,
+  ]);
   it("should return an EventDispatcher object with methods on and emit", async () => {
     expect(dispatcher)
       .to.be.an("object")
-      .that.has.all.keys("on", "emit", "disconnect")
+      .that.has.all.keys("on", "emit", "$clearEvent", "disconnect")
       .that.respondsTo("on")
       .that.respondsTo("emit")
+      .that.respondsTo("$clearEvent")
       .that.respondsTo("disconnect");
   });
   it("Should be able to emit and handle events", (done) => {
@@ -49,6 +57,9 @@ describe("SocketDispatcher.apply()", () => {
       done();
     });
 
-    setTimeout(() => socket.emit("dispatch", { name: eventName, data: { testPassed: true } }), 500);
+    setTimeout(
+      () => socket.emit("dispatch", { name: eventName, data: { testPassed: true } }),
+      500
+    );
   });
 });

package/systemlynx/Dispatcher/Dispatcher.js

@@ -1,5 +1,5 @@
 "use strict";
-module.exports = function SystemLynxDispatcher(events = {}, systemContext) {
+module.exports = function createDispatcher(events = {}, systemContext) {
   const Dispatcher = this || {};
 
   Dispatcher.emit = (eventName, data, event) => {
@@ -24,5 +24,20 @@ module.exports = function SystemLynxDispatcher(events = {}, systemContext) {
     return Dispatcher;
   };
 
+  Dispatcher.$clearEvent = (eventName, fn) => {
+    if (!events[eventName]) return Dispatcher;
+
+    if (!fn) {
+      // Clear all listeners for the given event
+      delete events[eventName];
+    } else {
+      // Remove the listener function with the specified name from the event's listener array
+      events[eventName] = events[eventName].filter((callback) => {
+        return callback.name !== fn;
+      });
+    }
+
+    return Dispatcher;
+  };
   return Dispatcher;
 };

package/systemlynx/Dispatcher/Dispatcher.test.js

@@ -1,14 +1,15 @@
 const { expect } = require("chai");
 const Dispatcher = require("./Dispatcher");
 
-describe("SystemLynxDispatcher", () => {
+describe("createDispatcher", () => {
   const dispatcher = Dispatcher();
   it("should return an EventDispatcher object with methods on and emit", async () => {
     expect(dispatcher)
       .to.be.an("object")
-      .that.has.all.keys("on", "emit")
+      .that.has.all.keys("on", "emit", "$clearEvent")
       .that.respondsTo("on")
-      .that.respondsTo("emit");
+      .that.respondsTo("emit")
+      .that.respondsTo("$clearEvent");
   });
   it("Should be able to emit and handle events", (done) => {
     dispatcher.on("test", (data) => {

package/systemlynx/HttpClient/HttpClient.js

@@ -2,7 +2,7 @@
 const httpClient = require("request");
 const json = true;
 
-module.exports = function SystemLynxClient() {
+module.exports = function createClient() {
   const Client = this || {};
   Client.request = ({ method, url, body }, cb) => {
     const tryRequest = (callback) => {

package/systemlynx/LoadBalancer/tests/LoadBalancer.test.js

@@ -1,6 +1,6 @@
 const { expect } = require("chai");
 const LoadBalancer = require("../LoadBalancer")();
-const SystemLynxService = require("../../Service/Service");
+const createService = require("../../Service/Service");
 const HttpClient = require("../../HttpClient/HttpClient")();
 const lbPort = 5030;
 const route = "loadbalancer";
@@ -9,14 +9,33 @@ describe("LoadBalancer()", () => {
   it("should return a SystemLynx LoadBalancer", () => {
     expect(LoadBalancer)
       .to.be.an("object")
-      .that.has.all.keys("startService", "server", "WebSocket", "module", "clones")
+      .that.has.all.keys(
+        "startService",
+        "server",
+        "WebSocket",
+        "module",
+        "clones",
+        "before"
+      )
       .that.respondsTo("startService")
-      .that.respondsTo("module");
+      .that.respondsTo("module")
+      .that.respondsTo("before");
     expect(LoadBalancer.clones)
       .to.be.an("object")
-      .that.has.all.keys("on", "emit", "clones", "register", "dispatch", "assignDispatch")
+      .that.has.all.keys(
+        "on",
+        "emit",
+        "$clearEvent",
+        "before",
+        "clones",
+        "register",
+        "dispatch",
+        "assignDispatch"
+      )
       .that.respondsTo("emit")
+      .that.respondsTo("$clearEvent")
       .that.respondsTo("on")
+      .that.respondsTo("before")
       .that.respondsTo("register")
       .that.respondsTo("dispatch")
       .that.respondsTo("assignDispatch")
@@ -71,6 +90,8 @@ describe("LoadBalancer.clones (Module)", () => {
         "on",
         "emit",
         "$emit",
+        "$clearEvent",
+        "before",
         "register",
         "dispatch",
         "assignDispatch",
@@ -78,6 +99,8 @@ describe("LoadBalancer.clones (Module)", () => {
       )
       .that.respondsTo("on")
       .that.respondsTo("emit")
+      .that.respondsTo("$clearEvent")
+      .that.respondsTo("before")
       .that.respondsTo("$emit")
       .that.respondsTo("register")
       .that.respondsTo("dispatch")
@@ -87,7 +110,7 @@ describe("LoadBalancer.clones (Module)", () => {
   });
 
   it("should be able to use clones.register(connData, callback) method to host connection", async () => {
-    const Service = SystemLynxService();
+    const Service = createService();
     const { route, port, host } = test_service1;
     await Service.startService({ route, port, host });
     LoadBalancer.clones.register({ route, port, host }, () => {});
@@ -113,8 +136,8 @@ describe("LoadBalancer.clones (Module)", () => {
 
   it("should be able to manager the routing to multiple clones of the same Service", async () => {
     const { route, port1, port2, host } = test_service2;
-    const Clone1 = SystemLynxService();
-    const Clone2 = SystemLynxService();
+    const Clone1 = createService();
+    const Clone2 = createService();
     await Clone1.startService({ route, port: port1, host });
     await Clone2.startService({ route, port: port2, host });
     LoadBalancer.clones.register({ route, port: port1, host }, () => {});

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,48 @@ 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 (!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