systemlynx 1.1.0

package/systemlynx/App/components/loadServices.js

@@ -0,0 +1,28 @@
+const Client = require("../../Client/Client")();
+module.exports = ({ Services, App }) => {
+  return Promise.all(
+    Services.map(serviceData => {
+      const { url, limit, wait, name, onLoad } = serviceData;
+      return new Promise(resolve => {
+        Client.loadService(url, { limit, wait })
+          .then(service => {
+            serviceData.client = service;
+            if (typeof onLoad === "function") {
+              onLoad(serviceData.client);
+              serviceData.client.on("reconnect", onLoad);
+            }
+            App.emit("service_loaded", serviceData.client).emit(
+              `service_loaded:${name}`,
+              serviceData.client
+            );
+            resolve();
+          })
+          .catch(err => {
+            console.warn(err);
+            App.emit("failed_connection", { err, ...serviceData });
+            resolve();
+          });
+      });
+    })
+  );
+};

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

@@ -0,0 +1,354 @@
+const { expect } = require("chai");
+const AppFactory = require("../App");
+const HttpClient = require("../../HttpClient/HttpClient")();
+const ServiceFactory = require("../../Service/Service");
+
+describe("App Factory", () => {
+  it("should return a SystemLynx App", () => {
+    const App = AppFactory();
+
+    expect(App)
+      .to.be.an("object")
+      .that.has.all.keys(
+        "module",
+        "ServerModule",
+        "on",
+        "emit",
+        "startService",
+        "loadService",
+        "onLoad",
+        "config"
+      )
+      .that.respondsTo("module")
+      .that.respondsTo("ServerModule")
+      .that.respondsTo("on")
+      .that.respondsTo("emit")
+      .that.respondsTo("startService")
+      .that.respondsTo("loadService")
+      .that.respondsTo("onLoad")
+      .that.respondsTo("config");
+  });
+});
+describe("App: Loading Services", () => {
+  it("should be able to use App.loadService(str_url) to load as hosted Service", async () => {
+    const Service = ServiceFactory();
+    const route = "test-service";
+    const port = "8503";
+
+    Service.ServerModule("mod", function () {
+      this.test = () => {};
+      this.test2 = () => {};
+    });
+
+    await Service.startService({ route, port });
+
+    await new Promise((resolve) => {
+      const App = AppFactory();
+      App.loadService("test", `http://localhost:${port}/${route}`).on(
+        "init_complete",
+        (system) => {
+          expect(system.Services[0]).to.be.an("object");
+
+          expect(system.Services[0].client)
+            .to.be.an("object")
+            .that.has.all.keys("emit", "on", "resetConnection", "disconnect", "mod")
+            .that.respondsTo("emit")
+            .that.respondsTo("on")
+            .that.respondsTo("resetConnection")
+            .that.respondsTo("disconnect");
+          resolve();
+        }
+      );
+    });
+  });
+
+  it("should be able to use App.loadService(...).onLoad(handler) to fire a callback when the Service connects", async () => {
+    const Service = ServiceFactory();
+    const route = "test-service";
+    const port = "8422";
+    const url = `http://localhost:${port}/${route}`;
+
+    Service.ServerModule("mod", function () {
+      this.test = () => {};
+      this.test2 = () => {};
+    });
+
+    await Service.startService({ route, port });
+
+    await new Promise((resolve) => {
+      const App = AppFactory();
+      App.loadService("test", url).onLoad((test) => {
+        expect(test)
+          .to.be.an("object")
+          .that.has.all.keys("emit", "on", "resetConnection", "disconnect", "mod")
+          .that.respondsTo("emit")
+          .that.respondsTo("on")
+          .that.respondsTo("resetConnection")
+          .that.respondsTo("disconnect");
+        resolve();
+      });
+    });
+  });
+
+  it('should use App.on("service_loaded[:name]", callback) to fire when a Service has loaded', async () => {
+    const Service = ServiceFactory();
+    const route = "test-service";
+    const port = "8423";
+    const url = `http://localhost:${port}/${route}`;
+    Service.ServerModule("mod", function () {
+      this.test = () => {};
+      this.test2 = () => {};
+    });
+
+    await Service.startService({ route, port });
+
+    await new Promise((resolve) => {
+      const App = AppFactory();
+      App.loadService("test", url)
+        .on("service_loaded", (test) => {
+          expect(test)
+            .to.be.an("object")
+            .that.has.all.keys("emit", "on", "resetConnection", "disconnect", "mod")
+            .that.respondsTo("emit")
+            .that.respondsTo("on")
+            .that.respondsTo("resetConnection");
+        })
+        .on("service_loaded:test", (test) => {
+          expect(test)
+            .to.be.an("object")
+            .that.has.all.keys("emit", "on", "resetConnection", "disconnect", "mod")
+            .that.respondsTo("emit")
+            .that.respondsTo("on")
+            .that.respondsTo("resetConnection");
+          resolve();
+        });
+    });
+  });
+
+  it("should be accessible to SystemObjects via the module.useService method", async () => {
+    const Service = ServiceFactory();
+    const route = "test-service";
+    const port = "8442";
+    const url = `http://localhost:${port}/${route}`;
+
+    Service.ServerModule("mod", function () {
+      this.test = () => {};
+      this.test2 = () => {};
+    });
+
+    await Service.startService({ route, port });
+
+    await new Promise((resolve) => {
+      const App = AppFactory();
+      App.loadService("test", url)
+        .module("module_name", function () {
+          const test = this.useService("test");
+          expect(test)
+            .to.be.an("object")
+            .that.has.all.keys("emit", "on", "resetConnection", "disconnect", "mod")
+            .that.respondsTo("emit")
+            .that.respondsTo("on")
+            .that.respondsTo("resetConnection");
+          resolve();
+        })
+        .on("init_complete", resolve);
+    });
+  });
+});
+
+describe("App SystemObjects: Initializing Modules,  ServerModules and configurations", () => {
+  it("should be able to use App.module to initialize a module", async () => {
+    const App = AppFactory();
+    return new Promise((resolve) =>
+      App.module("test", function () {
+        expect(this)
+          .to.be.an("object")
+          .that.has.all.keys("useModule", "useService", "useConfig", "on", "emit")
+          .that.respondsTo("useModule")
+          .that.respondsTo("useService")
+          .that.respondsTo("useConfig")
+          .that.respondsTo("on")
+          .that.respondsTo("emit");
+      }).module("test2", function () {
+        expect(this)
+          .to.be.an("object")
+          .that.has.all.keys("useModule", "useService", "useConfig", "on", "emit")
+          .that.respondsTo("useModule")
+          .that.respondsTo("useService")
+          .that.respondsTo("useConfig")
+          .that.respondsTo("on")
+          .that.respondsTo("emit");
+        resolve();
+      })
+    );
+  });
+  it("should be able to use App.startService to start as Service", async () => {
+    const App = AppFactory();
+    const route = "test-service";
+    const port = "8493";
+    const url = `http://localhost:${port}/${route}`;
+
+    await new Promise((resolve) =>
+      App.startService({ route, port }).on("init_complete", resolve)
+    );
+    const connData = await HttpClient.request({ url });
+
+    expect(connData)
+      .to.be.an("Object")
+      .that.has.all.keys(
+        "SystemLynxService",
+        "host",
+        "port",
+        "modules",
+        "route",
+        "namespace",
+        "serviceUrl"
+      )
+      .that.has.property("modules")
+      .that.is.an("array").that.is.empty;
+    expect(connData.serviceUrl).to.equal(url);
+  });
+  it("should be able to use App.ServerModule to add a hosted ServerModule to the Service", async () => {
+    const App = AppFactory();
+    const route = "test-service";
+    const port = "8494";
+    const url = `http://localhost:${port}/${route}`;
+    await new Promise((resolve) =>
+      App.startService({ route, port })
+        .ServerModule("mod", function () {
+          this.test = () => {};
+          this.test2 = () => {};
+        })
+        .ServerModule("mod2", function () {
+          this.test = () => {};
+          this.test2 = () => {};
+        })
+        .on("init_complete", resolve)
+    );
+
+    const connData = await HttpClient.request({ url });
+
+    expect(connData)
+      .to.be.an("Object")
+      .that.has.all.keys(
+        "SystemLynxService",
+        "host",
+        "port",
+        "modules",
+        "route",
+        "namespace",
+        "serviceUrl"
+      )
+      .that.has.property("modules")
+      .that.is.an("array");
+    expect(connData.modules).to.have.a.lengthOf(2);
+    expect(connData.modules[0])
+      .to.be.an("Object")
+      .that.has.all.keys("namespace", "route", "name", "methods")
+      .that.has.property("methods")
+      .that.is.an("array");
+    expect(connData.modules[0].methods, [
+      { method: "PUT", name: "test" },
+      { method: "PUT", name: "test2" },
+    ]);
+  });
+
+  it('should be able to use App.on("init_complete", callback) fire a callback when App initialization is complete', async () => {
+    const App = AppFactory();
+
+    App.ServerModule("mod", function () {
+      this.test = () => {};
+      this.test2 = () => {};
+    }).module("mod", function () {
+      this.test = () => {};
+      this.test2 = () => {};
+    });
+
+    await new Promise((resolve) =>
+      App.on("init_complete", (system) => {
+        expect(system)
+          .to.be.an("object")
+          .that.has.all.keys(
+            "Services",
+            "Service",
+            "Modules",
+            "ServerModules",
+            "configurations",
+            "App",
+            "routing",
+            "useService",
+            "useModule",
+            "useConfig"
+          );
+        resolve();
+      })
+    );
+  });
+
+  it("should be able to use App.config(constructor) to construct a configuartion module", async () => {
+    const App = AppFactory();
+
+    App.ServerModule("mod", function () {
+      this.test = () => {};
+      this.test2 = () => {};
+    })
+      .module("mod", function () {
+        this.test = () => {};
+        this.test2 = () => {};
+      })
+      .config(function (next) {
+        this.test = () => {};
+        this.test2 = () => {};
+        next();
+      });
+
+    await new Promise((resolve) =>
+      App.on("init_complete", ({ configurations }) => {
+        expect(configurations)
+          .to.be.an("object")
+          .that.has.all.keys("module", "__constructor")
+          .that.has.property("module")
+          .that.is.an("object")
+          .that.has.all.keys("useService", "useModule", "useConfig", "test", "test2");
+
+        resolve();
+      })
+    );
+  });
+});
+
+describe("SystemObjects", () => {
+  it("should be able to use this.useModule and this.useService within modules and ServerModule", () => {
+    const App = AppFactory();
+    App.module("mod1", function () {
+      expect(this)
+        .to.be.an("object")
+        .that.respondsTo("useService")
+        .that.respondsTo("useModule")
+        .that.respondsTo("useConfig");
+
+      this.testPassed = true;
+    })
+      .module("mod2", function () {
+        expect(this)
+          .to.be.an("object")
+          .that.respondsTo("useService")
+          .that.respondsTo("useModule")
+          .that.respondsTo("useConfig");
+        const mod1 = this.useModule("mod1");
+        const config = this.useConfig();
+        expect(mod1.testPassed).to.equal(true);
+        expect(config.configPassed).to.equal(true);
+      })
+      .config(function (next) {
+        expect(this)
+          .to.be.an("object")
+          .that.respondsTo("useService")
+          .that.respondsTo("useModule")
+          .that.respondsTo("useConfig");
+        this.configPassed = true;
+        next();
+      });
+    return new Promise((resolve) => App.on("init_complete", () => resolve()));
+  });
+});

package/systemlynx/Client/Client.js

@@ -0,0 +1,42 @@
+"use strict";
+const loadConnectionData = require("./components/loadConnectionData");
+const SocketDispatcher = require("./components/SocketDispatcher");
+const ClientModule = require("./components/ClientModule");
+
+module.exports = function SystemLynxClient() {
+  const Client = {};
+  Client.loadedServices = {};
+
+  Client.loadService = async (url, options = {}) => {
+    if (Client.loadedServices[url] && !options.forceReload)
+      return Client.loadedServices[url];
+
+    const connData = await loadConnectionData(url, options);
+    const Service = SocketDispatcher(connData.namespace);
+    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]);
+
+      modules.forEach(({ namespace, route, name }) =>
+        Service[name].__setConnection(host, port, route, namespace)
+      );
+
+      if (typeof cb === "function") cb();
+    };
+
+    connData.modules.forEach(
+      (mod) => (Service[mod.name] = ClientModule(mod, connData, Service.resetConnection))
+    );
+
+    Service.on("disconnect", Service.resetConnection);
+
+    await new Promise((resolve) => Service.on("connect", resolve));
+    return Service;
+  };
+
+  return Client;
+};

package/systemlynx/Client/components/ClientModule.js

@@ -0,0 +1,28 @@
+"use strict";
+const ServiceRequestHandler = require("./ServiceRequestHandler");
+const SocketDispatcher = require("./SocketDispatcher");
+module.exports = function SystemLynxClientModule(
+  { methods, namespace, route },
+  { port, host },
+  resetConnection
+) {
+  const events = {};
+  const ClientModule = this || {};
+
+  ClientModule.__setConnection = (host, port, route, namespace) => {
+    ClientModule.__connectionData = () => ({ route, host, port });
+    SocketDispatcher.apply(ClientModule, [namespace, events]);
+  };
+
+  ClientModule.__setConnection(host, port, route, namespace);
+
+  methods.forEach(({ method, fn }) => {
+    ClientModule[fn] = ServiceRequestHandler.apply(ClientModule, [
+      method,
+      fn,
+      resetConnection,
+    ]);
+  });
+
+  return ClientModule;
+};

package/systemlynx/Client/components/ServiceRequestHandler.js

@@ -0,0 +1,62 @@
+"use strict";
+const HttpClient = require("../../HttpClient/HttpClient")();
+const isObject = (value) =>
+  typeof value === "object" ? (!value ? false : !Array.isArray(value)) : false;
+
+const makeQuery = (data) =>
+  Object.getOwnPropertyNames(data).reduce(
+    (query, name) => (query += `${name}=${data[name]}&`),
+    "?"
+  );
+module.exports = function ServiceRequestHandler(method, fn, resetConnection) {
+  const ClientModule = this;
+
+  return function sendRequest() {
+    const __arguments = Array.from(arguments);
+
+    const tryRequest = (cb, errCount = 0) => {
+      const { route, port, host } = ClientModule.__connectionData();
+      const singleFileURL = `http://${host}:${port}/sf${route}/${fn}`;
+      const multiFileURL = `http://${host}:${port}/mf${route}/${fn}`;
+      const defaultURL = `http://${host}:${port}${route}/${fn}`;
+      const { file, files } = __arguments[0] || {};
+      const url = file ? singleFileURL : files ? multiFileURL : defaultURL;
+
+      if (url === defaultURL)
+        HttpClient.request({
+          url: `${url}${
+            method === "get" && isObject(__arguments[0]) ? makeQuery(__arguments[0]) : ""
+          }`,
+          method,
+          body: { __arguments },
+        })
+          .then((results) => cb(null, results))
+          .catch((err) => ErrorHandler(err, errCount, cb));
+      else
+        HttpClient.upload({
+          url,
+          method,
+          formData: { ...__arguments[0], __arguments },
+        })
+          .then((results) => cb(null, results))
+          .catch((err) => ErrorHandler(err, errCount, cb));
+    };
+
+    const ErrorHandler = (err, errCount, cb) => {
+      if (err.SystemLynxServiceError) {
+        cb(err);
+      } else if (errCount <= 3) {
+        console.log(err);
+        errCount++;
+        resetConnection(() => tryRequest(cb, errCount));
+      } else throw Error(`(SystemLynxServiceError): Invalid route:${err}`);
+    };
+
+    return new Promise((resolve, reject) =>
+      tryRequest((err, results) => {
+        if (err) reject(err);
+        else resolve(results.returnValue);
+      })
+    );
+  };
+};

package/systemlynx/Client/components/SocketDispatcher.js

@@ -0,0 +1,20 @@
+"use strict";
+const io = require("socket.io-client");
+const SystemLynxDispatcher = require("../../Dispatcher/Dispatcher");
+
+module.exports = function SocketDispatcher(namespace, events = {}) {
+  const dispatcher =
+    (this || {}).on && (this || {}).emit
+      ? this
+      : SystemLynxDispatcher.apply(this, [events]);
+  const socket = io.connect(namespace);
+  socket.on("dispatch", (event) => dispatcher.emit(event.name, event.data, event));
+  socket.on("disconnect", () => {
+    socket.disconnect();
+    dispatcher.emit("disconnect");
+  });
+  socket.on("connect", () => dispatcher.emit("connect"));
+
+  dispatcher.disconnect = () => socket.disconnect();
+  return dispatcher;
+};

package/systemlynx/Client/components/loadConnectionData.js

@@ -0,0 +1,18 @@
+const HttpClient = require("../../HttpClient/HttpClient")();
+
+module.exports = function loadConnectionData(url, { limit = 10, wait = 150 } = {}) {
+  const errors = [];
+
+  return new Promise(function getData(resolve) {
+    HttpClient.request({ method: "GET", url }, (err, results) => {
+      if (err) {
+        errors.push(err);
+
+        if (errors.length < limit)
+          setTimeout(() => getData(resolve), errors.length * wait);
+        else
+          throw `SystemLynx loadConnectionData() Error: url:${url}, attempts:${errors.length}`;
+      } else resolve(results);
+    });
+  });
+};