systemlynx 1.8.2 → 1.9.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,19 +1,23 @@
-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) => {
+  return new Promise(function getData(resolve, reject) {
+    httpClient.request({ method: "GET", url }, (err, results) => {
       if (err) {
         errors.push(err);
 
         if (errors.length < limit)
-          setTimeout(() => getData(resolve), errors.length * wait);
-        else
+          setTimeout(() => getData(resolve, reject), errors.length * wait);
+        else {
           console.error(
             `[SystemLynx][Client][Error]: Failed to load Service @${url} after ${errors.length} attempts.`
           );
+          reject(err);
+        }
       } else resolve(results);
     });
   });

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 }, () => {});