systemlynx 1.10.8 → 1.12.8

package/client.js

@@ -0,0 +1,21 @@
+//These are all the abstractions that make up SystemLynx
+const createClient = require("./systemlynx/Client/Client");
+const createHttpClient = require("./systemlynx/HttpClient/HttpClient");
+const createDispatcher = require("./systemlynx/Dispatcher/Dispatcher");
+
+const HttpClient = createHttpClient();
+const Client = createClient();
+const Dispatcher = createDispatcher();
+
+module.exports = {
+  //Export these pre-created objects for convenient object destructuring
+  //These are the main utilities for app development
+  HttpClient,
+  Client,
+  Dispatcher,
+  //export all modules themselves
+  //all these modules export a functions
+  createClient,
+  createHttpClient,
+  createDispatcher,
+};

package/index.test.js

@@ -115,13 +115,13 @@ describe("SystemLynx Objects", () => {
       .that.has.all.keys([
         "startService",
         "addModule",
-        "addRouteHandler",
+        "addMiddleware",
         "server",
         "WebSocket",
       ])
       .that.respondsTo("startService")
       .that.respondsTo("addModule")
-      .that.respondsTo("addRouteHandler");
+      .that.respondsTo("addMiddleware");
   });
 
   it("should return a new instance of a Service", () => {

package/package.json

@@ -1,17 +1,20 @@
 {
   "name": "systemlynx",
-  "version": "1.10.8",
+  "version": "1.12.8",
   "description": "",
   "main": "index.js",
+  "browser": {
+    "./index.js": "./client.js"
+  },
   "scripts": {
     "start": "node index.js",
     "test": "jest --verbose"
   },
   "dependencies": {
+    "axios": "^1.5.0",
     "express": "^4.18.2",
     "mime": "^2.4.0",
     "multer": "^1.4.2",
-    "request": "^2.88.0",
     "shortid": "^2.2.14",
     "socket.io": "^2.2.0"
   },
@@ -36,5 +39,10 @@
     "commitizen": {
       "path": "./node_modules/cz-conventional-changelog"
     }
+  },
+  "jest": {
+    "moduleNameMapper": {
+      "axios": "axios/dist/node/axios.cjs"
+    }
   }
 }

package/systemlynx/App/App.js

@@ -1,5 +1,4 @@
 "use strict";
-const { isNode } = require("../../utils/ProcessChecker");
 const createService = require("../Service/Service");
 const createDispatcher = require("../Dispatcher/Dispatcher");
 const initializeApp = require("./components/initializeApp");
@@ -11,6 +10,7 @@ module.exports = function createApp(server, WebSocket, customClient) {
   const systemContext = SystemLynxContext(system);
   const App = new createDispatcher(undefined, systemContext);
   const plugins = [];
+
   const init = () => {
     plugins.forEach((plugin) => {
       if (typeof plugin === "function") plugin.apply({}, [App, system]);
@@ -23,32 +23,30 @@ module.exports = function createApp(server, WebSocket, customClient) {
     init();
   }, 0);
 
-  if (isNode) {
-    system.Service = createService(server, WebSocket, systemContext);
+  system.Service = createService(server, WebSocket, systemContext);
+  App.server = system.Service.server;
+  App.WebSocket = system.Service.WebSocket;
 
-    App.startService = (options) => {
-      system.routing = options;
-      if (!timeoutId) {
-        timeoutId = setTimeout(() => {
-          timeoutId = null;
-          init();
-        }, 0);
-      }
-      return App;
-    };
+  App.startService = (options) => {
+    system.routing = options;
+    if (!timeoutId) {
+      timeoutId = setTimeout(() => {
+        timeoutId = null;
+        init();
+      }, 0);
+    }
+    return App;
+  };
 
-    App.module = (name, __constructor) => {
-      system.modules.push({ name, __constructor });
-      return App;
-    };
+  App.module = (name, __constructor) => {
+    system.modules.push({ name, __constructor });
+    return App;
+  };
 
-    App.before = (...args) => {
-      system.Service.before(...args);
-      return App;
-    };
-    App.server = system.Service.server;
-    App.WebSocket = system.Service.WebSocket;
-  }
+  App.before = (...args) => {
+    system.Service.before(...args);
+    return App;
+  };
 
   App.loadService = (name, url) => {
     system.services.push({ name, url, onLoad: null, client: {} });
@@ -75,5 +73,6 @@ module.exports = function createApp(server, WebSocket, customClient) {
     plugins.push(plugin);
     return App;
   };
+
   return App;
 };

package/systemlynx/App/components/initializeApp.js

@@ -7,9 +7,9 @@ module.exports = async function initApp(system, App, customClient, systemContext
     if (!configComplete)
       console.warn(
         `
-        continuationERROR: Failed to call continuation function in App Configuariotn module 
+        continuationERROR: Failed to call next function in App.config() callback 
         
-        Fix: Must call next function during App.config( constructor(=>next) )
+        Fix: Must call next function during App.config( callback(=>next) )
         
         `
       );

package/systemlynx/Client/components/ClientModule.js

@@ -24,17 +24,14 @@ module.exports = function SystemLynxClientModule(
   const reconnectModule = async (cb) => {
     try {
       const url = connectionData.serviceUrl + `?modules=${name}`;
-    const { modules, port, host } = await loadConnectionData(url);
-    const { namespace, route } = modules[0];
-    ClientModule.__setConnection(host, port, route, namespace);
+      const { modules, port, host } = await loadConnectionData(url);
+      const { namespace, route } = modules[0];
+      ClientModule.__setConnection(host, port, route, namespace);
 
-    if (typeof cb === "function") cb();
+      if (typeof cb === "function") cb();
     } catch (error) {
-      console.error(
-        `[SystemLynx][ClientModule]: Failed to reconnect service @${connData.serviceUrl}`
-      );
+      console.error(`[SystemLynx][ClientModule]: Failed to reconnect service @${url}`);
     }
-    
   };
   const protocol = getProtocol(serviceUrl);
   methods.forEach(({ method, fn }) => {

package/systemlynx/Client/components/ServiceRequestHandler.js

@@ -1,4 +1,7 @@
 "use strict";
+
+const { isNode } = require("../../../utils/ProcessChecker");
+const { convertToReadStream } = require("../components/convertToReadStream");
 const isObject = (value) =>
   typeof value === "object" ? (!value ? false : !Array.isArray(value)) : false;
 const isEmpty = (obj) => Object.getOwnPropertyNames(obj).length === 0;
@@ -15,48 +18,55 @@ module.exports = function ServiceRequestHandler(
   Service,
   reconnectModule
 ) {
-  const ClientModule = this;
   return function sendRequest() {
     const __arguments = Array.from(arguments);
 
     const tryRequest = (cb, errCount = 0) => {
-      const { route, port, host } = ClientModule.__connectionData();
+      const { route, port, host } = this.__connectionData();
       const singleFileURL = `${protocol}${host}:${port}/sf${route}/${fn}`;
       const multiFileURL = `${protocol}${host}:${port}/mf${route}/${fn}`;
       const defaultURL = `${protocol}${host}:${port}${route}/${fn}`;
       const { file, files } = __arguments[0] || {};
       const url = file ? singleFileURL : files ? multiFileURL : defaultURL;
-      const defaultHeaders = ClientModule.headers();
+      const defaultHeaders = this.headers();
       const headers = !isEmpty(defaultHeaders) ? defaultHeaders : Service.headers();
-      if (url === defaultURL)
+      if (url === defaultURL) {
+        const query =
+          method === "get" && isObject(__arguments[0]) ? makeQuery(__arguments[0]) : "";
         httpClient
           .request({
-            url: `${url}${
-              method === "get" && isObject(__arguments[0])
-                ? makeQuery(__arguments[0])
-                : ""
-            }`,
+            url: `${url}${query}`,
             method,
             body: { __arguments },
             headers,
           })
           .then((results) => cb(null, results))
           .catch((err) => ErrorHandler(err, errCount, cb));
-      else
+      } else {
+        delete __arguments[0].file;
+        delete __arguments[0].files;
+        const formData = {};
+        formData.__arguments = __arguments;
+        if (file) formData.file = isNode ? convertToReadStream(file) : file;
+        if (Array.isArray(files))
+          formData.files = isNode ? files.map(convertToReadStream) : files;
         httpClient
           .upload({
             url,
             method,
-            formData: { ...__arguments[0], __arguments },
+            formData,
             headers,
           })
           .then((results) => cb(null, results))
           .catch((err) => ErrorHandler(err, errCount, cb));
+      }
     };
 
     const ErrorHandler = (err, errCount, cb) => {
-      if (err.SystemLynxService) {
-        cb(err);
+      if (!err.isAxiosError) {
+        throw err;
+      } else if (err.response.data.SystemLynxService) {
+        cb(err.response.data);
       } else if (errCount <= 3) {
         errCount++;
         if (reconnectModule) reconnectModule(() => tryRequest(cb, errCount));

package/systemlynx/Client/components/convertToReadStream.js

@@ -0,0 +1,41 @@
+const fs = require("fs");
+const { Readable } = require("stream");
+
+function convertStringToReadStream(path) {
+  try {
+    const stats = fs.statSync(path);
+    if (stats.isFile()) {
+      return fs.createReadStream(path);
+    } else {
+      throw new Error(`File does not exists: ${path}`);
+    }
+  } catch (error) {
+    throw new Error(
+      "Error occurred while converting file path to Readable stream:",
+      error
+    );
+  }
+}
+function bufferToStream(buffer) {
+  // Create a custom readable stream
+  const readableStream = new Readable();
+  // Push the buffer data into the stream
+  readableStream.push(buffer);
+  // Signal the end of the stream
+  readableStream.push(null);
+  return readableStream;
+}
+function convertToReadStream(input) {
+  if (input instanceof Readable) {
+    return input;
+  } // else if (Buffer.isBuffer(input)) {
+  //  return bufferToStream(input);
+  // }
+  else if (typeof input === "string") {
+    return convertStringToReadStream(input);
+  } else {
+    throw new Error("File input must be either a Readable stream, or a file path.");
+  }
+}
+
+module.exports = { convertToReadStream };

package/systemlynx/Client/components/loadConnectionData.js

@@ -5,20 +5,22 @@ module.exports = function loadConnectionData(
 ) {
   const errors = [];
 
-  return new Promise(function getData(resolve, reject) {
-    httpClient.request({ method: "GET", url }, (err, results) => {
-      if (err) {
-        errors.push(err);
+  return new Promise(async function getData(resolve, reject) {
+    try {
+      const results = await httpClient.request({ url });
+      resolve(results);
+    } catch (error) {
+      errors.push(error);
 
-        if (errors.length < limit)
-          setTimeout(() => getData(resolve, reject), errors.length * wait);
-        else {
-          console.error(
-            `[SystemLynx][Client]: Failed to load Service @${url} after ${errors.length} attempts.\n`
-          );
-          reject(err);
-        }
-      } else resolve(results);
-    });
+      if (errors.length < limit)
+        setTimeout(() => getData(resolve, reject), errors.length * wait);
+      else {
+        console.error(
+          `[SystemLynx][Client]: Failed to load Service @${url} after ${errors.length} attempts.\n`
+        );
+        console.error(errors);
+        reject(errors);
+      }
+    }
   });
 };

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

@@ -1,3 +1,4 @@
+const fs = require("fs");
 const { expect } = require("chai");
 const createClient = require("../Client");
 const createService = require("../../Service/Service");
@@ -5,6 +6,7 @@ const Service = createService();
 const port = 6757;
 const route = "service-test";
 const url = `http://localhost:${port}/${route}`;
+const TEST_FILE = process.cwd() + "/test.file.json";
 
 describe("createClient()", () => {
   it("should return a SystemLynx Client", () => {
@@ -175,7 +177,7 @@ describe("Service", () => {
     const useREST = true;
     Service.module("restTester", function () {
       this.get = (data) => ({ REST_TEST_PASSED: true, getResponse: true, ...data });
-      this.put = () => ({ REST_TEST_PASSED: true, putResponse: true });
+      this.put = (data) => ({ REST_TEST_PASSED: true, putResponse: true, ...data });
       this.post = () => ({ REST_TEST_PASSED: true, postResponse: true });
       this.delete = () => ({ REST_TEST_PASSED: true, deleteResponse: true });
     });
@@ -183,7 +185,7 @@ describe("Service", () => {
     await Service.startService({ route, port, useREST });
     const buAPI = await Client.loadService(url);
     const getResponse = await buAPI.restTester.get({ name: "GET TEST", id: 12 });
-    const putResponse = await buAPI.restTester.put();
+    const putResponse = await buAPI.restTester.put({ name: "PUT TEST", id: 13 });
     const postResponse = await buAPI.restTester.post();
     const deleteResponse = await buAPI.restTester.delete();
 
@@ -193,7 +195,12 @@ describe("Service", () => {
       name: "GET TEST",
       id: 12,
     });
-    expect(putResponse).to.deep.equal({ REST_TEST_PASSED: true, putResponse: true });
+    expect(putResponse).to.deep.equal({
+      REST_TEST_PASSED: true,
+      putResponse: true,
+      name: "PUT TEST",
+      id: 13,
+    });
     expect(postResponse).to.deep.equal({ REST_TEST_PASSED: true, postResponse: true });
     expect(deleteResponse).to.deep.equal({
       REST_TEST_PASSED: true,
@@ -201,17 +208,13 @@ describe("Service", () => {
     });
   });
 
-  it("should be able to use 'useReturnValue' configuration option to enable synchronous return values from Module methods", async () => {
+  it("should be able to asynchronously return values from Module methods", async () => {
     const service = createService();
     const route = "sync/test";
     const port = 4920;
     const host = "localhost";
     const url = `http://localhost:${port}/${route}`;
-    service.module("AsyncMath", function () {
-      this.max = Math.max;
-      this.min = Math.min;
-      this.round = Math.round;
-    });
+    service.module("AsyncMath", Math);
 
     await service.startService({
       route,
@@ -227,6 +230,104 @@ describe("Service", () => {
     const results3 = await AsyncMath.round(10.2);
     expect(results3).to.equal(10);
   });
+
+  it("should send proper error responses", async () => {
+    const service = createService();
+    const route = "sync/test";
+    const port = 7860;
+    const host = "localhost";
+    const url = `http://localhost:${port}/${route}`;
+    service.module("ErrorTest", function () {
+      this.sendError = () => {
+        return { status: 404, message: "test error" };
+      };
+      this.throwError = () => {
+        throw Error("This is my error!");
+      };
+    });
+
+    await service.startService({
+      route,
+      port,
+      host,
+    });
+    const Client = createClient();
+    const { ErrorTest } = await Client.loadService(url);
+    try {
+      await ErrorTest.sendError();
+      throw Error("this test should throw before this point");
+    } catch (error) {
+      expect(error).to.deep.equal({
+        SystemLynxService: true,
+        fn: "sendError",
+        message: "test error",
+        module_name: "ErrorTest",
+        serviceUrl: "http://localhost:7860/sync/test",
+        status: 404,
+      });
+    }
+    try {
+      await ErrorTest.throwError();
+      throw Error("this test should throw before this point");
+    } catch (error) {
+      expect(error).to.deep.equal({
+        SystemLynxService: true,
+        fn: "throwError",
+        message: "This is my error!",
+        module_name: "ErrorTest",
+        serviceUrl: "http://localhost:7860/sync/test",
+        status: 500,
+      });
+    }
+  });
+
+  it("should be able pass a ReadStream or file path for upload the via property names file or files on an object in the first parameter", async () => {
+    const service = createService();
+    const route = "file-upload/test";
+    const port = 4568;
+    const host = "localhost";
+    const url = `http://localhost:${port}/${route}`;
+
+    service.module("storage", function () {
+      this.save = ({ file, files, message }) => {
+        return { file, files, message };
+      };
+    });
+    await service.startService({
+      route,
+      port,
+      host,
+    });
+
+    const Client = createClient();
+    const { storage } = await Client.loadService(url);
+
+    const singleFileResponse = await storage.save({
+      file: fs.createReadStream(TEST_FILE),
+      message: "single file upload test confirmation",
+    });
+    const multiFileResponse = await storage.save({
+      files: [TEST_FILE, fs.createReadStream(TEST_FILE)],
+      message: "multi file upload test confirmation",
+    });
+
+    expect(singleFileResponse).to.be.an("object").that.has.all.keys("file", "message");
+    expect(singleFileResponse.message).to.be.an("string");
+    expect(singleFileResponse.message).to.equal("single file upload test confirmation");
+    expect(singleFileResponse.file).to.be.an("object");
+    expect(singleFileResponse.file.originalname).to.equal("test.file.json");
+    expect(singleFileResponse.file.mimetype).to.equal("application/json");
+
+    expect(multiFileResponse).to.be.an("object").that.has.all.keys("files", "message");
+    expect(multiFileResponse.message).to.be.an("string");
+    expect(multiFileResponse.message).to.equal("multi file upload test confirmation");
+    expect(multiFileResponse.files).to.be.an("array");
+    expect(multiFileResponse.files[0]).to.be.an("object");
+    expect(multiFileResponse.files[1]).to.be.an("object");
+    expect(multiFileResponse.files[0].originalname).to.equal("test.file.json");
+    expect(multiFileResponse.files[1].mimetype).to.equal("application/json");
+  });
+
   it("should maintain service and module level headers on a Client instance", async () => {
     const service = createService();
     const route = "setHeaders/test";

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

@@ -0,0 +1,33 @@
+const { expect } = require("chai");
+const fs = require("fs");
+const { convertToReadStream } = require("../components/convertToReadStream"); // Update the path accordingly
+// const { Readable } = require("stream");
+const TEST_FILE = process.cwd() + "/test.file.json";
+
+describe("convertToReadStream", () => {
+  it("should convert file path to Readable stream", () => {
+    const expected = fs.createReadStream(TEST_FILE);
+    const result = convertToReadStream(TEST_FILE);
+    expect(result).to.be.an.instanceOf(fs.ReadStream);
+    expect(result.path).to.equal(expected.path);
+  });
+
+  it("should handle existing Readable streams", () => {
+    const existingReadStream = fs.createReadStream(TEST_FILE);
+    const result = convertToReadStream(existingReadStream);
+    expect(result).to.equal(existingReadStream);
+  });
+
+  // it("should convert Buffer to Readable stream", () => {
+  //   const fileContentsBuffer = fs.readFileSync(TEST_FILE);
+  //   const result = convertToReadStream(fileContentsBuffer);
+  //   expect(result).to.be.an.instanceOf(Readable);
+  // });
+
+  it("should throw error for invalid input", () => {
+    const invalidInput = 123;
+    expect(() => convertToReadStream(invalidInput)).to.throw(
+      "File input must be either a Readable stream, or a file path."
+    );
+  });
+});

package/systemlynx/Dispatcher/Dispatcher.js

@@ -30,11 +30,15 @@ module.exports = function createDispatcher(events = {}, systemContext) {
     if (!fn) {
       // Clear all listeners for the given event
       delete events[eventName];
-    } else {
+    } else if (typeof fn === "function") {
       // Remove the listener function with the specified name from the event's listener array
       events[eventName] = events[eventName].filter((callback) => {
-        return callback.name !== fn;
+        return callback.name !== fn.name;
       });
+    } else {
+      console.error(
+        "SystemLynxError: the second parameter of the Dispatcher.$clearEvent takes the original function  to the event"
+      );
     }
 
     return Dispatcher;

package/systemlynx/HttpClient/HttpClient.js

@@ -1,44 +1,35 @@
-"use strict";
-const request = require("request");
-const json = true;
+const { isNode } = require("../../utils/ProcessChecker");
+const axios = require("axios").default;
+const FormData = require("form-data");
+const path = require("path");
 
 module.exports = function createHttpClient() {
-  const Client = this || {};
-
-  Client.request = ({ method, url, body, headers }, cb) => {
-    const tryRequest = (callback) => {
-      request({ method, url, body, json, headers }, (err, res, body) => {
-        if (err) callback(err);
-        else if (res.statusCode >= 400) callback(body);
-        else callback(null, body, res);
-      });
-    };
-    if (typeof cb === "function") tryRequest(cb);
-    else
-      return new Promise((resolve, reject) =>
-        tryRequest((err, results) => {
-          if (err) reject(err);
-          else resolve(results);
-        })
-      );
+  const Client = {};
+  Client.request = async ({ method = "get", url, body: data, headers }) => {
+    method = method.toLowerCase();
+    const res = await axios({ url, method, headers, data });
+    if (res.status >= 400) {
+      throw res.data;
+    } else return res.data;
   };
 
-  Client.upload = ({ url, formData, headers }, cb) => {
-    const tryRequest = (callback) => {
-      request.post({ url, formData, json, headers }, (err, res, body) => {
-        if (err) callback(err);
-        else if (res.statusCode >= 400) callback(body);
-        else callback(null, body, res);
+  Client.upload = async ({ url, formData, headers }) => {
+    const { file, files, __arguments } = formData;
+    const form = new FormData();
+    if (file) form.append("file", file, isNode ? path.basename(file.path) : file.name);
+    if (files) {
+      files.forEach((file) => {
+        form.append("files", file, isNode ? path.basename(file.path) : file.name);
       });
-    };
-    if (typeof cb === "function") tryRequest(cb);
-    else
-      return new Promise((resolve, reject) =>
-        tryRequest((err, results) => {
-          if (err) reject(err);
-          else resolve(results);
-        })
-      );
+    }
+    if (__arguments) form.append("__arguments", JSON.stringify(__arguments));
+
+    const res = await axios.post(url, form, {
+      headers: { ...headers, "Content-Type": "multipart/form-data" },
+    });
+    if (res.status >= 400) {
+      throw res.data;
+    } else return res.data;
   };
 
   return Client;

package/systemlynx/HttpClient/HttpClient.test.js

@@ -3,7 +3,7 @@ const fs = require("fs");
 const HttpSystemLynxClient = require("./HttpClient");
 const port = 4789;
 const testServerSetup = require("./test.server");
-//test server setup
+const TEST_FILE = process.cwd() + "/test.file.json";
 
 beforeAll(() => new Promise((resolve) => testServerSetup(port, resolve)));
 describe("HttpSystemLynxClient Test", () => {
@@ -20,37 +20,13 @@ describe("HttpSystemLynxClient Test", () => {
       .that.respondsTo("upload");
   });
 
-  it("should be able to make http requests using a callback", async () => {
-    const results = await new Promise((resolve, reject) => {
-      HttpClient.request(
-        {
-          method: "GET",
-          url: "http://localhost:4789/test",
-          body: { getWithCallback: true },
-        },
-        (err, results) => {
-          if (err) reject(err);
-          else resolve(results);
-        }
-      );
-    });
-
-    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 },
     });
 
     expect(results).to.be.an("Object").that.deep.equal({
-      getWithPromise: true,
       testPassed: true,
       method: "GET",
     });
@@ -60,11 +36,9 @@ describe("HttpSystemLynxClient Test", () => {
     const results = await HttpClient.request({
       method: "GET",
       url,
-      body: { getWithPromise: true },
     });
 
     expect(results).to.be.an("Object").that.deep.equal({
-      getWithPromise: true,
       testPassed: true,
       method: "GET",
     });
@@ -87,21 +61,19 @@ describe("HttpSystemLynxClient Test", () => {
     const results = await HttpClient.request({
       method: "DELETE",
       url,
-      body: { test: true },
     });
 
     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 file = fs.createReadStream(TEST_FILE);
     const results = await HttpClient.upload({
       url: singleFileUrl,
-      formData: { file },
+      formData: { file, __arguments: [{ uploadArguments: true }] },
     });
 
     expect(results).to.be.an("Object").that.has.property("testPassed", true);
@@ -109,19 +81,19 @@ describe("HttpSystemLynxClient Test", () => {
       .to.have.property("file")
       .that.is.an("Object")
       .that.has.property("originalname", "test.file.json");
+    expect(results.__arguments).to.deep.equal([{ uploadArguments: true }]);
   });
 
   it("should be able to upload multiple files", async () => {
-    const files = [
-      fs.createReadStream(__dirname + "/test.file.json"),
-      fs.createReadStream(__dirname + "/test.file.json"),
-    ];
-    const multiUploadResponse = await HttpClient.upload({
+    const files = [fs.createReadStream(TEST_FILE), fs.createReadStream(TEST_FILE)];
+    const results = await HttpClient.upload({
       url: multiFileUrl,
-      formData: { files },
+      formData: { files, __arguments: [{ multiUploadArguments: true }] },
     });
-    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);
+
+    expect(results).to.be.an("Object").that.has.property("testPassed", true);
+    expect(results).to.have.property("files").that.is.an("Array");
+    expect(results).to.have.property("fileUploadTest", true);
+    expect(results.__arguments).to.deep.equal([{ multiUploadArguments: true }]);
   });
 });

package/systemlynx/HttpClient/test.server.js

@@ -12,14 +12,14 @@ module.exports = TestServerSetup = (port, done) => {
     const { file } = req;
     const json = JSON.parse(fs.readFileSync(file.path));
 
-    res.json({ file, ...json });
+    res.json({ file, ...json, ...req.body });
   };
 
   const multiUploadResponse = (req, res) => {
     const { files } = req;
     const json = JSON.parse(fs.readFileSync(files[0].path));
 
-    res.json({ files, ...json });
+    res.json({ files, ...json, ...req.body });
   };
 
   server.get("/test", response);

package/systemlynx/LoadBalancer/components/Router.js

@@ -11,15 +11,18 @@ module.exports = function Router(server) {
       if (locations.length === 0)
         return res.status(404).json({
           message: `No services found on requested route: ${route}`,
-          locations
+          locations,
         });
 
       location_index++;
       location_index = location_index < locations.length ? location_index : 0;
       const url = locations[location_index];
-
-      HttpClient.request({ url }, (err, connData) => {
-        if (err) {
+      HttpClient.request({ url })
+        .then((connData) => {
+          res.json(connData);
+        })
+        .catch((err) => {
+          console.log(err);
           for (i = 0; i < locations.length; i++) {
             if (locations[i] === url) {
               locations.splice(i, 1);
@@ -28,8 +31,7 @@ module.exports = function Router(server) {
             }
           }
           recursiveGetService(req, res);
-        } else res.json(connData);
-      });
+        });
     }
   };
 

package/systemlynx/ServerManager/ServerManager.js

@@ -5,7 +5,7 @@ const SocketEmitter = require("./components/SocketEmitter");
 const createWebSocket = require("./components/WebSocketServer");
 const parseMethods = require("./components/parseMethods");
 const shortId = require("shortid");
-const randomPort = () => parseInt(Math.random() * parseInt(Math.random() * 10000)) + 1023;
+const randomPort = () => Math.floor(Math.random() * (65535 - 49152 + 1)) + 49152;
 const createSSLServer = (app, options) => {
   const https = require("https");
   return https.createServer(options, app);
@@ -135,7 +135,7 @@ module.exports = function createServerManager(customServer, customWebSocketServe
         }
       });
   };
-  ServerManager.addRouteHandler = (...args) => {
+  ServerManager.addMiddleware = (...args) => {
     const name = typeof args[0] === "string" ? args.shift() : "$all";
     args.forEach(async (middleware) => {
       if (Array.isArray(middleware)) {

package/systemlynx/ServerManager/components/Router.js

@@ -76,7 +76,7 @@ module.exports = function createRouter(server, config) {
     const getArguments = () => {
       const args = body.__arguments || [];
       if (!isEmpty(query) && !args.length) args.push(query);
-      if (isObject(args[0]) && method === "PUT")
+      if (isObject(args[0]) && method === "POST")
         args[0] = { ...args[0], ...(file && { file }), ...(files && { files }) };
       return args;
     };

package/systemlynx/ServerManager/components/Server.js

@@ -1,6 +1,8 @@
-//express server, socket.io server and middleware needed for SystemLynx basic functionality
-const clearFolder = require("./clearFolder");
-const clearTempFolder = clearFolder.bind({}, "./temp");
+const fs = require("fs");
+const TEMP_FOLDER = `${__dirname}/temp`;
+const { ensureDir, clearFolder } = require("./utils");
+ensureDir(TEMP_FOLDER);
+
 module.exports = function createServer(customServer) {
   //express server
   const express = require("express");
@@ -8,13 +10,14 @@ module.exports = function createServer(customServer) {
   //express middleware
   const multer = require("multer");
   //express file upload middleware setup
-  const TEMP_LOCATION = "./temp";
+
   const mime = require("mime");
   const shortId = require("shortid");
   const storage = multer.diskStorage({
-    destination: (req, file, cb) => cb(null, TEMP_LOCATION),
-    filename: (req, file, cb) =>
-      cb(null, `${shortId()}.${mime.getExtension(file.mimetype)}`),
+    destination: (req, file, cb) => cb(null, TEMP_FOLDER),
+    filename: (req, file, cb) => {
+      return cb(null, `${shortId()}.${mime.getExtension(file.mimetype)}`);
+    },
   });
   //multi-file and single-file upload middleware functions
   const sf = multer({ storage }).single("file");
@@ -24,18 +27,22 @@ module.exports = function createServer(customServer) {
   const singleFileUpload = (req, res, next) =>
     sf(req, res, (err) => {
       if (err) return res.json(err);
-      res.on("finish", clearTempFolder);
+      res.on("finish", () => fs.unlink(req.file.path, () => {}));
       next();
     });
   const multiFileUpload = (req, res, next) =>
     mf(req, res, (err) => {
       if (err) return res.json(err);
-      res.on("finish", clearTempFolder);
+      res.on("finish", () => clearFolder(TEMP_FOLDER));
       next();
     });
-
-  server.use("/sf", singleFileUpload);
-  server.use("/mf", multiFileUpload);
+  const parseArguments = (req, res, next) => {
+    const { __arguments } = req.body;
+    if (__arguments) req.body.__arguments = JSON.parse(__arguments);
+    next();
+  };
+  server.use("/sf", singleFileUpload, parseArguments);
+  server.use("/mf", multiFileUpload, parseArguments);
   server.use(express.json({ limit: "5mb" }));
 
   !customServer &&

package/systemlynx/ServerManager/components/parseMethods.js

@@ -8,7 +8,7 @@ const parseMethods = (obj, reserved_methods = [], useREST) => {
       const method =
         useREST && REST_methods.indexOf(fn.toLocaleLowerCase()) > -1
           ? fn.toLocaleLowerCase()
-          : "put";
+          : "post";
       methods.push({ method, fn });
     }
   });

package/systemlynx/ServerManager/components/utils.js

@@ -0,0 +1,21 @@
+const fs = require("fs");
+const path = require("path");
+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));
+    });
+  });
+}
+async function ensureDir(dir) {
+  if (!fs.existsSync(dir)) {
+    return new Promise((resolve, reject) => {
+      fs.mkdir(dir, { recursive: true }, (err) => {
+        if (err) reject(err);
+        else resolve();
+      });
+    });
+  }
+}
+module.exports = { clearFolder, ensureDir };

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

@@ -11,13 +11,13 @@ describe("createServerManager function", () => {
       .that.has.all.keys([
         "startService",
         "addModule",
-        "addRouteHandler",
+        "addMiddleware",
         "server",
         "WebSocket",
       ])
       .that.respondsTo("startService")
       .that.respondsTo("addModule")
-      .that.respondsTo("addRouteHandler");
+      .that.respondsTo("addMiddleware");
   });
 });
 describe("ServerManager", () => {
@@ -200,7 +200,7 @@ describe("ServerManager.startService(ServerConfiguration)", () => {
     });
   });
 
-  it("should be able to use the ServerManager.addRouteHandler method to add additional route handling", async () => {
+  it("should be able to use the ServerManager.addMiddleware method to add additional route handling", async () => {
     const ServerManager = createServerManager();
     const route = "/testAPI";
     const port = 5454;
@@ -228,15 +228,15 @@ describe("ServerManager.startService(ServerConfiguration)", () => {
       },
     };
 
-    ServerManager.addRouteHandler((req, res, next) => {
+    ServerManager.addMiddleware((req, res, next) => {
       req.$allHandlerAdded = true;
       next();
     });
-    ServerManager.addRouteHandler(`${name}.put`, (req, res, next) => {
+    ServerManager.addMiddleware(`${name}.put`, (req, res, next) => {
       req.putHandlerAdded = true;
       next();
     });
-    ServerManager.addRouteHandler(`${name}.test`, (req, res, next) => {
+    ServerManager.addMiddleware(`${name}.test`, (req, res, next) => {
       res.sendError({ status: 400, message: "tested passed" });
     });
     ServerManager.addModule(name, object);
@@ -289,7 +289,7 @@ describe("ServerManager.startService(ServerConfiguration)", () => {
 
     const result3 = await new Promise((resolve) => {
       request(
-        { url: `${url}/${name}/test`, json: true, method: "PUT" },
+        { url: `${url}/${name}/test`, json: true, method: "post" },
         (err, res, body) => {
           resolve(body);
         }

package/systemlynx/Service/Service.js

@@ -8,8 +8,8 @@ module.exports = function createService(
   systemContext = {}
 ) {
   const ServerManager = createServerManager(customServer, customWebSocketServer);
-  const { startService, addRouteHandler, server, WebSocket } = ServerManager;
-  const Service = { startService, server, WebSocket, before: addRouteHandler };
+  const { startService, addMiddleware, server, WebSocket } = ServerManager;
+  const Service = { startService, server, WebSocket, before: addMiddleware };
 
   Service.module = function (name, constructor, reserved_methods = []) {
     const exclude_methods = reserved_methods.concat(
@@ -19,9 +19,9 @@ module.exports = function createService(
       if (typeof args[0] === "string") {
         const arg1 = args.shift();
         const fn = arg1 === "$all" ? "" : `.${arg1}`;
-        addRouteHandler(`${name}${fn}`, ...args);
+        addMiddleware(`${name}${fn}`, ...args);
       } else {
-        addRouteHandler(`${name}`, ...args);
+        addMiddleware(`${name}`, ...args);
       }
     };
     if (typeof constructor === "object" && constructor instanceof Object) {

package/systemlynx/ServerManager/components/clearFolder.js

@@ -1,10 +0,0 @@
-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));
-    });
-  });
-};