systemlynx 1.1.0

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

@@ -0,0 +1,208 @@
+const { expect } = require("chai");
+const ClientFactory = require("../Client");
+const ServiceFactory = require("../../Service/Service");
+const Service = ServiceFactory();
+const port = 6757;
+const route = "service-test";
+const url = `http://localhost:${port}/${route}`;
+
+describe("Client Factory", () => {
+  it("should return a SystemLynx Client", () => {
+    const Client = ClientFactory();
+    expect(Client)
+      .to.be.an("object")
+      .that.has.property("loadService")
+      .that.is.a("function");
+  });
+});
+describe("Client", () => {
+  it("should be able to use Client.loadService(url, options) to return a promise that resolve into a backend service", async () => {
+    Service.ServerModule(
+      "orders",
+      function () {
+        this.action1 = (data) => ({ SERVICE_TEST_PASSED: true, ...data, action1: true });
+        this.action2 = (data) => ({ SERVICE_TEST_PASSED: true, ...data, action2: true });
+        this.action3 = (data) => ({ SERVICE_TEST_PASSED: true, ...data, action3: true });
+        this.noArgTest = () => ({ SERVICE_TEST_PASSED: true, noArgTest: true });
+        this.multiArgTest = (arg1, arg2, arg3) => ({
+          SERVICE_TEST_PASSED: true,
+          multiArgTest: true,
+          arg1,
+          arg2,
+          arg3,
+        });
+      },
+      ["action3"]
+    );
+
+    await Service.startService({ route, port });
+    const Client = ClientFactory();
+    const buAPI = await Client.loadService(url);
+
+    expect(buAPI)
+      .to.be.an("object")
+      .that.has.all.keys("emit", "on", "resetConnection", "disconnect", "orders")
+      .that.respondsTo("emit")
+      .that.respondsTo("on")
+      .that.respondsTo("resetConnection")
+      .that.respondsTo("disconnect");
+
+    expect(buAPI.orders)
+      .to.be.an("object")
+      .that.has.all.keys(
+        "emit",
+        "on",
+        "disconnect",
+        "__setConnection",
+        "__connectionData",
+        "action1",
+        "action2",
+        "multiArgTest",
+        "noArgTest"
+      )
+      .that.respondsTo("emit")
+      .that.respondsTo("on")
+      .that.respondsTo("emit")
+      .that.respondsTo("__setConnection")
+      .that.respondsTo("__connectionData")
+      .that.respondsTo("action1")
+      .that.respondsTo("action2")
+      .that.respondsTo("multiArgTest")
+      .that.respondsTo("noArgTest");
+  });
+});
+
+describe("Service", () => {
+  it("should be able to call methods from the frontend client to the backend ServerModule", async () => {
+    const Client = ClientFactory();
+    const buAPI = await Client.loadService(url);
+
+    const results = await buAPI.orders.action1({ code: 3 });
+
+    const results2 = await buAPI.orders.action2({ code: 11 });
+
+    expect(results).to.deep.equal({ SERVICE_TEST_PASSED: true, code: 3, action1: true });
+    expect(results2).to.deep.equal({
+      SERVICE_TEST_PASSED: true,
+      code: 11,
+      action2: true,
+    });
+  });
+  it("should be able to send multiple arguments to the backend ServerModule", async () => {
+    const Client = ClientFactory();
+    const buAPI = await Client.loadService(url);
+    const arg1 = 4,
+      arg2 = 5,
+      arg3 = 6;
+
+    const results = await buAPI.orders.multiArgTest(arg1, arg2, arg3);
+
+    expect(results).to.deep.equal({
+      SERVICE_TEST_PASSED: true,
+      multiArgTest: true,
+      arg1,
+      arg2,
+      arg3,
+    });
+  });
+
+  it("should be able to send no arguments and use a promise", async () => {
+    const Client = ClientFactory();
+    const buAPI = await Client.loadService(url);
+    const results = await buAPI.orders.noArgTest();
+
+    expect(results).to.deep.equal({
+      SERVICE_TEST_PASSED: true,
+      noArgTest: true,
+    });
+  });
+
+  it("should be able to receive events emitted from the backend Client", async () => {
+    const eventName = "testing";
+    const eventTester = Service.ServerModule("eventTester", function () {
+      const eventTester = this;
+      eventTester.sendEvent = () => eventTester.emit(eventName, { testPassed: true });
+    });
+
+    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");
+    });
+
+    eventTester.emit(eventName, { testPassed: true });
+  });
+
+  it("should be able to send REST http requests", async () => {
+    const Client = ClientFactory();
+    const Service = ServiceFactory();
+    const route = "rest-tester";
+    const port = "8492";
+    const url = `http://localhost:${port}/${route}`;
+    const useREST = true;
+    Service.ServerModule("restTester", function () {
+      this.get = (data) => ({ REST_TEST_PASSED: true, getResponse: true, ...data });
+      this.put = () => ({ REST_TEST_PASSED: true, putResponse: true });
+      this.post = () => ({ REST_TEST_PASSED: true, postResponse: true });
+      this.delete = () => ({ REST_TEST_PASSED: true, deleteResponse: true });
+    });
+
+    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 postResponse = await buAPI.restTester.post();
+    const deleteResponse = await buAPI.restTester.delete();
+
+    expect(getResponse).to.deep.equal({
+      REST_TEST_PASSED: true,
+      getResponse: true,
+      name: "GET TEST",
+      id: 12,
+    });
+    expect(putResponse).to.deep.equal({ REST_TEST_PASSED: true, putResponse: true });
+    expect(postResponse).to.deep.equal({ REST_TEST_PASSED: true, postResponse: true });
+    expect(deleteResponse).to.deep.equal({
+      REST_TEST_PASSED: true,
+      deleteResponse: true,
+    });
+  });
+
+  it("should be able to use 'useReturnValue' configuration option to enable synchronous return values from ServerModule methods", async () => {
+    const service = ServiceFactory();
+    const route = "sync/test";
+    const port = 4920;
+    const host = "localhost";
+    const url = `http://localhost:${port}/${route}`;
+    service.ServerModule("AsyncMath", function () {
+      this.max = Math.max;
+      this.min = Math.min;
+      this.round = Math.round;
+    });
+
+    await service.startService({
+      route,
+      port,
+      host,
+      useReturnValues: true,
+      useCallbacks: false,
+    });
+    const Client = ClientFactory();
+    const { AsyncMath } = await Client.loadService(url);
+    const results = await AsyncMath.max(10, 2);
+    expect(results).to.equal(10);
+    const results2 = await AsyncMath.min(10, 2);
+    expect(results2).to.equal(2);
+    const results3 = await AsyncMath.round(10.2);
+    expect(results3).to.equal(10);
+  });
+});

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

@@ -0,0 +1,54 @@
+const { expect } = require("chai");
+const SocketDispatcher = require("../components/SocketDispatcher");
+const { WebSocket, SocketServer } = require("../../ServerManager/components/WebSocketServer")();
+
+const namespace = "test-namespace";
+const port = 4592;
+const socket = WebSocket.of(`/${namespace}`);
+
+SocketServer.listen(port);
+
+describe("SocketDispatcher", () => {
+  const eventName = "test-event";
+  const dispatcher = SocketDispatcher(`http://localhost:${port}/${namespace}`);
+  it("should return an EventDispatcher object with methods on and emit", async () => {
+    expect(dispatcher)
+      .to.be.an("object")
+      .that.has.all.keys("on", "emit", "disconnect")
+      .that.respondsTo("on")
+      .that.respondsTo("emit")
+      .that.respondsTo("disconnect");
+  });
+  it("Should be able to emit and handle events", (done) => {
+    dispatcher.on(eventName, (data) => {
+      expect(data).to.deep.equal({ testPassed: true });
+      done();
+    });
+    dispatcher.on("connect", () => console.log(`I'm all the way connected!`));
+    setTimeout(() => socket.emit("dispatch", { name: eventName, data: { testPassed: true } }), 500);
+  });
+});
+
+describe("SocketDispatcher.apply()", () => {
+  const eventName = "testing-event";
+  const dispatcher = SocketDispatcher.apply({}, [`http://localhost:${port}/${namespace}`]);
+  it("should return an EventDispatcher object with methods on and emit", async () => {
+    expect(dispatcher)
+      .to.be.an("object")
+      .that.has.all.keys("on", "emit", "disconnect")
+      .that.respondsTo("on")
+      .that.respondsTo("emit")
+      .that.respondsTo("disconnect");
+  });
+  it("Should be able to emit and handle events", (done) => {
+    dispatcher.on(eventName, (data, event) => {
+      expect(data).to.deep.equal({ testPassed: true });
+      expect(event).to.deep.equal({ name: "testing-event", data: { testPassed: true } });
+      //console.log(event);
+      console.log(`I'm all the way connected too!`);
+      done();
+    });
+
+    setTimeout(() => socket.emit("dispatch", { name: eventName, data: { testPassed: true } }), 500);
+  });
+});

package/systemlynx/Dispatcher/Dispatcher.js

@@ -0,0 +1,21 @@
+"use strict";
+module.exports = function SystemLynxDispatcher(events = {}) {
+  const Dispatcher = this || {};
+
+  Dispatcher.emit = (eventName, data, event) => {
+    if (events[eventName]) events[eventName].forEach((callback) => callback(data, event));
+    return Dispatcher;
+  };
+
+  Dispatcher.on = (eventName, callback) => {
+    if (typeof callback !== "function")
+      throw Error(
+        "SystemLynxDispatcher Error: object.on(eventName, callback) invalid parameters"
+      );
+    if (!events[eventName]) events[eventName] = [];
+    events[eventName].push(callback);
+    return Dispatcher;
+  };
+
+  return Dispatcher;
+};

package/systemlynx/Dispatcher/Dispatcher.test.js

@@ -0,0 +1,21 @@
+const { expect } = require("chai");
+const Dispatcher = require("./Dispatcher");
+
+describe("SystemLynxDispatcher", () => {
+  const dispatcher = Dispatcher();
+  it("should return an EventDispatcher object with methods on and emit", async () => {
+    expect(dispatcher)
+      .to.be.an("object")
+      .that.has.all.keys("on", "emit")
+      .that.respondsTo("on")
+      .that.respondsTo("emit");
+  });
+  it("Should be able to emit and handle events", (done) => {
+    dispatcher.on("test", (data) => {
+      expect(data).to.deep.equal({ testPassed: true });
+      done();
+    });
+
+    dispatcher.emit("test", { testPassed: true });
+  });
+});

package/systemlynx/HttpClient/HttpClient.js

@@ -0,0 +1,44 @@
+"use strict";
+const httpClient = require("request");
+const json = true;
+
+module.exports = function SystemLynxClient() {
+  const Client = this || {};
+  Client.request = ({ method, url, body }, cb) => {
+    const tryRequest = (callback) => {
+      httpClient({ method, url, body, json }, (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);
+        })
+      );
+  };
+
+  Client.upload = ({ url, formData }, cb) => {
+    const tryRequest = (callback) => {
+      httpClient.post({ url, formData, json }, (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);
+        })
+      );
+  };
+
+  return Client;
+};

package/systemlynx/HttpClient/HttpClient.test.js

@@ -0,0 +1,143 @@
+const { expect } = require("chai");
+const fs = require("fs");
+const HttpClientFactory = require("./HttpClient");
+const port = 4789;
+const testServerSetup = require("./test.server");
+//test server setup
+
+beforeAll(() => new Promise(resolve => testServerSetup(port, resolve)));
+describe("HttpClientFactory Test", () => {
+  const HttpClient = HttpClientFactory();
+  const url = `http://localhost:${port}/test`;
+  const singleFileUrl = `http://localhost:${port}/sf/test`;
+  const multiFileUrl = `http://localhost:${port}/mf/test`;
+
+  it("should return a HttpClient instance", () => {
+    expect(HttpClient)
+      .to.be.an("Object")
+      .that.has.all.keys("request", "upload")
+      .that.respondsTo("request")
+      .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"
+      });
+  });
+
+  it("should be able to make PUT requests", 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"
+      });
+  });
+
+  it("should be able to make POST requests", async () => {
+    const results = await HttpClient.request({
+      method: "POST",
+      url,
+      body: { test: true }
+    });
+
+    expect(results)
+      .to.be.an("Object")
+      .that.deep.equal({
+        test: true,
+        testPassed: true,
+        method: "POST"
+      });
+  });
+  it("should be able to make DELETE requests", async () => {
+    const results = await HttpClient.request({
+      method: "DELETE",
+      url,
+      body: { test: true }
+    });
+
+    expect(results)
+      .to.be.an("Object")
+      .that.deep.equal({
+        test: true,
+        testPassed: true,
+        method: "DELETE"
+      });
+  });
+
+  it("should be able to upload a file", async () => {
+    const file = fs.createReadStream(__dirname + "/test.file.json");
+    const results = await HttpClient.upload({
+      url: singleFileUrl,
+      formData: { file }
+    });
+
+    expect(results)
+      .to.be.an("Object")
+      .that.has.property("testPassed", true);
+    expect(results)
+      .to.have.property("file")
+      .that.is.an("Object")
+      .that.has.property("originalname", "test.file.json");
+  });
+
+  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({
+      url: multiFileUrl,
+      formData: { files }
+    });
+    expect(multiUploadResponse)
+      .to.be.an("Object")
+      .that.has.property("testPassed", true);
+    expect(multiUploadResponse)
+      .to.have.property("files")
+      .that.is.an("Array");
+    expect(multiUploadResponse).to.have.property("fileUploadTest", true);
+  });
+});

package/systemlynx/HttpClient/test.file.json

@@ -0,0 +1 @@
+{ "testPassed": true, "fileUploadTest": true }

package/systemlynx/HttpClient/test.server.js

@@ -0,0 +1,34 @@
+module.exports = TestServerSetup = (port, done) => {
+  const fs = require("fs");
+  const server = require("../ServerManager/components/Server")();
+
+  const response = (req, res) => {
+    const { body, method } = req;
+    body.testPassed = true;
+    res.json({ method, ...body });
+  };
+
+  const uploadResponse = (req, res) => {
+    const { file } = req;
+    const json = JSON.parse(fs.readFileSync(file.path));
+
+    res.json({ file, ...json });
+  };
+
+  const multiUploadResponse = (req, res) => {
+    const { files } = req;
+    const json = JSON.parse(fs.readFileSync(files[0].path));
+
+    res.json({ files, ...json });
+  };
+
+  server.get("/test", response);
+  server.put("/test", response);
+  server.post("/test", response);
+  server.delete("/test", response);
+  server.post("/sf/test", uploadResponse);
+  server.post("/mf/test", multiUploadResponse);
+  server.listen(port, console.log(`(TestServer) listening on port:${port}`), done);
+
+  return server;
+};

package/systemlynx/LoadBalancer/LoadBalancer.js

@@ -0,0 +1,7 @@
+const Service = require("../Service/Service");
+const CloneManager = require("./components/CloneManager");
+module.exports = function LoadBalancer() {
+  const LoadBalancer = Service();
+  const clones = LoadBalancer.ServerModule("clones", CloneManager);
+  return { ...LoadBalancer, clones };
+};

package/systemlynx/LoadBalancer/components/CloneManager.js

@@ -0,0 +1,49 @@
+const Router = require("./Router");
+module.exports = function Clones(server) {
+  const Clones = this;
+  const cloneRouter = Router.apply(Clones, [server]);
+  const handledEvents = [];
+  Clones.clones = [];
+
+  Clones.register = ({ port, host, route }, cb) => {
+    if (!(port && route && host))
+      return cb({
+        message: "route port and host are required options",
+        status: 400,
+      });
+
+    route = route.charAt(0) === "/" ? route : "/" + route;
+    const url = `http://${host}:${port}${route}`;
+    let service = Clones.clones.find((service) => service.route === route);
+
+    if (service) {
+      if (service.locations.indexOf(url) === -1) {
+        service.locations.push(url);
+        Clones.emit("new_clone", { url, service });
+        cb(null, { message: "New clone locations registered", service });
+      }
+    } else {
+      service = { route, locations: [url] };
+      cloneRouter.addService(service);
+      Clones.clones.push(service);
+      Clones.emit("new_service", { url, service });
+      Clones.emit("new_clone", { url, service });
+      cb(null, { url, service });
+    }
+  };
+
+  Clones.dispatch = ({ name, data }, cb) => {
+    Clones.emit(name, data);
+    cb();
+  };
+
+  Clones.assignDispatch = (event, cb) => {
+    const e = handledEvents.find((e) => e.id === event.id);
+    if (!e) {
+      handledEvents.push(event);
+      cb(null, event);
+    } else cb({ message: "Event already handle", status: 403 });
+
+    if (handledEvents.length > 50) handledEvents.splice(20);
+  };
+};

package/systemlynx/LoadBalancer/components/Router.js

@@ -0,0 +1,37 @@
+const HttpClient = require("../../HttpClient/HttpClient")();
+
+module.exports = function Router(server) {
+  const CloneManager = this;
+
+  const addService = ({ route, locations }) => {
+    server.get(route, recursiveGetService);
+
+    let location_index = -1;
+    function recursiveGetService(req, res) {
+      if (locations.length === 0)
+        return res.status(404).json({
+          message: `No services found on requested route: ${route}`,
+          locations
+        });
+
+      location_index++;
+      location_index = location_index < locations.length ? location_index : 0;
+      const url = locations[location_index];
+
+      HttpClient.request({ url }, (err, connData) => {
+        if (err) {
+          for (i = 0; i < locations.length; i++) {
+            if (locations[i] === url) {
+              locations.splice(i, 1);
+              console.warn(`(LoadBalancer): Removing (${url}) URL from ${route} Service`);
+              CloneManager.emit("location_removed", { url, route, locations });
+            }
+          }
+          recursiveGetService(req, res);
+        } else res.json(connData);
+      });
+    }
+  };
+
+  return { addService };
+};