systemlynx 1.5.0 → 1.7.0

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,28 +34,28 @@ 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 status = (error || {}).status || 500;
+      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,
       });
     };
 
     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/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/Service/Service.js

@@ -1,27 +1,34 @@
 "use strict";
-const ServerManagerFactory = require("../ServerManager/ServerManager");
-const Dispatcher = require("../Dispatcher/Dispatcher");
+const SystemLynxServerManager = require("../ServerManager/ServerManager");
+const SystemLynxDispatcher = require("../Dispatcher/Dispatcher");
 
-module.exports = function ServiceFactory({ defaultModule = {} } = {}) {
-  const ServerManager = ServerManagerFactory();
+module.exports = function SystemLynxService(systemContext = {}) {
+  const ServerManager = SystemLynxServerManager();
   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

@@ -1,13 +1,13 @@
 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", "defaultModule")
+      .that.has.all.keys("startService", "module", "Server", "WebSocket")
       .that.respondsTo("startService")
       .that.respondsTo("module")
       .that.respondsTo("Server")
@@ -17,7 +17,7 @@ describe("SystemLynxService", () => {
 
 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 +49,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 +111,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}`;
@@ -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;
-};