systemlynx 1.5.0 → 1.7.0

package/systemlynx/Client/Client.js

@@ -3,7 +3,7 @@ const loadConnectionData = require("./components/loadConnectionData");
 const SocketDispatcher = require("./components/SocketDispatcher");
 const ClientModule = require("./components/ClientModule");
 
-module.exports = function SystemLynxClient() {
+module.exports = function SystemLynxClient(systemContext) {
   const Client = {};
   Client.loadedServices = {};
 
@@ -12,29 +12,50 @@ module.exports = function SystemLynxClient() {
       return Client.loadedServices[url];
 
     const connData = await loadConnectionData(url, options);
-    const Service = SocketDispatcher(connData.namespace);
+    const Service = Client.createService(connData);
     Client.loadedServices[url] = Service;
-    if (options.name) Client[options.name] = Service;
+    await new Promise((resolve) => Service.on("connect", resolve));
+    return Service;
+  };
 
-    Service.resetConnection = async (cb) => {
-      const { modules, host, port, namespace } = await loadConnectionData(url, options);
+  Client.createService = (connData) => {
+    const events = {};
+    if (Client.loadedServices[connData.serviceUrl])
+      return Client.loadedServices[connData.serviceUrl];
 
-      SocketDispatcher.apply(Service, [namespace]);
+    const Service = SocketDispatcher(connData.namespace, events, systemContext);
 
-      modules.forEach(({ namespace, route, name }) =>
-        Service[name].__setConnection(host, port, route, namespace)
+    Client.loadedServices[connData.serviceUrl] = Service;
+
+    Service.resetConnection = async (cb) => {
+      const { modules, host, port, namespace } = await loadConnectionData(
+        connData.serviceUrl
       );
+      SocketDispatcher.apply(Service, [namespace, events, systemContext]);
 
+      modules.forEach(({ namespace, route, name }) => {
+        if (Service[name]) {
+          Service[name].__setConnection(host, port, route, namespace);
+          Service[name].emit("reconnect");
+        }
+      });
+
+      Service.emit("reconnect");
       if (typeof cb === "function") cb();
     };
 
     connData.modules.forEach(
-      (mod) => (Service[mod.name] = ClientModule(mod, connData, Service.resetConnection))
+      (mod) =>
+        (Service[mod.name] = ClientModule(
+          mod,
+          connData,
+          Service.resetConnection,
+          systemContext
+        ))
     );
 
     Service.on("disconnect", Service.resetConnection);
 
-    await new Promise((resolve) => Service.on("connect", resolve));
     return Service;
   };
 

package/systemlynx/Client/components/ClientModule.js

@@ -2,25 +2,35 @@
 const ServiceRequestHandler = require("./ServiceRequestHandler");
 const SocketDispatcher = require("./SocketDispatcher");
 module.exports = function SystemLynxClientModule(
-  { methods, namespace, route },
+  { methods, namespace, route, connectionData, name },
   { port, host },
-  resetConnection
+  reconnectService,
+  systemContext
 ) {
   const events = {};
   const ClientModule = this || {};
 
   ClientModule.__setConnection = (host, port, route, namespace) => {
     ClientModule.__connectionData = () => ({ route, host, port });
-    SocketDispatcher.apply(ClientModule, [namespace, events]);
+    SocketDispatcher.apply(ClientModule, [namespace, events, systemContext]);
   };
-
   ClientModule.__setConnection(host, port, route, namespace);
 
+  const reconnectModule = async (cb) => {
+    const url = connectionData.serviceUrl + `?modules=${name}`;
+    const { modules, port, host } = await loadConnectionData(url);
+    const { namespace, route } = modules[0];
+    ClientModule.__setConnection(host, port, route, namespace);
+
+    if (typeof cb === "function") cb();
+  };
+
   methods.forEach(({ method, fn }) => {
     ClientModule[fn] = ServiceRequestHandler.apply(ClientModule, [
       method,
       fn,
-      resetConnection,
+      reconnectService,
+      connectionData && reconnectModule,
     ]);
   });
 

package/systemlynx/Client/components/ServiceRequestHandler.js

@@ -8,7 +8,12 @@ const makeQuery = (data) =>
     (query, name) => (query += `${name}=${data[name]}&`),
     "?"
   );
-module.exports = function ServiceRequestHandler(method, fn, resetConnection) {
+module.exports = function ServiceRequestHandler(
+  method,
+  fn,
+  reconnectService,
+  reconnectModule
+) {
   const ClientModule = this;
 
   return function sendRequest() {
@@ -48,7 +53,8 @@ module.exports = function ServiceRequestHandler(method, fn, resetConnection) {
       } else if (errCount <= 3) {
         console.log(err);
         errCount++;
-        resetConnection(() => tryRequest(cb, errCount));
+        if (reconnectModule) reconnectModule(() => tryRequest(cb, errCount));
+        else reconnectService(() => tryRequest(cb, errCount));
       } else throw Error(`[SystemLynx][Service][Error]: Invalid route:${err}`);
     };
 

package/systemlynx/Client/components/SocketDispatcher.js

@@ -2,11 +2,11 @@
 const io = require("socket.io-client");
 const SystemLynxDispatcher = require("../../Dispatcher/Dispatcher");
 
-module.exports = function SocketDispatcher(namespace, events = {}) {
+module.exports = function SocketDispatcher(namespace, events = {}, systemContext) {
   const dispatcher =
     (this || {}).on && (this || {}).emit
       ? this
-      : SystemLynxDispatcher.apply(this, [events]);
+      : SystemLynxDispatcher.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

@@ -11,7 +11,9 @@ module.exports = function loadConnectionData(url, { limit = 10, wait = 150 } = {
         if (errors.length < limit)
           setTimeout(() => getData(resolve), errors.length * wait);
         else
-          throw `[SystemLynx][Client][Error]: Failed to load Service @${url} after ${errors.length} attempts.`;
+          console.error(
+            `[SystemLynx][Client][Error]: Failed to load Service @${url} after ${errors.length} attempts.`
+          );
       } else resolve(results);
     });
   });

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

@@ -1,14 +1,14 @@
 const { expect } = require("chai");
-const ClientFactory = require("../Client");
-const ServiceFactory = require("../../Service/Service");
-const Service = ServiceFactory();
+const SystemLynxClient = require("../Client");
+const SystemLynxService = require("../../Service/Service");
+const Service = SystemLynxService();
 const port = 6757;
 const route = "service-test";
 const url = `http://localhost:${port}/${route}`;
 
-describe("Client Factory", () => {
+describe("SystemLynxClient()", () => {
   it("should return a SystemLynx Client", () => {
-    const Client = ClientFactory();
+    const Client = SystemLynxClient();
     expect(Client)
       .to.be.an("object")
       .that.has.property("loadService")
@@ -36,7 +36,7 @@ describe("Client", () => {
     );
 
     await Service.startService({ route, port });
-    const Client = ClientFactory();
+    const Client = SystemLynxClient();
     const buAPI = await Client.loadService(url);
 
     expect(buAPI)
@@ -74,7 +74,7 @@ describe("Client", () => {
 
 describe("Service", () => {
   it("should be able to call methods from the frontend client to the backend Module", async () => {
-    const Client = ClientFactory();
+    const Client = SystemLynxClient();
     const buAPI = await Client.loadService(url);
 
     const results = await buAPI.orders.action1({ code: 3 });
@@ -89,7 +89,7 @@ describe("Service", () => {
     });
   });
   it("should be able to send multiple arguments to the backend Module", async () => {
-    const Client = ClientFactory();
+    const Client = SystemLynxClient();
     const buAPI = await Client.loadService(url);
     const arg1 = 4,
       arg2 = 5,
@@ -107,7 +107,7 @@ describe("Service", () => {
   });
 
   it("should be able to send no arguments and use a promise", async () => {
-    const Client = ClientFactory();
+    const Client = SystemLynxClient();
     const buAPI = await Client.loadService(url);
     const results = await buAPI.orders.noArgTest();
 
@@ -119,32 +119,37 @@ describe("Service", () => {
 
   it("should be able to receive events emitted from the backend Client", async () => {
     const eventName = "testing";
+    const route = "test-service";
+    const port = "8980";
+    const url = `http://localhost:${port}/${route}`;
+    const Service = SystemLynxService();
     const eventTester = Service.module("eventTester", function () {
-      const eventTester = this;
-      eventTester.sendEvent = () => eventTester.emit(eventName, { testPassed: true });
+      this.sendEvent = () => this.emit(eventName, { testPassed: true });
     });
+    await Service.startService({ route, port });
 
-    const Client = ClientFactory();
-    const buAPI = await Client.loadService(url);
+    const Client = SystemLynxClient();
 
-    buAPI.eventTester.on(eventName, (data, event) => {
-      console.log("Ladies and gentleman... mission accomplish!");
-      // console.log(data);
-      // console.log(event);
-      expect(data).to.deep.equal({ testPassed: true });
-      expect(event).to.be.an("object").that.has.all.keys("id", "name", "data", "type");
-      expect(event.name).to.equal("testing");
-      expect(event.data).to.deep.equal({ testPassed: true });
-      expect(event.id).to.be.a("string");
-      expect(event.type).to.equal("WebSocket");
+    const buAPI = await Client.loadService(url);
+    setTimeout(() => eventTester.emit(eventName, { testPassed: true }), 500);
+
+    await new Promise((resolve) => {
+      buAPI.eventTester.on(eventName, (data, event) => {
+        console.log("Ladies and gentleman... mission accomplish!");
+        expect(data).to.deep.equal({ testPassed: true });
+        expect(event).to.be.an("object").that.has.all.keys("id", "name", "data", "type");
+        expect(event.name).to.equal(eventName);
+        expect(event.data).to.deep.equal({ testPassed: true });
+        expect(event.id).to.be.a("string");
+        expect(event.type).to.equal("WebSocket");
+        resolve();
+      });
     });
-
-    eventTester.emit(eventName, { testPassed: true });
   });
 
   it("should be able to send REST http requests", async () => {
-    const Client = ClientFactory();
-    const Service = ServiceFactory();
+    const Client = SystemLynxClient();
+    const Service = SystemLynxService();
     const route = "rest-tester";
     const port = "8492";
     const url = `http://localhost:${port}/${route}`;
@@ -178,7 +183,7 @@ describe("Service", () => {
   });
 
   it("should be able to use 'useReturnValue' configuration option to enable synchronous return values from Module methods", async () => {
-    const service = ServiceFactory();
+    const service = SystemLynxService();
     const route = "sync/test";
     const port = 4920;
     const host = "localhost";
@@ -193,10 +198,8 @@ describe("Service", () => {
       route,
       port,
       host,
-      useReturnValues: true,
-      useCallbacks: false,
     });
-    const Client = ClientFactory();
+    const Client = SystemLynxClient();
     const { AsyncMath } = await Client.loadService(url);
     const results = await AsyncMath.max(10, 2);
     expect(results).to.equal(10);

package/systemlynx/Dispatcher/Dispatcher.js

@@ -1,19 +1,26 @@
 "use strict";
-module.exports = function SystemLynxDispatcher(events = {}) {
+module.exports = function SystemLynxDispatcher(events = {}, systemContext) {
   const Dispatcher = this || {};
 
   Dispatcher.emit = (eventName, data, event) => {
-    if (events[eventName]) events[eventName].forEach((callback) => callback(data, event));
+    if (events[eventName])
+      events[eventName].forEach((callback) =>
+        callback.apply(systemContext, [data, event])
+      );
     return Dispatcher;
   };
 
   Dispatcher.on = (eventName, callback) => {
-    if (typeof callback !== "function")
-      throw Error(
-        "[SystemLynx][EventHandler][Error]: EventHandler.on(eventName, callback) received invalid parameters"
-      );
+    if (typeof callback !== "function") return Dispatcher;
+
     if (!events[eventName]) events[eventName] = [];
-    events[eventName].push(callback);
+
+    if (callback.name) {
+      //if the function has a name and it already present don't add it
+      const i = events[eventName].findIndex((fn) => fn.name === callback.name);
+      if (i === -1) events[eventName].push(callback);
+      else events[eventName][i] = callback;
+    } else events[eventName].push(callback);
     return Dispatcher;
   };
 

package/systemlynx/HttpClient/HttpClient.test.js

@@ -1,13 +1,13 @@
 const { expect } = require("chai");
 const fs = require("fs");
-const HttpClientFactory = require("./HttpClient");
+const HttpSystemLynxClient = require("./HttpClient");
 const port = 4789;
 const testServerSetup = require("./test.server");
 //test server setup
 
-beforeAll(() => new Promise(resolve => testServerSetup(port, resolve)));
-describe("HttpClientFactory Test", () => {
-  const HttpClient = HttpClientFactory();
+beforeAll(() => new Promise((resolve) => testServerSetup(port, resolve)));
+describe("HttpSystemLynxClient Test", () => {
+  const HttpClient = HttpSystemLynxClient();
   const url = `http://localhost:${port}/test`;
   const singleFileUrl = `http://localhost:${port}/sf/test`;
   const multiFileUrl = `http://localhost:${port}/mf/test`;
@@ -26,7 +26,7 @@ describe("HttpClientFactory Test", () => {
         {
           method: "GET",
           url: "http://localhost:4789/test",
-          body: { getWithCallback: true }
+          body: { getWithCallback: true },
         },
         (err, results) => {
           if (err) reject(err);
@@ -35,88 +35,76 @@ describe("HttpClientFactory Test", () => {
       );
     });
 
-    expect(results)
-      .to.be.an("Object")
-      .that.deep.equal({
-        getWithCallback: true,
-        testPassed: true,
-        method: "GET"
-      });
+    expect(results).to.be.an("Object").that.deep.equal({
+      getWithCallback: true,
+      testPassed: true,
+      method: "GET",
+    });
   });
 
   it("should be able to make http requests using a promise", async () => {
     const results = await HttpClient.request({
       method: "GET",
       url,
-      body: { getWithPromise: true }
+      body: { getWithPromise: true },
     });
 
-    expect(results)
-      .to.be.an("Object")
-      .that.deep.equal({
-        getWithPromise: true,
-        testPassed: true,
-        method: "GET"
-      });
+    expect(results).to.be.an("Object").that.deep.equal({
+      getWithPromise: true,
+      testPassed: true,
+      method: "GET",
+    });
   });
 
   it("should be able to make PUT requests", async () => {
     const results = await HttpClient.request({
       method: "GET",
       url,
-      body: { getWithPromise: true }
+      body: { getWithPromise: true },
     });
 
-    expect(results)
-      .to.be.an("Object")
-      .that.deep.equal({
-        getWithPromise: true,
-        testPassed: true,
-        method: "GET"
-      });
+    expect(results).to.be.an("Object").that.deep.equal({
+      getWithPromise: true,
+      testPassed: true,
+      method: "GET",
+    });
   });
 
   it("should be able to make POST requests", async () => {
     const results = await HttpClient.request({
       method: "POST",
       url,
-      body: { test: true }
+      body: { test: true },
     });
 
-    expect(results)
-      .to.be.an("Object")
-      .that.deep.equal({
-        test: true,
-        testPassed: true,
-        method: "POST"
-      });
+    expect(results).to.be.an("Object").that.deep.equal({
+      test: true,
+      testPassed: true,
+      method: "POST",
+    });
   });
   it("should be able to make DELETE requests", async () => {
     const results = await HttpClient.request({
       method: "DELETE",
       url,
-      body: { test: true }
+      body: { test: true },
     });
 
-    expect(results)
-      .to.be.an("Object")
-      .that.deep.equal({
-        test: true,
-        testPassed: true,
-        method: "DELETE"
-      });
+    expect(results).to.be.an("Object").that.deep.equal({
+      test: true,
+      testPassed: true,
+      method: "DELETE",
+    });
   });
 
   it("should be able to upload a file", async () => {
     const file = fs.createReadStream(__dirname + "/test.file.json");
     const results = await HttpClient.upload({
       url: singleFileUrl,
-      formData: { file }
+      formData: { file },
     });
 
-    expect(results)
-      .to.be.an("Object")
-      .that.has.property("testPassed", true);
+    expect(results).to.be.an("Object").that.has.property("testPassed", true);
     expect(results)
       .to.have.property("file")
       .that.is.an("Object")
@@ -126,18 +114,14 @@ describe("HttpClientFactory Test", () => {
   it("should be able to upload multiple files", async () => {
     const files = [
       fs.createReadStream(__dirname + "/test.file.json"),
-      fs.createReadStream(__dirname + "/test.file.json")
+      fs.createReadStream(__dirname + "/test.file.json"),
     ];
     const multiUploadResponse = await HttpClient.upload({
       url: multiFileUrl,
-      formData: { files }
+      formData: { files },
     });
-    expect(multiUploadResponse)
-      .to.be.an("Object")
-      .that.has.property("testPassed", true);
-    expect(multiUploadResponse)
-      .to.have.property("files")
-      .that.is.an("Array");
+    expect(multiUploadResponse).to.be.an("Object").that.has.property("testPassed", true);
+    expect(multiUploadResponse).to.have.property("files").that.is.an("Array");
     expect(multiUploadResponse).to.have.property("fileUploadTest", true);
   });
 });

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

@@ -1,22 +1,15 @@
 const { expect } = require("chai");
 const LoadBalancer = require("../LoadBalancer")();
-const ServiceFactory = require("../../Service/Service");
+const SystemLynxService = require("../../Service/Service");
 const HttpClient = require("../../HttpClient/HttpClient")();
 const lbPort = 5030;
 const route = "loadbalancer";
 
-describe("LoadBalancerFactory", () => {
+describe("LoadBalancer()", () => {
   it("should return a SystemLynx LoadBalancer", () => {
     expect(LoadBalancer)
       .to.be.an("object")
-      .that.has.all.keys(
-        "startService",
-        "Server",
-        "WebSocket",
-        "defaultModule",
-        "module",
-        "clones"
-      )
+      .that.has.all.keys("startService", "Server", "WebSocket", "module", "clones")
       .that.respondsTo("startService")
       .that.respondsTo("Server")
       .that.respondsTo("WebSocket")
@@ -76,9 +69,18 @@ describe("LoadBalancer.clones (Module)", () => {
   it("should be a Service object with additional methods for LoadBalancing", () => {
     expect(LoadBalancer.clones)
       .to.be.an("Object")
-      .that.has.all.keys("on", "emit", "register", "dispatch", "assignDispatch", "clones")
+      .that.has.all.keys(
+        "on",
+        "emit",
+        "$emit",
+        "register",
+        "dispatch",
+        "assignDispatch",
+        "clones"
+      )
       .that.respondsTo("on")
       .that.respondsTo("emit")
+      .that.respondsTo("$emit")
       .that.respondsTo("register")
       .that.respondsTo("dispatch")
       .that.respondsTo("assignDispatch")
@@ -87,7 +89,7 @@ describe("LoadBalancer.clones (Module)", () => {
   });
 
   it("should be able to use clones.register(connData, callback) method to host connection", async () => {
-    const Service = ServiceFactory();
+    const Service = SystemLynxService();
     const { route, port, host } = test_service1;
     await Service.startService({ route, port, host });
     LoadBalancer.clones.register({ route, port, host }, () => {});
@@ -113,8 +115,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 = ServiceFactory();
-    const Clone2 = ServiceFactory();
+    const Clone1 = SystemLynxService();
+    const Clone2 = SystemLynxService();
     await Clone1.startService({ route, port: port1, host });
     await Clone2.startService({ route, port: port2, host });
     LoadBalancer.clones.register({ route, port: port1, host }, () => {});
@@ -128,7 +130,7 @@ describe("LoadBalancer.clones (Module)", () => {
     expect(connData2.serviceUrl).to.equal(`http://localhost:${port2}/${route}`);
   });
 
-  it("should be able to manage the route of multiple clones of multiple Services. aka Service Discovery", async () => {
+  it("should be able to manage the route of multiple clones of multiple services. aka Service Discovery", async () => {
     const route1 = test_service1.route;
     const route2 = test_service2.route;
     const url1 = `http://localhost:${lbPort}/${route1}`;

package/systemlynx/ServerManager/ServerManager.js

@@ -39,6 +39,7 @@ module.exports = function SystemLynxServerManager() {
     route =
       route.charAt(route.length - 1) === "/" ? route.substr(route.length - 1) : route;
     const serviceUrl = `http://${host}:${port}/${route}`;
+
     serverConfigurations = {
       ...serverConfigurations,
       ...options,
@@ -46,42 +47,55 @@ module.exports = function SystemLynxServerManager() {
       route,
       socketPort,
     };
+    const connectionData = {
+      modules,
+      host,
+      route: `/${route}`,
+      port,
+      serviceUrl,
+      namespace: `http://${host}:${socketPort}/${namespace}`,
+      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({
-        modules,
-        port,
-        host,
-        route: `/${route}`,
-        serviceUrl,
-        namespace: `http://${host}:${socketPort}/${namespace}`,
-        SystemLynxService: true,
+        ...connectionData,
+        modules: query.modules ? selectModules(query.modules.split(",")) : modules,
       });
     });
 
     return new Promise((resolve) =>
       server.listen(port, () => {
         console.log(`[SystemLynx][Service]: Listening on ${serviceUrl}`);
-        moduleQueue.forEach(({ name, object, reserved_methods }) =>
-          ServerManager.addModule(name, object, reserved_methods)
+        moduleQueue.forEach(({ name, Module, reserved_methods }) =>
+          ServerManager.addModule(name, Module, reserved_methods)
         );
         moduleQueue.length = 0;
-        resolve(ServerManager);
+        resolve(connectionData);
       })
     );
   };
 
-  ServerManager.addModule = (name, object, reserved_methods = []) => {
+  ServerManager.addModule = (name, Module, reserved_methods = []) => {
     const { host, route, serviceUrl, staticRouting, useService, useREST, socketPort } =
       serverConfigurations;
 
-    if (!serviceUrl) return moduleQueue.push({ name, object, reserved_methods });
-    const methods = parseMethods(object, ["on", "emit", ...reserved_methods], useREST);
+    if (!serviceUrl) return moduleQueue.push({ name, Module, reserved_methods });
+    const methods = parseMethods(Module, ["on", "emit", ...reserved_methods], useREST);
     const namespace = staticRouting ? name : shortId();
 
-    SocketEmitter.apply(object, [namespace, WebSocket]);
+    SocketEmitter.apply(Module, [namespace, WebSocket]);
 
     if (useService) {
       const path = staticRouting ? `${route}/${name}` : `${shortId()}/${shortId()}`;
@@ -92,7 +106,7 @@ module.exports = function SystemLynxServerManager() {
         name,
         methods,
       });
-      methods.forEach((method) => router.addService(object, path, method, name));
+      methods.forEach((method) => router.addService(Module, path, method, name));
     }
     if (useREST)
       methods.forEach((method) => {
@@ -101,7 +115,7 @@ module.exports = function SystemLynxServerManager() {
           case "put":
           case "post":
           case "delete":
-            router.addREST(object, `${route}/${name}`, method, name);
+            router.addREST(Module, `${route}/${name}`, method, name);
         }
       });
   };