systemlynx 1.5.0 → 1.6.0

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 export 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 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 comes with the following objects that are used for web app development:
 

package/index.test.js

@@ -67,14 +67,7 @@ describe("SystemLynx Objects", () => {
   it("should return a SystemLynx LoadBalancer", () => {
     expect(LoadBalancer)
       .to.be.an("object")
-      .that.has.all.keys(
-        "startService",
-        "Server",
-        "WebSocket",
-        "defaultModule",
-        "clones",
-        "module"
-      )
+      .that.has.all.keys("startService", "Server", "WebSocket", "clones", "module")
       .that.respondsTo("startService")
       .that.respondsTo("Server")
       .that.respondsTo("WebSocket")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "systemlynx",
-  "version": "1.5.0",
+  "version": "1.6.0",
   "description": "",
   "main": "index.js",
   "scripts": {

package/systemlynx/App/App.js

@@ -1,22 +1,19 @@
 "use strict";
 const { isNode } = require("../../utils/ProcessChecker");
-const ServiceFactory = require("../Service/Service");
-const SystemObject = require("./components/SystemObject");
-const Dispatcher = require("../Dispatcher/Dispatcher");
+const SystemLynxService = require("../Service/Service");
+const SystemLynxDispatcher = require("../Dispatcher/Dispatcher");
 const initializeApp = require("./components/initializeApp");
+const SystemContext = require("../utils/SystemContext");
+const System = require("../utils/System");
 
 module.exports = function SystemLynxApp() {
-  const { on, emit } = Dispatcher();
-  const App = { emit };
-  const system = { Services: [], Modules: [], configurations: {}, App, routing: null };
-  const systemObject = SystemObject(system);
-  setTimeout(() => initializeApp(system), 0);
-
-  App.on = (name, callback) => on(name, callback.bind(systemObject));
+  const system = new System();
+  const systemContext = SystemContext(system);
+  const App = SystemLynxDispatcher(undefined, systemContext);
+  setTimeout(() => initializeApp(system, App, systemContext), 0);
 
   if (isNode) {
-    system.Service = ServiceFactory();
-    system.Service.defaultModule = systemObject;
+    system.Service = SystemLynxService(systemContext);
 
     App.startService = (options) => {
       system.routing = options;
@@ -50,7 +47,7 @@ module.exports = function SystemLynxApp() {
 
   App.config = (__constructor) => {
     if (typeof __constructor === "function")
-      system.configurations = { __constructor, module: SystemObject(system) };
+      system.configurations = { __constructor, module: SystemContext(system) };
     else
       throw Error(
         "[SystemLynx][App][Error]: App.config(...) methods requires a constructor function as its first parameter."

package/systemlynx/App/components/initializeApp.js

@@ -1,7 +1,7 @@
 const loadModules = require("./loadModules");
 const loadServices = require("./loadServices");
 
-module.exports = async function initApp(system) {
+module.exports = async function initApp(system, App, systemContext) {
   let configComplete = false;
   const continuationERROR = () => {
     if (!configComplete)
@@ -16,7 +16,7 @@ module.exports = async function initApp(system) {
   };
 
   try {
-    await loadServices(system);
+    await loadServices(system, App, systemContext);
   } catch (err) {
     throw `[SystemLynx][App][Error]: Initialization Error - failed to load all services`;
   }
@@ -26,8 +26,8 @@ module.exports = async function initApp(system) {
     system.configurations.__constructor.apply(system.configurations.module, [
       () => {
         configComplete = true;
-        loadModules(system);
+        loadModules(system, App);
       },
     ]);
-  } else loadModules(system);
+  } else loadModules(system, App);
 };

package/systemlynx/App/components/loadModules.js

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

package/systemlynx/App/components/loadServices.js

@@ -1,11 +1,14 @@
-const Client = require("../../Client/Client")();
-module.exports = ({ Services, App }) => {
+const SystemLynxClient = require("../../Client/Client");
+
+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 => {
+      return new Promise((resolve) => {
         Client.loadService(url, { limit, wait })
-          .then(service => {
+          .then((service) => {
             serviceData.client = service;
             if (typeof onLoad === "function") {
               onLoad(serviceData.client);
@@ -17,7 +20,7 @@ module.exports = ({ Services, App }) => {
             );
             resolve();
           })
-          .catch(err => {
+          .catch((err) => {
             console.warn(err);
             App.emit("failed_connection", { err, ...serviceData });
             resolve();

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

@@ -271,7 +271,6 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
             "Service",
             "Modules",
             "configurations",
-            "App",
             "routing"
           );
         resolve();
@@ -279,7 +278,7 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
     );
   });
 
-  it("should be able to use App.config(constructor) to construct a configuartion module", async () => {
+  it("should be able to use App.config(constructor) to construct a configuration module", async () => {
     const App = AppFactory();
 
     App.module("mod", function () {
@@ -311,7 +310,7 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
   });
 });
 
-describe("SystemObjects", () => {
+describe("SystemContext", () => {
   it("should be able to use this.useModule and this.useService within modules and Module", () => {
     const App = AppFactory();
     App.module("mod1", function () {
@@ -333,6 +332,7 @@ describe("SystemObjects", () => {
         const config = this.useConfig();
         expect(mod1.testPassed).to.equal(true);
         expect(config.configPassed).to.equal(true);
+        this.testPassed = true;
       })
       .config(function (next) {
         expect(this)
@@ -353,7 +353,68 @@ describe("SystemObjects", () => {
         const config = this.useConfig();
         expect(mod1.testPassed).to.equal(true);
         expect(config.configPassed).to.equal(true);
+      })
+      .on("ready", function () {
+        expect(this)
+          .to.be.an("object")
+          .that.respondsTo("useService")
+          .that.respondsTo("useModule")
+          .that.respondsTo("useConfig");
+        const mod2 = this.useModule("mod2");
+        const config = this.useConfig();
+        expect(mod2.testPassed).to.equal(true);
+        expect(config.configPassed).to.equal(true);
       });
     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 eventName = "testing-this";
+    const _route = "test-service";
+    const _port = "8900";
+    const _url = `http://localhost:${_port}/${_route}`;
+    AppBackend.module("EventTesterModule", function () {
+      this.sendEvent = () => this.emit(eventName, { testPassed: true });
+
+      //testing local event callback context
+      this.on(eventName, function () {
+        console.log("Aww man... here we go again!", this);
+        expect(this)
+          .to.be.an("object")
+          .that.respondsTo("useService")
+          .that.respondsTo("useModule")
+          .that.respondsTo("useConfig");
+      });
+    });
+    await AppBackend.startService({ route: _route, port: _port });
+
+    const AppClient = AppFactory();
+    const route = "test-service";
+    const port = "8901";
+
+    AppClient.startService({ route, port }).loadService("buAPI", _url);
+    await new Promise((resolve) =>
+      AppClient.on("ready", function () {
+        const { EventTesterModule } = this.useService("buAPI");
+        EventTesterModule.on(eventName, function (data, event) {
+          console.log("Ladies and gentleman... another one!");
+          expect(this)
+            .to.be.an("object")
+            .that.respondsTo("useService")
+            .that.respondsTo("useModule")
+            .that.respondsTo("useConfig");
+          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();
+        });
+        EventTesterModule.sendEvent(eventName);
+      })
+    );
+  });
 });

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,14 +12,14 @@ module.exports = function SystemLynxClient() {
       return Client.loadedServices[url];
 
     const connData = await loadConnectionData(url, options);
-    const Service = SocketDispatcher(connData.namespace);
+    const Service = SocketDispatcher(connData.namespace, undefined, systemContext);
     Client.loadedServices[url] = Service;
     if (options.name) Client[options.name] = Service;
 
     Service.resetConnection = async (cb) => {
       const { modules, host, port, namespace } = await loadConnectionData(url, options);
 
-      SocketDispatcher.apply(Service, [namespace]);
+      SocketDispatcher.apply(Service, [namespace, undefined, systemContext]);
 
       modules.forEach(({ namespace, route, name }) =>
         Service[name].__setConnection(host, port, route, namespace)
@@ -29,7 +29,13 @@ module.exports = function SystemLynxClient() {
     };
 
     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);

package/systemlynx/Client/components/ClientModule.js

@@ -4,14 +4,15 @@ const SocketDispatcher = require("./SocketDispatcher");
 module.exports = function SystemLynxClientModule(
   { methods, namespace, route },
   { port, host },
-  resetConnection
+  resetConnection,
+  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);

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/tests/Client.test.js

@@ -119,27 +119,32 @@ 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 = ServiceFactory();
     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);
 
-    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 () => {
@@ -193,8 +198,6 @@ describe("Service", () => {
       route,
       port,
       host,
-      useReturnValues: true,
-      useCallbacks: false,
     });
     const Client = ClientFactory();
     const { AsyncMath } = await Client.loadService(url);

package/systemlynx/Dispatcher/Dispatcher.js

@@ -1,9 +1,12 @@
 "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;
   };
 

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

@@ -9,14 +9,7 @@ describe("LoadBalancerFactory", () => {
   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")

package/systemlynx/ServerManager/ServerManager.js

@@ -64,8 +64,8 @@ module.exports = function SystemLynxServerManager() {
     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);
@@ -73,15 +73,15 @@ module.exports = function SystemLynxServerManager() {
     );
   };
 
-  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 +92,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 +101,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);
         }
       });
   };

package/systemlynx/ServerManager/components/Router.js

@@ -36,8 +36,8 @@ module.exports = function SystemLynxRouter(server, config) {
     const presets = { serviceUrl, module_name, fn };
 
     const sendError = (error) => {
-      const status = error.status || 500;
-      const message = error.message || "Unexpected error";
+      const status = (error || {}).status || 500;
+      const message = (error || {}).message || "Unexpected error";
       const unhandledMessage = status === 500 ? "Unhandled error" : "Error";
       res.status(status).json({
         ...presets,
@@ -49,13 +49,13 @@ module.exports = function SystemLynxRouter(server, config) {
     };
 
     const sendResponse = (returnValue) => {
-      const status = returnValue.status || 200;
+      const status = (returnValue || {}).status || 200;
       if (status < 400) {
         res.status(status).json({
           ...presets,
           status,
           message:
-            returnValue.message ||
+            (returnValue || {}).message ||
             `[SystemLynx][response]: ${module_name}.${fn}(...) returned successfully`,
           returnValue,
         });

package/systemlynx/Service/Service.js

@@ -1,27 +1,34 @@
 "use strict";
 const ServerManagerFactory = require("../ServerManager/ServerManager");
-const Dispatcher = require("../Dispatcher/Dispatcher");
+const SystemLynxDispatcher = require("../Dispatcher/Dispatcher");
 
-module.exports = function ServiceFactory({ defaultModule = {} } = {}) {
+module.exports = function ServiceFactory(systemContext = {}) {
   const ServerManager = ServerManagerFactory();
   const { startService, Server, WebSocket } = ServerManager;
-  const Service = { startService, Server, WebSocket, defaultModule };
+  const Service = { startService, Server, WebSocket };
 
   Service.module = function (name, constructor, reserved_methods = []) {
+    const exclude_methods = reserved_methods.concat(
+      Object.getOwnPropertyNames(systemContext)
+    );
+
     if (typeof constructor === "object" && constructor instanceof Object) {
-      ServerManager.addModule(name, constructor, reserved_methods);
-      return constructor;
+      const Module = SystemLynxDispatcher.apply({ ...constructor, ...systemContext }, [
+        undefined,
+        systemContext,
+      ]);
+      ServerManager.addModule(name, Module, exclude_methods);
+      return Module;
     }
 
     if (typeof constructor === "function") {
       if (constructor.constructor.name === "AsyncFunction")
         throw `[SystemLynx][Module][Error]: Module(name, constructor) function cannot receive an async function as the constructor`;
 
-      const Module = Dispatcher.apply({ ...Service.defaultModule });
-      const exclude_methods = [
-        ...reserved_methods,
-        ...Object.getOwnPropertyNames(Module),
-      ];
+      const Module = SystemLynxDispatcher.apply(systemContext, [
+        undefined,
+        systemContext,
+      ]);
       constructor.apply(Module, [ServerManager.Server(), ServerManager.WebSocket()]);
       ServerManager.addModule(name, Module, exclude_methods);
       return Module;

package/systemlynx/Service/Service.test.js

@@ -7,7 +7,7 @@ describe("SystemLynxService", () => {
     const Service = ServiceFactory();
     expect(Service)
       .to.be.an("object")
-      .that.has.all.keys("startService", "module", "Server", "WebSocket", "defaultModule")
+      .that.has.all.keys("startService", "module", "Server", "WebSocket")
       .that.respondsTo("startService")
       .that.respondsTo("module")
       .that.respondsTo("Server")
@@ -123,9 +123,11 @@ describe("Service.module(object)", () => {
 
     expect(mod)
       .to.be.an("Object")
-      .that.has.all.keys("action1", "action2")
+      .that.has.all.keys("action1", "action2", "on", "emit")
       .that.respondsTo("action1")
-      .that.respondsTo("action2");
+      .that.respondsTo("action2")
+      .that.respondsTo("on")
+      .that.respondsTo("emit");
   });
   it("should 'Serve' Service connection data created using an object as the constructor", async () => {
     await Service.startService({ route, port });

package/systemlynx/utils/System.js

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

package/systemlynx/utils/SystemContext.js

@@ -0,0 +1,10 @@
+"use strict";
+module.exports = function SystemObject(system) {
+  const context = this || {};
+  context.useModule = (modName) =>
+    (system.Modules.find((mod) => mod.name === modName) || {}).module || {};
+  context.useService = (serviceName) =>
+    (system.Services.find((mod) => mod.name === serviceName) || {}).client || {};
+  context.useConfig = () => system.configurations.module || {};
+  return context;
+};

package/systemlynx/App/components/SystemObject.js

@@ -1,9 +0,0 @@
-"use strict";
-module.exports = function SystemObject(system) {
-  const App = this || {};
-  App.useModule = modName => (system.Modules.find(mod => mod.name === modName) || {}).module || {};
-  App.useService = serviceName =>
-    (system.Services.find(mod => mod.name === serviceName) || {}).client || {};
-  App.useConfig = () => system.configurations.module || {};
-  return App;
-};