systemlynx 1.6.0 → 1.7.1

package/API.md

@@ -51,25 +51,84 @@ Welcome to the docs! Following is a list of the objects used and created when de
 ---
 
 <details>
-   <summary><b><a href="https://github.com/Odion100/SystemLynx/tasksjs2.0/API.md">ClientModule</a></b></summary>
+   <summary><b><a href="https://github.com/Odion100/SystemLynx/tasksjs2.0/API.md">ServerModule</a></b></summary>
     
-- [**[created_method]([args...] [,callback])**]() 
-- [**on(name, constructor [,options])**]() 
-- [**emit()**]()
+- [**...constructedMethods**]()
+- [**on(name, callback)**]() 
+- [**emit(name, data)**]()
 
 </details>
 
 <details>
-   <summary><b><a href="https://github.com/Odion100/SystemLynx/tasksjs2.0/API.md">module</a></b></summary>
+   <summary><b><a href="https://github.com/Odion100/SystemLynx/tasksjs2.0/API.md">ClientModule</a></b></summary>
     
-- [**[created_method]([args...] [,callback])**]() 
-- [**on(name, constructor [,options])**]() 
-- [**emit()**]()
+- [**...loadedMethods**]() 
+- [**on(name, callback)**]() 
+- [**emit(name, data)**]()
 
 </details>
 
 ---
 
+## Service
+
+In SystemLynx a **Service** is a class used to host objects that can be later loaded into a client application using a SystemLynx **Client.** Get a handle on a SystemLynx **Service** by de-structuring the SystemLynx export.
+
+```javascript
+const { Service } = require(“systemlynx”)
+```
+
+## Service.module(name, constructor)
+
+Use the `Service.module(name, constructor/object)` method to create a **ServerModule**, which is an object that is hosted by a **SystemLynx Service**. This will allows you to later load an instance of that object into a client application. The **Service.module(name, constructor)** method takes the (string) name assigned to the object as the first argument, and the object itself, or a constructor function, as the second argument, and will return the constructed **ServerModule.** See the examples below.
+
+```javascript
+const { Service } = require("systemlynx");
+
+const UsersConstructor = {
+  add:function(data) {
+   return { message: "You have successfully called Users.add(...)" };
+  }
+};
+constr OrdersConstructor = function () {
+  const Orders = this;
+
+  Orders.find = function (arg1, arg2) {
+    return { message: "You have successfully called the Orders.find(...)" };
+  };
+}
+
+const Users = Service.module("Users", UsersConstructor);
+
+const Orders = Service.module("Orders", OrdersConstructor);
+```
+
+## Service.startService(options)
+
+Use the `Service.startService(options)` method to setup hosting and routing for the **Service**. Calling this method will start an **ExpressJS** Server and a **Socket.io** WebSocket Server, and allow the modules created by the **Service** to be loaded into a client application. This method returns a promise that will resolve once the Express server is running.
+
+```javascript
+const { Service } = require("systemlynx");
+const route = "my-route/whatever";
+const port = 8100;
+const host = "localhost";
+
+const promise = Service.startService({ route, port, host });
+```
+
+Following is a list of options that can be passed to the **Service.startService(options)** method.
+
+| Name          |  Type   | O/R/C | Description                                                                                                                                            |
+| :------------ | :-----: | :---: | :----------------------------------------------------------------------------------------------------------------------------------------------------- |
+| route         | string  |   R   | The route from which the service can be loaded.                                                                                                        |
+| port          | number  |   R   | The port on which to start the Express server.                                                                                                         |
+| host          | string  |   O   | The host from which the **Service** can be reached.                                                                                                    |
+| socketPort    | string  |   R   | The port on which to start the Socket.io Websocket server. <br/><br/> Default value : **_random for digit number_**                                    |
+| useRest       | boolean |   O   | When this is true a RESTful route will be created for any **ServerModule** method which is named after a REST method <br/><br/> Default value: `false` |
+| useService    | boolean |   O   | The route from which the service can be loaded.                                                                                                        |
+| staticRouting | boolean |   O   | The route from which the service can be loaded.                                                                                                        |
+| middleware    | string  |   R   | The route from which the service can be loaded.                                                                                                        |
+
 ## App
 
 **App** combinds the both functionalites of SystemLynx Service and Client into one object, while also providing a module interface and lifecycle events. Access the App instance by deconcatanating from the object return when loading SystemLynx `require("systemlynx")`.

package/README.md

@@ -1,6 +1,6 @@
 # SystemLynx JS ![GitHub license](https://img.shields.io/badge/license-MIT-blue.svg) ![PRs Welcome](https://img.shields.io/badge/PRs-welcome-blue.svg) ![JS 100%](https://img.shields.io/badge/JavaScript-100%25-green)
 
-SystemLynx is a framework for developing modular web APIs in NodeJS. It's a wrapper on top of ExpressJS and Socket.io. With SystemLynx, instead of developing a server with endpoints, you can simply import objects from a server into a client application. Basically any objects hosted by a SystemLynx Service can be loaded and used by a SystemLynx Client.
+SystemLynx is a framework for developing modular web APIs in NodeJS. It's a wrapper on top of ExpressJS and Socket.io. With SystemLynx, instead of creating a server with many endpoints, you can simply create objects and load those objects from a server into a client application. Basically any objects hosted by a SystemLynx Service can be loaded and used by a SystemLynx Client.
 
 SystemLynx comes with the following objects that are used for web app development:
 
@@ -8,13 +8,13 @@ SystemLynx comes with the following objects that are used for web app developmen
 const { App, Service, Client, LoadBalancer } = require("systemlynx");
 ```
 
-Call `require("systemlynx")` and de-concatenate from the object it returns. The main abstractions used for client-to-server interactions are the following:
+Call `require("systemlynx")` and destructrue from the object it returns. The main abstractions used for client-to-server interactions are the following:
 
 - **Service** - Used to create and host objects that can be loaded and used by a SystemLynx Client.
 - **Client** - Used in a client application to load a **Service**, which contains all the objects added to the **Service**.
 - **App** - Provides a modular interface and lifecycle methods for asynchronously creating and loading **Services**.
 
-Find the full [API Documentation](https://github.com/Odion100/SystemLynx/blob/tasksjs2.0/API.md#tasksjs-api-documentation) here.
+Find the full [API Documentation](https://github.com/Odion100/SystemLynx/blob/master/API.md#tasksjs-api-documentation) here.
 
 ---
 
@@ -57,7 +57,7 @@ Service.module("Orders", function () {
   const Orders = this;
 
   Orders.find = async function (arg1, arg2) {
-    console.log(data);
+    console.log(arg1, arg2);
     return { message: "You have successfully called the Orders.find method" };
   };
 });
@@ -82,8 +82,8 @@ Service.module("Users", Users);
 Service.module("Orders", function () {
   const Orders = this;
 
-  Orders.find = function (arg1, arg2) {
-    console.log(data);
+  Orders.find = async function (arg1, arg2) {
+    console.log(arg1, arg2);
     return { message: "You have successfully called the Orders.find method" };
   };
 });
@@ -165,8 +165,8 @@ Service.module("Users", Users);
 Service.module("Orders", function () {
   const Orders = this;
 
-  Orders.find = function (arg1, arg2) {
-    console.log(data);
+  Orders.find = async function (arg1, arg2) {
+    console.log(arg1, arg2);
     return { message: "You have successfully called the Orders.find method" };
   };
 });

package/index.test.js

@@ -35,6 +35,7 @@ describe("SystemLynx Objects", () => {
         "module",
         "on",
         "emit",
+        "use",
         "startService",
         "loadService",
         "onLoad",
@@ -43,6 +44,7 @@ describe("SystemLynx Objects", () => {
       .that.respondsTo("module")
       .that.respondsTo("on")
       .that.respondsTo("emit")
+      .that.respondsTo("use")
       .that.respondsTo("startService")
       .that.respondsTo("loadService")
       .that.respondsTo("onLoad")
@@ -67,10 +69,8 @@ describe("SystemLynx Objects", () => {
   it("should return a SystemLynx LoadBalancer", () => {
     expect(LoadBalancer)
       .to.be.an("object")
-      .that.has.all.keys("startService", "Server", "WebSocket", "clones", "module")
+      .that.has.all.keys("startService", "server", "WebSocket", "clones", "module")
       .that.respondsTo("startService")
-      .that.respondsTo("Server")
-      .that.respondsTo("WebSocket")
       .that.respondsTo("module");
     expect(LoadBalancer.clones)
       .to.be.an("object")
@@ -87,18 +87,12 @@ describe("SystemLynx Objects", () => {
   it("should return a SystemLynx ServerManager instance", () => {
     expect(ServerManager)
       .to.be.an("Object")
-      .that.has.all.keys(["startService", "addModule", "Server", "WebSocket"])
+      .that.has.all.keys(["startService", "addModule", "server", "WebSocket"])
       .that.respondsTo("startService")
-      .that.respondsTo("addModule")
-      .that.respondsTo("Server")
-      .that.respondsTo("WebSocket");
+      .that.respondsTo("addModule");
   });
 
   it("should return a new instance of a Service", () => {
-    expect(Service)
-      .to.be.an("object")
-      .that.respondsTo("startService")
-      .that.respondsTo("Server")
-      .that.respondsTo("WebSocket");
+    expect(Service).to.be.an("object").that.respondsTo("startService");
   });
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "systemlynx",
-  "version": "1.6.0",
+  "version": "1.7.1",
   "description": "",
   "main": "index.js",
   "scripts": {
@@ -9,9 +9,7 @@
   },
   "dependencies": {
     "body-parser": "^1.18.3",
-    "chai-as-promised": "^7.1.1",
     "express": "^4.16.4",
-    "jest": "^24.9.0",
     "mime": "^2.4.0",
     "multer": "^1.4.2",
     "request": "^2.88.0",
@@ -30,7 +28,9 @@
   "homepage": "https://github.com/Odion100/SystemLynx#readme",
   "devDependencies": {
     "chai": "^4.3.4",
+    "chai-as-promised": "^7.1.1",
     "cz-conventional-changelog": "^3.3.0",
+    "jest": "^24.9.0",
     "mocha": "^6.2.0"
   },
   "config": {

package/systemlynx/App/App.js

@@ -3,14 +3,20 @@ const { isNode } = require("../../utils/ProcessChecker");
 const SystemLynxService = require("../Service/Service");
 const SystemLynxDispatcher = require("../Dispatcher/Dispatcher");
 const initializeApp = require("./components/initializeApp");
-const SystemContext = require("../utils/SystemContext");
+const SystemLynxContext = require("../utils/SystemContext");
 const System = require("../utils/System");
 
 module.exports = function SystemLynxApp() {
   const system = new System();
-  const systemContext = SystemContext(system);
+  const systemContext = SystemLynxContext(system);
   const App = SystemLynxDispatcher(undefined, systemContext);
-  setTimeout(() => initializeApp(system, App, systemContext), 0);
+  const plugins = [];
+  setTimeout(() => {
+    plugins.forEach((plugin) => {
+      if (typeof plugin === "function") plugin.apply({}, [App, system]);
+    });
+    initializeApp(system, App, systemContext);
+  }, 0);
 
   if (isNode) {
     system.Service = SystemLynxService(systemContext);
@@ -21,33 +27,25 @@ module.exports = function SystemLynxApp() {
     };
 
     App.module = (name, __constructor) => {
-      system.Modules.push({
-        name,
-        __constructor,
-      });
+      system.modules.push({ name, __constructor });
       return App;
     };
   }
 
   App.loadService = (name, url) => {
-    system.Services.push({
-      name,
-      url,
-      onLoad: null,
-      client: {},
-    });
+    system.services.push({ name, url, onLoad: null, client: {} });
     return App;
   };
 
   App.onLoad = (handler) => {
-    const service = system.Services[system.Services.length - 1];
+    const service = system.services[system.services.length - 1];
     service.onLoad = handler;
     return App;
   };
 
   App.config = (__constructor) => {
     if (typeof __constructor === "function")
-      system.configurations = { __constructor, module: SystemContext(system) };
+      system.configurations = { __constructor, module: SystemLynxContext(system) };
     else
       throw Error(
         "[SystemLynx][App][Error]: App.config(...) methods requires a constructor function as its first parameter."
@@ -55,5 +53,9 @@ module.exports = function SystemLynxApp() {
     return App;
   };
 
+  App.use = (plugin) => {
+    plugins.push(plugin);
+    return App;
+  };
   return App;
 };

package/systemlynx/App/components/loadModules.js

@@ -1,8 +1,10 @@
 module.exports = async function loadModules(system, App) {
-  system.Modules.forEach(
+  system.modules.forEach(
     (mod) => (mod.module = system.Service.module(mod.name, mod.__constructor))
   );
 
-  if (system.routing) await system.Service.startService(system.routing);
+  if (system.routing) {
+    system.connectionData = await system.Service.startService(system.routing);
+  }
   App.emit("ready", system);
 };

package/systemlynx/App/components/loadServices.js

@@ -1,10 +1,10 @@
 const SystemLynxClient = require("../../Client/Client");
 
-module.exports = ({ Services }, App, systemContext) => {
+module.exports = ({ services }, App, systemContext) => {
   const Client = SystemLynxClient(systemContext);
 
   return Promise.all(
-    Services.map((serviceData) => {
+    services.map((serviceData) => {
       const { url, limit, wait, name, onLoad } = serviceData;
       return new Promise((resolve) => {
         Client.loadService(url, { limit, wait })

package/systemlynx/App/tests/App.test.js

@@ -1,11 +1,11 @@
 const { expect } = require("chai");
-const AppFactory = require("../App");
+const SystemLynxApp = require("../App");
 const HttpClient = require("../../HttpClient/HttpClient")();
-const ServiceFactory = require("../../Service/Service");
+const SystemLynxService = require("../../Service/Service");
 
-describe("App Factory", () => {
+describe("SystemLynxApp()", () => {
   it("should return a SystemLynx App", () => {
-    const App = AppFactory();
+    const App = SystemLynxApp();
 
     expect(App)
       .to.be.an("object")
@@ -13,6 +13,7 @@ describe("App Factory", () => {
         "module",
         "on",
         "emit",
+        "use",
         "startService",
         "loadService",
         "onLoad",
@@ -21,6 +22,7 @@ describe("App Factory", () => {
       .that.respondsTo("module")
       .that.respondsTo("on")
       .that.respondsTo("emit")
+      .that.respondsTo("use")
       .that.respondsTo("startService")
       .that.respondsTo("loadService")
       .that.respondsTo("onLoad")
@@ -29,7 +31,7 @@ describe("App Factory", () => {
 });
 describe("App: Loading Services", () => {
   it("should be able to use App.loadService(str_url) to load as hosted Service", async () => {
-    const Service = ServiceFactory();
+    const Service = SystemLynxService();
     const route = "test-service";
     const port = "8503";
 
@@ -41,13 +43,13 @@ describe("App: Loading Services", () => {
     await Service.startService({ route, port });
 
     await new Promise((resolve) => {
-      const App = AppFactory();
+      const App = SystemLynxApp();
       App.loadService("test", `http://localhost:${port}/${route}`).on(
         "ready",
         (system) => {
-          expect(system.Services[0]).to.be.an("object");
+          expect(system.services[0]).to.be.an("object");
 
-          expect(system.Services[0].client)
+          expect(system.services[0].client)
             .to.be.an("object")
             .that.has.all.keys("emit", "on", "resetConnection", "disconnect", "mod")
             .that.respondsTo("emit")
@@ -61,7 +63,7 @@ describe("App: Loading Services", () => {
   });
 
   it("should be able to use App.loadService(...).onLoad(handler) to fire a callback when the Service connects", async () => {
-    const Service = ServiceFactory();
+    const Service = SystemLynxService();
     const route = "test-service";
     const port = "8422";
     const url = `http://localhost:${port}/${route}`;
@@ -74,7 +76,7 @@ describe("App: Loading Services", () => {
     await Service.startService({ route, port });
 
     await new Promise((resolve) => {
-      const App = AppFactory();
+      const App = SystemLynxApp();
       App.loadService("test", url).onLoad((test) => {
         expect(test)
           .to.be.an("object")
@@ -89,7 +91,7 @@ describe("App: Loading Services", () => {
   });
 
   it('should use App.on("service_loaded[:name]", callback) to fire when a Service has loaded', async () => {
-    const Service = ServiceFactory();
+    const Service = SystemLynxService();
     const route = "test-service";
     const port = "8423";
     const url = `http://localhost:${port}/${route}`;
@@ -101,7 +103,7 @@ describe("App: Loading Services", () => {
     await Service.startService({ route, port });
 
     await new Promise((resolve) => {
-      const App = AppFactory();
+      const App = SystemLynxApp();
       App.loadService("test", url)
         .on("service_loaded", (test) => {
           expect(test)
@@ -124,7 +126,7 @@ describe("App: Loading Services", () => {
   });
 
   it("should be accessible to SystemObjects via the module.useService method", async () => {
-    const Service = ServiceFactory();
+    const Service = SystemLynxService();
     const route = "test-service";
     const port = "8442";
     const url = `http://localhost:${port}/${route}`;
@@ -137,7 +139,7 @@ describe("App: Loading Services", () => {
     await Service.startService({ route, port });
 
     await new Promise((resolve) => {
-      const App = AppFactory();
+      const App = SystemLynxApp();
       App.loadService("test", url)
         .module("module_name", function () {
           const test = this.useService("test");
@@ -156,7 +158,7 @@ describe("App: Loading Services", () => {
 
 describe("App SystemObjects: Initializing Modules,  Modules and configurations", () => {
   it("should be able to use App.module to initialize a module", async () => {
-    const App = AppFactory();
+    const App = SystemLynxApp();
     return new Promise((resolve) =>
       App.module("test", function () {
         expect(this)
@@ -181,7 +183,7 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
     );
   });
   it("should be able to use App.startService to start as Service", async () => {
-    const App = AppFactory();
+    const App = SystemLynxApp();
     const route = "test-service";
     const port = "8493";
     const url = `http://localhost:${port}/${route}`;
@@ -207,7 +209,7 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
     expect(connData.serviceUrl).to.equal(url);
   });
   it("should be able to use App.module to add a hosted Module to the Service", async () => {
-    const App = AppFactory();
+    const App = SystemLynxApp();
     const route = "test-service";
     const port = "8494";
     const url = `http://localhost:${port}/${route}`;
@@ -252,8 +254,10 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
   });
 
   it('should be able to use App.on("ready", callback) fire a callback when App initialization is complete', async () => {
-    const App = AppFactory();
-
+    const App = SystemLynxApp();
+    const route = "system-test";
+    const port = "4242";
+    App.startService({ route, port });
     App.module("mod", function () {
       this.test = () => {};
       this.test2 = () => {};
@@ -267,9 +271,10 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
         expect(system)
           .to.be.an("object")
           .that.has.all.keys(
-            "Services",
+            "services",
             "Service",
-            "Modules",
+            "modules",
+            "connectionData",
             "configurations",
             "routing"
           );
@@ -279,7 +284,7 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
   });
 
   it("should be able to use App.config(constructor) to construct a configuration module", async () => {
-    const App = AppFactory();
+    const App = SystemLynxApp();
 
     App.module("mod", function () {
       this.test = () => {};
@@ -309,10 +314,41 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
     );
   });
 });
+describe("Use App.use(SystemLynxPlugin), to initializing Modules, and load Services", () => {
+  it("should allow for adding new modules and services before app initialization", async () => {
+    const Service = SystemLynxService();
+    const route = "test-service";
+    const port = "8520";
+    const pluginUrl = `http://localhost:${port}/${route}`;
+    Service.module("mod", function () {
+      this.test = () => {};
+      this.test2 = () => {};
+    });
+    await Service.startService({ route, port });
 
+    const plugin = (App, system) => {
+      App.loadService("PluginService", pluginUrl);
+      App.module("plugin", { testMethod: (data) => data });
+    };
+    await new Promise((resolve) => {
+      const App = SystemLynxApp();
+      App.module("testModule", { testFunction: () => data })
+        .use(plugin)
+        .on("ready", (system) => {
+          expect(system.services).to.have.lengthOf(1);
+          expect(system.services[0]).to.be.an("object");
+          expect(system.services[0]).to.have.property("name", "PluginService");
+          expect(system.services[0]).to.have.property("url", pluginUrl);
+          expect(system.modules).to.have.lengthOf(2);
+          expect(system.modules[1]).to.have.property("name", "plugin");
+          resolve();
+        });
+    });
+  });
+});
 describe("SystemContext", () => {
   it("should be able to use this.useModule and this.useService within modules and Module", () => {
-    const App = AppFactory();
+    const App = SystemLynxApp();
     App.module("mod1", function () {
       expect(this)
         .to.be.an("object")
@@ -368,7 +404,7 @@ describe("SystemContext", () => {
     return new Promise((resolve) => App.on("ready", () => resolve()));
   });
   it("[SystemLynx][App][Client][on] should have access to systemContext during event callbacks.", async () => {
-    const AppBackend = AppFactory();
+    const AppBackend = SystemLynxApp();
     const eventName = "testing-this";
     const _route = "test-service";
     const _port = "8900";
@@ -388,7 +424,7 @@ describe("SystemContext", () => {
     });
     await AppBackend.startService({ route: _route, port: _port });
 
-    const AppClient = AppFactory();
+    const AppClient = SystemLynxApp();
     const route = "test-service";
     const port = "8901";
 

package/systemlynx/Client/Client.js

@@ -12,19 +12,35 @@ module.exports = function SystemLynxClient(systemContext) {
       return Client.loadedServices[url];
 
     const connData = await loadConnectionData(url, options);
-    const Service = SocketDispatcher(connData.namespace, undefined, systemContext);
+    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, undefined, systemContext]);
+    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();
     };
 
@@ -40,7 +56,6 @@ module.exports = function SystemLynxClient(systemContext) {
 
     Service.on("disconnect", Service.resetConnection);
 
-    await new Promise((resolve) => Service.on("connect", resolve));
     return Service;
   };
 

package/systemlynx/Client/components/ClientModule.js

@@ -2,9 +2,9 @@
 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 = {};
@@ -14,14 +14,23 @@ module.exports = function SystemLynxClientModule(
     ClientModule.__connectionData = () => ({ route, host, port });
     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/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();
 
@@ -122,13 +122,13 @@ describe("Service", () => {
     const route = "test-service";
     const port = "8980";
     const url = `http://localhost:${port}/${route}`;
-    const Service = ServiceFactory();
+    const Service = SystemLynxService();
     const eventTester = Service.module("eventTester", function () {
       this.sendEvent = () => this.emit(eventName, { testPassed: true });
     });
     await Service.startService({ route, port });
 
-    const Client = ClientFactory();
+    const Client = SystemLynxClient();
 
     const buAPI = await Client.loadService(url);
     setTimeout(() => eventTester.emit(eventName, { testPassed: true }), 500);
@@ -148,8 +148,8 @@ describe("Service", () => {
   });
 
   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}`;
@@ -183,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";
@@ -199,7 +199,7 @@ describe("Service", () => {
       port,
       host,
     });
-    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

@@ -11,12 +11,16 @@ module.exports = function SystemLynxDispatcher(events = {}, systemContext) {
   };
 
   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,18 +1,16 @@
 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", "module", "clones")
+      .that.has.all.keys("startService", "server", "WebSocket", "module", "clones")
       .that.respondsTo("startService")
-      .that.respondsTo("Server")
-      .that.respondsTo("WebSocket")
       .that.respondsTo("module");
     expect(LoadBalancer.clones)
       .to.be.an("object")
@@ -69,9 +67,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")
@@ -80,7 +87,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 }, () => {});
@@ -106,8 +113,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 }, () => {});
@@ -121,7 +128,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

@@ -24,7 +24,7 @@ module.exports = function SystemLynxServerManager() {
   const moduleQueue = [];
   const modules = [];
 
-  const ServerManager = { Server: () => server, WebSocket: () => WebSocket };
+  const ServerManager = { server, WebSocket };
 
   ServerManager.startService = (options) => {
     let { route, host = "localhost", port, socketPort, staticRouting } = options;
@@ -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,18 +47,31 @@ 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,
       });
     });
 
@@ -68,7 +82,7 @@ module.exports = function SystemLynxServerManager() {
           ServerManager.addModule(name, Module, reserved_methods)
         );
         moduleQueue.length = 0;
-        resolve(ServerManager);
+        resolve(connectionData);
       })
     );
   };

package/systemlynx/ServerManager/components/Router.js

@@ -1,7 +1,7 @@
 const isObject = (value) =>
   typeof value === "object" ? (!value ? false : !Array.isArray(value)) : false;
 const isEmpty = (obj) => Object.getOwnPropertyNames(obj).length === 0;
-const isPromise = (p) => typeof p === "object" && typeof p.then === "function";
+const isPromise = (p) => typeof p === "object" && typeof (p || {}).then === "function";
 
 module.exports = function SystemLynxRouter(server, config) {
   const addService = (Module, route, { fn, method }, module_name) => {
@@ -34,16 +34,16 @@ module.exports = function SystemLynxRouter(server, config) {
     const { query, file, files, body, fn, Module, module_name, method } = req;
     const { serviceUrl } = config();
     const presets = { serviceUrl, module_name, fn };
+    const unhandledMessage = `[SystemLynx]: handled error While calling ${module_name}.${fn}(...)`;
 
     const sendError = (error) => {
       const status = (error || {}).status || 500;
-      const message = (error || {}).message || "Unexpected error";
-      const unhandledMessage = status === 500 ? "Unhandled error" : "Error";
+      const message = (error || {}).message || unhandledMessage;
       res.status(status).json({
         ...presets,
-        error,
+        ...error,
         status,
-        message: `[SystemLynx][error]: ${unhandledMessage} While calling ${module_name}.${fn}(...): ${message}`,
+        message,
         SystemLynxServiceError: true,
       });
     };

package/systemlynx/ServerManager/components/SocketEmitter.js

@@ -6,14 +6,15 @@ module.exports = function SocketEmitter(namespace, WebSocket) {
     (this || {}).on && (this || {}).emit ? this : SystemLynxDispatcher.apply(this);
 
   const socket = WebSocket.of(`/${namespace}`);
-  const emit = Emitter.emit;
+  //use $emit to emit events locally only
+  Emitter.$emit = Emitter.emit;
 
   Emitter.emit = (name, data) => {
     const id = shortid();
     const type = "WebSocket";
     socket.emit("dispatch", { id, name, data, type });
     //emit the same event locally
-    emit(name, data);
+    Emitter.$emit(name, data);
   };
   return Emitter;
 };

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

@@ -8,11 +8,9 @@ describe("SystemLynxServerManager function", () => {
 
     expect(ServerManager)
       .to.be.an("Object")
-      .that.has.all.keys(["startService", "addModule", "Server", "WebSocket"])
+      .that.has.all.keys(["startService", "addModule", "server", "WebSocket"])
       .that.respondsTo("startService")
-      .that.respondsTo("addModule")
-      .that.respondsTo("Server")
-      .that.respondsTo("WebSocket");
+      .that.respondsTo("addModule");
   });
 });
 describe("ServerManager", () => {

package/systemlynx/Service/Service.js

@@ -1,11 +1,11 @@
 "use strict";
-const ServerManagerFactory = require("../ServerManager/ServerManager");
+const SystemLynxServerManager = require("../ServerManager/ServerManager");
 const SystemLynxDispatcher = require("../Dispatcher/Dispatcher");
 
-module.exports = function ServiceFactory(systemContext = {}) {
-  const ServerManager = ServerManagerFactory();
-  const { startService, Server, WebSocket } = ServerManager;
-  const Service = { startService, Server, WebSocket };
+module.exports = function SystemLynxService(systemContext = {}) {
+  const ServerManager = SystemLynxServerManager();
+  const { startService, server, WebSocket } = ServerManager;
+  const Service = { startService, server, WebSocket };
 
   Service.module = function (name, constructor, reserved_methods = []) {
     const exclude_methods = reserved_methods.concat(
@@ -29,7 +29,7 @@ module.exports = function ServiceFactory(systemContext = {}) {
         undefined,
         systemContext,
       ]);
-      constructor.apply(Module, [ServerManager.Server(), ServerManager.WebSocket()]);
+      constructor.apply(Module, [server, WebSocket]);
       ServerManager.addModule(name, Module, exclude_methods);
       return Module;
     }

package/systemlynx/Service/Service.test.js

@@ -1,23 +1,21 @@
 const { expect } = require("chai");
 const request = require("request");
-const ServiceFactory = require("./Service");
+const SystemLynxService = require("./Service");
 
 describe("SystemLynxService", () => {
   it("should return a new instance of a Service", () => {
-    const Service = ServiceFactory();
+    const Service = SystemLynxService();
     expect(Service)
       .to.be.an("object")
-      .that.has.all.keys("startService", "module", "Server", "WebSocket")
+      .that.has.all.keys("startService", "module", "server", "WebSocket")
       .that.respondsTo("startService")
-      .that.respondsTo("module")
-      .that.respondsTo("Server")
-      .that.respondsTo("WebSocket");
+      .that.respondsTo("module");
   });
 });
 
 describe("Service factory", () => {
   it("should be able to use Service.startService to initiate a ServerManager instance that hosts the Service Connection Data", async () => {
-    const Service = ServiceFactory();
+    const Service = SystemLynxService();
     const route = "/testService";
     const port = 5500;
     const url = `http://localhost:${port}${route}`;
@@ -49,7 +47,7 @@ describe("Service factory", () => {
 });
 
 describe("Service.module(constructor)", () => {
-  const Service = ServiceFactory();
+  const Service = SystemLynxService();
   const port = 6542;
   const route = "test/service";
   const url = `http://localhost:${port}/${route}`;
@@ -111,7 +109,7 @@ describe("Service.module(constructor)", () => {
 });
 
 describe("Service.module(object)", () => {
-  const Service = ServiceFactory();
+  const Service = SystemLynxService();
   const port = 6543;
   const route = "test/service2";
   const url = `http://localhost:${port}/${route}`;

package/systemlynx/utils/System.js

@@ -1,7 +1,7 @@
 module.exports = function () {
   const System = this || {};
-  System.Services = [];
-  System.Modules = [];
+  System.services = [];
+  System.modules = [];
   System.configurations = {};
   System.routing = null;
 };

package/systemlynx/utils/SystemContext.js

@@ -2,9 +2,9 @@
 module.exports = function SystemObject(system) {
   const context = this || {};
   context.useModule = (modName) =>
-    (system.Modules.find((mod) => mod.name === modName) || {}).module || {};
+    (system.modules.find((mod) => mod.name === modName) || {}).module || {};
   context.useService = (serviceName) =>
-    (system.Services.find((mod) => mod.name === serviceName) || {}).client || {};
+    (system.services.find((mod) => mod.name === serviceName) || {}).client || {};
   context.useConfig = () => system.configurations.module || {};
   return context;
 };