systemlynx 1.7.2 → 1.8.3

package/systemlynx/ServerManager/components/Router.js

@@ -3,8 +3,8 @@ const isObject = (value) =>
 const isEmpty = (obj) => Object.getOwnPropertyNames(obj).length === 0;
 const isPromise = (p) => typeof p === "object" && typeof (p || {}).then === "function";
 
-module.exports = function SystemLynxRouter(server, config) {
-  const addService = (Module, route, { fn, method }, module_name) => {
+module.exports = function createRouter(server, config) {
+  const addService = (Module, route, { fn, method }, module_name, validators) => {
     server[method](
       [`/${route}/${fn}`, `/sf/${route}/${fn}`, `/mf/${route}/${fn}`],
       (req, res, next) => {
@@ -13,11 +13,13 @@ module.exports = function SystemLynxRouter(server, config) {
         req.Module = Module;
         next();
       },
-      routeHandler
+      setHelpers,
+      validators,
+      requestHandler
     );
   };
 
-  const addREST = (Module, route, { method }, module_name) => {
+  const addREST = (Module, route, { method }, module_name, validators) => {
     server[method](
       [`/${route}`],
       (req, res, next) => {
@@ -26,12 +28,15 @@ module.exports = function SystemLynxRouter(server, config) {
         req.Module = Module;
         next();
       },
-      routeHandler
+      setHelpers,
+      validators,
+      requestHandler
     );
   };
 
-  const routeHandler = (req, res) => {
-    const { query, file, files, body, fn, Module, module_name, method } = req;
+  const setHelpers = (req, res, next) => {
+    const { fn, module_name, query, file, files, body, method, Module } = req;
+
     const { serviceUrl } = config();
     const presets = { serviceUrl, module_name, fn };
     const unhandledMessage = `[SystemLynx]: handled error While calling ${module_name}.${fn}(...)`;
@@ -44,12 +49,12 @@ module.exports = function SystemLynxRouter(server, config) {
         ...error,
         status,
         message,
-        SystemLynxServiceError: true,
+        SystemLynxService: true,
       });
     };
 
     const sendResponse = (returnValue) => {
-      const status = (returnValue || {}).status || 200;
+      const status = (returnValue || {}).status >= 100 ? returnValue.status : 200;
       if (status < 400) {
         res.status(status).json({
           ...presets,
@@ -68,12 +73,26 @@ module.exports = function SystemLynxRouter(server, config) {
         status: 404,
       });
 
-    try {
+    const getArguments = () => {
       const args = body.__arguments || [];
       if (!isEmpty(query) && !args.length) args.push(query);
-      if (isObject(args[0]) && method === "PUT") args[0] = { ...args[0], file, files };
+      if (isObject(args[0]) && method === "PUT")
+        args[0] = { ...args[0], ...(file && { file }), ...(files && { files }) };
+      return args;
+    };
+    req.arguments = getArguments();
+    res.sendError = sendError;
+    res.sendResponse = sendResponse;
+    next();
+  };
+
+  const requestHandler = (req, res) => {
+    const { fn, Module } = req;
+    const { sendError, sendResponse } = res;
 
-      const results = Module[fn].apply(Module, args);
+    try {
+      const args = req.arguments;
+      const results = Module[fn].apply({ ...Module, req, res }, args);
 
       if (isPromise(results)) {
         results.then(sendResponse).catch(sendError);

package/systemlynx/ServerManager/components/Server.js

@@ -1,12 +1,12 @@
 //express server, socket.io server and middleware needed for SystemLynx basic functionality
-
-module.exports = function SystemLynxServer() {
+const clearFolder = require("./clearFolder");
+const clearTempFolder = clearFolder.bind({}, "./temp");
+module.exports = function createServer(customServer) {
   const cwd = process.cwd();
   //express server
   const express = require("express");
-  const server = express();
+  const server = customServer || express();
   //express middleware
-  const bodyParser = require("body-parser");
   const multer = require("multer");
   //express file upload middleware setup
   const TEMP_LOCATION = "./temp";
@@ -18,35 +18,38 @@ module.exports = function SystemLynxServer() {
       cb(null, `${shortId()}.${mime.getExtension(file.mimetype)}`),
   });
   //multi-file and single-file upload middleware functions
-  const sf = multer({ storage: storage }).single("file");
-  const mf = multer({ storage: storage }).array("files");
+  const sf = multer({ storage }).single("file");
+  const mf = multer({ storage }).array("files");
   //the sf and mf functions are used to a extract file from the req during a file upload
   //a property named file and files will be added to the req object respectively
   const singleFileUpload = (req, res, next) =>
     sf(req, res, (err) => {
-      if (err) res.json(errorResponseBuilder(err));
-      else next();
+      if (err) return res.json(err);
+      res.on("finish", clearTempFolder);
+      next();
     });
   const multiFileUpload = (req, res, next) =>
     mf(req, res, (err) => {
-      if (err) res.json(errorResponseBuilder(err));
-      else next();
+      if (err) return res.json(err);
+      res.on("finish", clearTempFolder);
+      next();
     });
 
   server.use("/sf", singleFileUpload);
   server.use("/mf", multiFileUpload);
   server.use(express.static(cwd + "/public"));
-  server.use(bodyParser.json({ limit: "5mb" }));
+  server.use(express.json({ limit: "5mb" }));
 
-  server.use((req, res, next) => {
-    res.setHeader("Access-Control-Allow-Origin", "*");
-    res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT ,DELETE");
-    res.setHeader(
-      "Access-Control-Allow-Headers",
-      "X-Requested-With,content-type, Authorization"
-    );
-    next();
-  });
+  !customServer &&
+    server.use((req, res, next) => {
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, PUT ,DELETE");
+      res.setHeader(
+        "Access-Control-Allow-Headers",
+        "X-Requested-With,content-type, Authorization"
+      );
+      next();
+    });
 
   return server;
 };

package/systemlynx/ServerManager/components/SocketEmitter.js

@@ -1,9 +1,9 @@
 "use strict";
-const SystemLynxDispatcher = require("../../Dispatcher/Dispatcher");
+const createDispatcher = require("../../Dispatcher/Dispatcher");
 const shortid = require("shortid");
 module.exports = function SocketEmitter(namespace, WebSocket) {
   const Emitter =
-    (this || {}).on && (this || {}).emit ? this : SystemLynxDispatcher.apply(this);
+    (this || {}).on && (this || {}).emit ? this : createDispatcher.apply(this);
 
   const socket = WebSocket.of(`/${namespace}`);
   //use $emit to emit events locally only

package/systemlynx/ServerManager/components/WebSocketServer.js

@@ -1,6 +1,6 @@
-module.exports = function SystemLynxWebWebSocket() {
+module.exports = function createWebSocket(server) {
   const express = require("express");
-  const SocketServer = require("http").Server(express());
+  const SocketServer = require("http").Server(server || express());
   const WebSocket = require("socket.io")(SocketServer);
 
   return { WebSocket, SocketServer };

package/systemlynx/ServerManager/components/clearFolder.js

@@ -0,0 +1,10 @@
+const fs = require("fs");
+const path = require("path");
+module.exports = function clearFolder(folder) {
+  fs.readdir(folder, (err, files) => {
+    if (err) return console.error(err);
+    files.forEach((file) => {
+      fs.unlink(path.join(folder, file), (err) => err && console.error(err));
+    });
+  });
+};

package/systemlynx/ServerManager/components/parseMethods.js

@@ -1,6 +1,6 @@
 const parseMethods = (obj, reserved_methods = [], useREST) => {
   const methods = [];
-  const REST_methods = ["get", "put", "post", "delete"];
+  const REST_methods = ["get", "put", "post", "delete", "options"];
   const props = Object.getOwnPropertyNames(obj);
 
   props.forEach((fn) => {

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

@@ -1,21 +1,28 @@
 const { expect } = require("chai");
-const SystemLynxServerManager = require("../ServerManager");
+const createServerManager = require("../ServerManager");
 const request = require("request");
 
-describe("SystemLynxServerManager function", () => {
+describe("createServerManager function", () => {
   it("should return an ServerManager instance", () => {
-    const ServerManager = SystemLynxServerManager();
+    const ServerManager = createServerManager();
 
     expect(ServerManager)
       .to.be.an("Object")
-      .that.has.all.keys(["startService", "addModule", "server", "WebSocket"])
+      .that.has.all.keys([
+        "startService",
+        "addModule",
+        "addRouteHandler",
+        "server",
+        "WebSocket",
+      ])
       .that.respondsTo("startService")
-      .that.respondsTo("addModule");
+      .that.respondsTo("addModule")
+      .that.respondsTo("addRouteHandler");
   });
 });
 describe("ServerManager", () => {
   it("should be able use ServerManager.startService to start a server that will accept requests for Module Connection Data on the given route", async () => {
-    const ServerManager = SystemLynxServerManager();
+    const ServerManager = createServerManager();
     const route = "/testService";
     const port = 4400;
     const url = `http://localhost:${port}${route}`;
@@ -43,7 +50,7 @@ describe("ServerManager", () => {
   });
 
   it("should be able to use the ServerManager.addModule method to add data to the ServerManager instance that can be accessed via a GET request", async () => {
-    const ServerManager = SystemLynxServerManager();
+    const ServerManager = createServerManager();
     const route = "/testService";
     const port = 4634;
     const url = `http://localhost:${port}${route}`;
@@ -78,7 +85,7 @@ describe("ServerManager", () => {
   });
 
   it("should be able call ServerManager.addModule method before or after calling ServerManager.startService", async () => {
-    const ServerManager = SystemLynxServerManager();
+    const ServerManager = createServerManager();
     const route = "/testService";
     const port = 4500;
     const url = `http://localhost:${port}${route}`;
@@ -117,13 +124,13 @@ describe("ServerManager", () => {
 
 describe("ServerManager.startService(ServerConfiguration)", () => {
   it("should be able to use the useREST=true property to create a REST API route for any method with the name 'get', 'put', 'post' or 'delete'", async () => {
-    const ServerManager = SystemLynxServerManager();
+    const ServerManager = createServerManager();
     const route = "/testAPI";
     const port = 8372;
     const url = `http://localhost:${port}${route}`;
     const name = "testObject";
     const object = {
-      get: () => (null, { REST_TEST_PASSED: true }),
+      get: () => ({ REST_TEST_PASSED: true }),
       put: () => {},
       post: () => {},
       delete: () => {},
@@ -156,7 +163,7 @@ describe("ServerManager.startService(ServerConfiguration)", () => {
   });
 
   it("should be able to use the staticRouting=true property to create static routes to the Modules", async () => {
-    const ServerManager = SystemLynxServerManager();
+    const ServerManager = createServerManager();
     const route = "/testAPI";
     const port = 2233;
     const url = `http://localhost:${port}${route}`;
@@ -192,4 +199,110 @@ describe("ServerManager.startService(ServerConfiguration)", () => {
       status: 200,
     });
   });
+
+  it("should be able to use the ServerManager.addRouteHandler method to add additional route handling", async () => {
+    const ServerManager = createServerManager();
+    const route = "/testAPI";
+    const port = 5454;
+    const url = `http://localhost:${port}${route}`;
+    const name = "testObject";
+    const object = {
+      get: function () {
+        const { req } = this;
+        return {
+          SERVICE_TEST_PASSED: true,
+          $allHandlerAdded: req.$allHandlerAdded,
+          putHandlerAdded: req.putHandlerAdded,
+        };
+      },
+      put: function () {
+        const { req } = this;
+        return {
+          SERVICE_TEST_PASSED: true,
+          $allHandlerAdded: req.$allHandlerAdded,
+          putHandlerAdded: req.putHandlerAdded,
+        };
+      },
+      test: function () {
+        return { SERVICE_TEST_PASSED: false };
+      },
+    };
+
+    ServerManager.addRouteHandler((req, res, next) => {
+      req.$allHandlerAdded = true;
+      next();
+    });
+    ServerManager.addRouteHandler(`${name}.put`, (req, res, next) => {
+      req.putHandlerAdded = true;
+      next();
+    });
+    ServerManager.addRouteHandler(`${name}.test`, (req, res, next) => {
+      res.sendError({ status: 400, message: "tested passed" });
+    });
+    ServerManager.addModule(name, object);
+    await ServerManager.startService({
+      route,
+      port,
+      staticRouting: true,
+      useREST: true,
+    });
+
+    const results = await new Promise((resolve) => {
+      request({ url: `${url}/${name}/get`, json: true }, (err, res, body) => {
+        resolve(body);
+      });
+    });
+
+    expect(results).to.deep.equal({
+      returnValue: {
+        SERVICE_TEST_PASSED: true,
+        $allHandlerAdded: true,
+      },
+      fn: "get",
+      message: "[SystemLynx][response]: testObject.get(...) returned successfully",
+      module_name: "testObject",
+      serviceUrl: "http://localhost:5454/testAPI",
+      status: 200,
+    });
+
+    const result2 = await new Promise((resolve) => {
+      request(
+        { url: `${url}/${name}/put`, json: true, method: "PUT" },
+        (err, res, body) => {
+          resolve(body);
+        }
+      );
+    });
+
+    expect(result2).to.deep.equal({
+      returnValue: {
+        SERVICE_TEST_PASSED: true,
+        $allHandlerAdded: true,
+        putHandlerAdded: true,
+      },
+      fn: "put",
+      message: "[SystemLynx][response]: testObject.put(...) returned successfully",
+      module_name: "testObject",
+      serviceUrl: "http://localhost:5454/testAPI",
+      status: 200,
+    });
+
+    const result3 = await new Promise((resolve) => {
+      request(
+        { url: `${url}/${name}/test`, json: true, method: "PUT" },
+        (err, res, body) => {
+          resolve(body);
+        }
+      );
+    });
+
+    expect(result3).to.deep.equal({
+      message: "tested passed",
+      fn: "test",
+      module_name: "testObject",
+      serviceUrl: "http://localhost:5454/testAPI",
+      status: 400,
+      SystemLynxService: true,
+    });
+  });
 });

package/systemlynx/Service/Service.js

@@ -1,22 +1,41 @@
 "use strict";
-const SystemLynxServerManager = require("../ServerManager/ServerManager");
-const SystemLynxDispatcher = require("../Dispatcher/Dispatcher");
+const createServerManager = require("../ServerManager/ServerManager");
+const createDispatcher = require("../Dispatcher/Dispatcher");
 
-module.exports = function SystemLynxService(systemContext = {}) {
-  const ServerManager = SystemLynxServerManager();
-  const { startService, server, WebSocket } = ServerManager;
-  const Service = { startService, server, WebSocket };
+module.exports = function createService(
+  customServer,
+  customWebSocketServer,
+  systemContext = {}
+) {
+  const ServerManager = createServerManager(customServer, customWebSocketServer);
+  const { startService, addRouteHandler, server, WebSocket } = ServerManager;
+  const Service = { startService, server, WebSocket, before: addRouteHandler };
 
   Service.module = function (name, constructor, reserved_methods = []) {
     const exclude_methods = reserved_methods.concat(
       Object.getOwnPropertyNames(systemContext)
     );
-
+    const before = (...args) => {
+      if (typeof args[0] === "string") {
+        const arg1 = args.shift();
+        const fn = arg1 === "$all" ? "" : `.${arg1}`;
+        addRouteHandler(`${name}${fn}`, ...args);
+      } else {
+        addRouteHandler(`${name}`, ...args);
+      }
+    };
     if (typeof constructor === "object" && constructor instanceof Object) {
-      const Module = SystemLynxDispatcher.apply({ ...constructor, ...systemContext }, [
-        undefined,
-        systemContext,
-      ]);
+      const Module = createDispatcher.apply(
+        {
+          ...Object.getOwnPropertyNames(constructor).reduce((obj, fn) => {
+            if (typeof constructor[fn] === "function") obj[fn] = constructor[fn];
+            return obj;
+          }, {}),
+          ...systemContext,
+          before,
+        },
+        [undefined, systemContext]
+      );
       ServerManager.addModule(name, Module, exclude_methods);
       return Module;
     }
@@ -25,7 +44,7 @@ module.exports = function SystemLynxService(systemContext = {}) {
       if (constructor.constructor.name === "AsyncFunction")
         throw `[SystemLynx][Module][Error]: Module(name, constructor) function cannot receive an async function as the constructor`;
 
-      const Module = SystemLynxDispatcher.apply(systemContext, [
+      const Module = createDispatcher.apply({ ...systemContext, before }, [
         undefined,
         systemContext,
       ]);

package/systemlynx/Service/Service.test.js

@@ -1,21 +1,22 @@
 const { expect } = require("chai");
 const request = require("request");
-const SystemLynxService = require("./Service");
-
-describe("SystemLynxService", () => {
+const createService = require("./Service");
+const createClient = require("../Client/Client");
+describe("createService", () => {
   it("should return a new instance of a Service", () => {
-    const Service = SystemLynxService();
+    const Service = createService();
     expect(Service)
       .to.be.an("object")
-      .that.has.all.keys("startService", "module", "server", "WebSocket")
+      .that.has.all.keys("startService", "module", "server", "WebSocket", "before")
       .that.respondsTo("startService")
-      .that.respondsTo("module");
+      .that.respondsTo("module")
+      .that.respondsTo("before");
   });
 });
 
 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 = SystemLynxService();
+    const Service = createService();
     const route = "/testService";
     const port = 5500;
     const url = `http://localhost:${port}${route}`;
@@ -47,7 +48,7 @@ describe("Service factory", () => {
 });
 
 describe("Service.module(constructor)", () => {
-  const Service = SystemLynxService();
+  const Service = createService();
   const port = 6542;
   const route = "test/service";
   const url = `http://localhost:${port}/${route}`;
@@ -60,13 +61,15 @@ describe("Service.module(constructor)", () => {
 
     expect(mod)
       .to.be.an("Object")
-      .that.has.all.keys("on", "emit", "test", "test2")
+      .that.has.all.keys("on", "emit", "$clearEvent", "before", "test", "test2")
       .that.respondsTo("on")
       .that.respondsTo("emit")
+      .that.respondsTo("$clearEvent")
+      .that.respondsTo("before")
       .that.respondsTo("test")
       .that.respondsTo("test2");
   });
-  it("should 'Serve' Service connection data created using the 'this' value of the constructor function", async () => {
+  it("should 'Serve' Service connection data", async () => {
     await Service.startService({ route, port });
 
     const results = await new Promise((resolve) =>
@@ -109,23 +112,69 @@ describe("Service.module(constructor)", () => {
 });
 
 describe("Service.module(object)", () => {
-  const Service = SystemLynxService();
+  const Service = createService();
   const port = 6543;
   const route = "test/service2";
   const url = `http://localhost:${port}/${route}`;
-  it("should be able to return a Service instance created using an object as the constructor", () => {
+  it("should return a ServerModule instance created using an object as the constructor", () => {
     const mod = Service.module("mod", {
-      action1: () => {},
-      action2: () => {},
+      action1: function () {
+        const { req } = this;
+        const { beforeAction1, beforeAction12, beforeModule, beforeService } = req;
+        return {
+          beforeAction1,
+          beforeModule,
+          beforeService,
+          beforeAction12,
+        };
+      },
+      action2: function () {
+        const { req } = this;
+        const { beforeAction1, beforeModule, beforeService } = req;
+        return { beforeAction1, beforeModule, beforeService };
+      },
+    });
+    Service.module("mod2", function () {
+      this.action3 = function () {
+        const { req } = this;
+        const { beforeAction3, beforeModule, beforeService } = req;
+        return { beforeAction3, beforeModule, beforeService };
+      };
+      this.before("action3", (req, res, next) => {
+        req.beforeAction3 = true;
+        next();
+      });
+    });
+    mod.before(
+      "action1",
+      (req, res, next) => {
+        req.beforeAction1 = true;
+        next();
+      },
+      (req, res, next) => {
+        req.beforeAction12 = true;
+        next();
+      }
+    );
+
+    mod.before((req, res, next) => {
+      req.beforeModule = true;
+      next();
     });
 
+    Service.before((req, res, next) => {
+      req.beforeService = true;
+      next();
+    });
     expect(mod)
       .to.be.an("Object")
-      .that.has.all.keys("action1", "action2", "on", "emit")
+      .that.has.all.keys("action1", "action2", "on", "emit", "$clearEvent", "before")
       .that.respondsTo("action1")
       .that.respondsTo("action2")
       .that.respondsTo("on")
-      .that.respondsTo("emit");
+      .that.respondsTo("emit")
+      .that.respondsTo("$clearEvent")
+      .that.respondsTo("before");
   });
   it("should 'Serve' Service connection data created using an object as the constructor", async () => {
     await Service.startService({ route, port });
@@ -167,4 +216,20 @@ describe("Service.module(object)", () => {
     expect(results.host, "localhost");
     expect(results.port, port);
   });
+
+  it("should use SeverModule.before method to add a route handler before a target method", async () => {
+    const Client = createClient();
+    const { mod, mod2 } = await Client.loadService(url);
+    const result = await mod.action1();
+    expect(result).to.deep.equal({
+      beforeAction1: true,
+      beforeAction12: true,
+      beforeModule: true,
+      beforeService: true,
+    });
+    const result2 = await mod.action2();
+    expect(result2).to.deep.equal({ beforeModule: true, beforeService: true });
+    const result3 = await mod2.action3();
+    expect(result3).to.deep.equal({ beforeAction3: true, beforeService: true });
+  });
 });

package/temp/.gitignore

@@ -1,4 +0,0 @@
-# Ignore everything in this directory
-*
-# Except this file
-!.gitignore