systemlynx 1.19.12 → 1.21.0

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

@@ -12,19 +12,25 @@ describe("createApp()", () => {
       .that.has.all.keys(
         "module",
         "on",
+        "once",
         "emit",
         "before",
         "after",
         "$clearEvent",
+        "destroy",
         "use",
         "startService",
         "loadService",
         "onLoad",
         "config",
         "server",
-        "WebSocket"
+        "WebSocket",
+        "getModule",
+        "getModules"
       )
       .that.respondsTo("module")
+      .that.respondsTo("getModule")
+      .that.respondsTo("getModules")
       .that.respondsTo("on")
       .that.respondsTo("emit")
       .that.respondsTo("$clearEvent")
@@ -62,7 +68,9 @@ describe("App: Loading Services", () => {
             .that.has.all.keys(
               "emit",
               "on",
+              "once",
               "$clearEvent",
+              "destroy",
               "resetConnection",
               "disconnect",
               "headers",
@@ -103,7 +111,9 @@ describe("App: Loading Services", () => {
           .that.has.all.keys(
             "emit",
             "on",
+            "once",
             "$clearEvent",
+            "destroy",
             "resetConnection",
             "disconnect",
             "headers",
@@ -136,48 +146,52 @@ describe("App: Loading Services", () => {
 
     await new Promise((resolve) => {
       const App = createApp();
-      App.loadService("test", url)
-        .on("service_loaded", (test) => {
-          expect(test)
-            .to.be.an("object")
-            .that.has.all.keys(
-              "emit",
-              "on",
-              "$clearEvent",
-              "resetConnection",
-              "disconnect",
-              "headers",
-              "setHeaders",
-              "mod"
-            )
-            .that.respondsTo("emit")
-            .that.respondsTo("$clearEvent")
-            .that.respondsTo("on")
-            .that.respondsTo("resetConnection")
-            .that.respondsTo("headers")
-            .that.respondsTo("setHeaders");
-        })
-        .on("service_loaded:test", (test) => {
-          expect(test)
-            .to.be.an("object")
-            .that.has.all.keys(
-              "emit",
-              "on",
-              "$clearEvent",
-              "resetConnection",
-              "disconnect",
-              "headers",
-              "setHeaders",
-              "mod"
-            )
-            .that.respondsTo("emit")
-            .that.respondsTo("$clearEvent")
-            .that.respondsTo("on")
-            .that.respondsTo("resetConnection")
-            .that.respondsTo("headers")
-            .that.respondsTo("setHeaders");
-          resolve();
-        });
+      App.loadService("test", url);
+      App.on("service_loaded", (test) => {
+        expect(test)
+          .to.be.an("object")
+          .that.has.all.keys(
+            "emit",
+            "on",
+            "once",
+            "$clearEvent",
+            "destroy",
+            "resetConnection",
+            "disconnect",
+            "headers",
+            "setHeaders",
+            "mod"
+          )
+          .that.respondsTo("emit")
+          .that.respondsTo("$clearEvent")
+          .that.respondsTo("on")
+          .that.respondsTo("resetConnection")
+          .that.respondsTo("headers")
+          .that.respondsTo("setHeaders");
+      });
+      App.on("service_loaded:test", (test) => {
+        expect(test)
+          .to.be.an("object")
+          .that.has.all.keys(
+            "emit",
+            "on",
+            "once",
+            "$clearEvent",
+            "destroy",
+            "resetConnection",
+            "disconnect",
+            "headers",
+            "setHeaders",
+            "mod"
+          )
+          .that.respondsTo("emit")
+          .that.respondsTo("$clearEvent")
+          .that.respondsTo("on")
+          .that.respondsTo("resetConnection")
+          .that.respondsTo("headers")
+          .that.respondsTo("setHeaders");
+        resolve();
+      });
     });
   });
 
@@ -204,7 +218,9 @@ describe("App: Loading Services", () => {
             .that.has.all.keys(
               "emit",
               "on",
+              "once",
               "$clearEvent",
+              "destroy",
               "resetConnection",
               "disconnect",
               "headers",
@@ -236,8 +252,10 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
             "useService",
             "useConfig",
             "on",
+            "once",
             "emit",
             "$clearEvent",
+            "destroy",
             "before",
             "after"
           )
@@ -257,8 +275,10 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
             "useService",
             "useConfig",
             "on",
+            "once",
             "emit",
             "$clearEvent",
+            "destroy",
             "before",
             "after"
           )
@@ -377,6 +397,66 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
     );
   });
 
+  it("should expose live modules via App.getModule(name) and App.getModules() after ready", async () => {
+    const App = createApp();
+    const route = "test-service";
+    const port = "8495";
+
+    App.module("mod", function () {
+      this.test = () => {};
+    }).module("mod2", function () {
+      this.test = () => {};
+    });
+
+    // before initialization the live module reference does not exist yet
+    expect(App.getModule("mod")).to.equal(undefined);
+    expect(App.getModules()).to.be.an("object").that.is.empty;
+
+    await new Promise((resolve) => App.startService({ route, port }).on("ready", resolve));
+
+    const mod = App.getModule("mod");
+    expect(mod).to.be.an("object").that.respondsTo("on").that.respondsTo("emit");
+    expect(App.getModule("missing")).to.equal(undefined);
+
+    const modules = App.getModules();
+    expect(modules).to.be.an("object").that.has.all.keys("mod", "mod2");
+    expect(modules.mod).to.respondTo("on").that.respondsTo("emit");
+  });
+
+  it("should emit a local 'error' event on the module when a method throws back to the client", async () => {
+    const App = createApp();
+    const route = "test-service";
+    const port = "8496";
+
+    App.module("errMod", function () {
+      this.boom = () => {
+        throw { status: 400, message: "boom went the method" };
+      };
+    });
+
+    await new Promise((resolve) => App.startService({ route, port }).on("ready", resolve));
+
+    const errMod = App.getModule("errMod");
+    const errorEvent = new Promise((resolve) => errMod.on("error", resolve));
+
+    const url = `http://localhost:${port}/${route}/errMod/boom`;
+    try {
+      await HttpClient.request({ method: "POST", url, body: { __arguments: [{ x: 1 }] } });
+    } catch (e) {
+      // expected — the method throws and the error is returned over HTTP
+    }
+
+    const info = await errorEvent;
+    expect(info)
+      .to.be.an("object")
+      .that.has.all.keys("module_name", "fn", "arguments", "status", "message", "error");
+    expect(info.module_name).to.equal("errMod");
+    expect(info.fn).to.equal("boom");
+    expect(info.status).to.equal(400);
+    expect(info.message).to.equal("boom went the method");
+    expect(info.arguments).to.deep.equal([{ x: 1 }]);
+  });
+
   it("should be able to use App.config(constructor) to construct a configuration module", async () => {
     const App = createApp();
 
@@ -472,19 +552,19 @@ describe("SystemContext", () => {
           .that.respondsTo("useConfig");
         this.configPassed = true;
         next();
-      })
-      .on("ready", 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);
-      })
-      .on("ready", function () {
+      });
+    App.on("ready", 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);
+    });
+    App.on("ready", function () {
         expect(this)
           .to.be.an("object")
           .that.respondsTo("useService")
@@ -543,7 +623,8 @@ describe("SystemContext", () => {
           expect(event.type).to.equal("WebSocket");
           resolve();
         });
-        EventTesterModule.sendEvent(eventName);
+        // small delay so "subscribe" WebSocket message is processed before the HTTP call triggers the emit
+        setTimeout(() => EventTesterModule.sendEvent(eventName), 100);
       })
     );
   });

package/systemlynx/Client/components/ServiceRequestHandler.js

@@ -17,13 +17,13 @@ const extractFilesFromArguments = (__arguments) => {
 
   __arguments.forEach((arg) => {
     if (isObject(arg)) {
-      if ("file" in arg) {
+      if (arg.file) {
         if (foundFile)
           throw new Error("Only one file or files allowed across arguments.");
         foundFile = arg.file;
         fileType = "file";
         arg.file = "__file__";
-      } else if ("files" in arg) {
+      } else if (arg.files) {
         if (foundFile)
           throw new Error("Only one file or files allowed across arguments.");
         foundFile = arg.files;

package/systemlynx/Client/components/SocketDispatcher.js

@@ -2,6 +2,8 @@
 const io = require("socket.io-client");
 const createDispatcher = require("../../Dispatcher/Dispatcher");
 
+const RESERVED = new Set(["connect", "disconnect", "error", "connect_error"]);
+
 module.exports = function SocketDispatcher(
   { namespace, socketPath: path },
   events = {},
@@ -13,8 +15,82 @@ module.exports = function SocketDispatcher(
       : createDispatcher.apply(this, [events, systemContext]);
 
   const socket = io.connect(namespace, { path });
+  const subscriptionCounts = new Map();
+
+  const trackSubscribe = (name) => {
+    const n = (subscriptionCounts.get(name) || 0) + 1;
+    subscriptionCounts.set(name, n);
+    if (n === 1) socket.emit("subscribe", name);
+  };
+
+  const trackUnsubscribe = (name) => {
+    const n = (subscriptionCounts.get(name) || 0) - 1;
+    if (n <= 0) {
+      subscriptionCounts.delete(name);
+      socket.emit("unsubscribe", name);
+    } else {
+      subscriptionCounts.set(name, n);
+    }
+  };
+
+  const originalOn = dispatcher.on.bind(dispatcher);
+  dispatcher.on = function (name, cb, options) {
+    const unsub = originalOn(name, cb, options);
+    if (!RESERVED.has(name)) {
+      trackSubscribe(name);
+      return function () {
+        unsub();
+        trackUnsubscribe(name);
+      };
+    }
+    return unsub;
+  };
 
-  socket.on("dispatch", (event) => dispatcher.emit(event.name, event.data, event));
+  const originalOnce = dispatcher.once.bind(dispatcher);
+  dispatcher.once = function (name, cb, options) {
+    if (RESERVED.has(name)) return originalOnce(name, cb, options);
+    let done = false;
+    trackSubscribe(name);
+    const unsub = originalOnce(
+      name,
+      function (...args) {
+        if (!done) {
+          done = true;
+          trackUnsubscribe(name);
+          cb(...args);
+        }
+      },
+      options
+    );
+    return function () {
+      if (!done) {
+        done = true;
+        unsub();
+        trackUnsubscribe(name);
+      }
+    };
+  };
+
+  const originalClearEvent = dispatcher.$clearEvent.bind(dispatcher);
+  dispatcher.$clearEvent = function (name) {
+    originalClearEvent(name);
+    if (subscriptionCounts.has(name)) {
+      subscriptionCounts.delete(name);
+      socket.emit("unsubscribe", name);
+    }
+  };
+
+  const originalDestroy = dispatcher.destroy.bind(dispatcher);
+  dispatcher.destroy = function () {
+    subscriptionCounts.forEach((_, name) => socket.emit("unsubscribe", name));
+    subscriptionCounts.clear();
+    originalDestroy();
+  };
+
+  socket.onAny((name, payload) => {
+    const event = { id: payload.id, name, data: payload.data, type: payload.type };
+    dispatcher.emit(name, payload.data, event);
+  });
 
   socket.on("disconnect", () => {
     socket.disconnect();
@@ -22,6 +98,9 @@ module.exports = function SocketDispatcher(
   });
 
   socket.on("connect", () => {
+    subscriptionCounts.forEach((count, name) => {
+      if (count > 0) socket.emit("subscribe", name);
+    });
     dispatcher.emit("connect");
   });
 

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

@@ -46,7 +46,9 @@ describe("Client", () => {
       .that.has.all.keys(
         "emit",
         "on",
+        "once",
         "$clearEvent",
+        "destroy",
         "resetConnection",
         "disconnect",
         "headers",
@@ -66,7 +68,9 @@ describe("Client", () => {
       .that.has.all.keys(
         "emit",
         "on",
+        "once",
         "$clearEvent",
+        "destroy",
         "disconnect",
         "headers",
         "setHeaders",

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

@@ -11,6 +11,10 @@ const socket = WebSocket.of(route);
 socket.on("connect", ({ id }) => {
   console.log(`socket connected with id:${id}`);
 });
+socket.on("connection", (clientSocket) => {
+  clientSocket.on("subscribe", (name) => clientSocket.join(name));
+  clientSocket.on("unsubscribe", (name) => clientSocket.leave(name));
+});
 SocketServer.listen(port);
 
 describe("SocketDispatcher", () => {
@@ -19,7 +23,7 @@ describe("SocketDispatcher", () => {
   it("should return an EventDispatcher object with methods on and emit", async () => {
     expect(dispatcher)
       .to.be.an("object")
-      .that.has.all.keys("on", "emit", "$clearEvent", "disconnect")
+      .that.has.all.keys("on", "once", "emit", "$clearEvent", "destroy", "disconnect")
       .that.respondsTo("on")
       .that.respondsTo("emit")
       .that.respondsTo("$clearEvent")
@@ -32,7 +36,7 @@ describe("SocketDispatcher", () => {
     });
     dispatcher.on("connect", () => console.log(`I'm all the way connected!`));
     setTimeout(
-      () => socket.emit("dispatch", { name: eventName, data: { testPassed: true } }),
+      () => socket.to(eventName).emit(eventName, { id: "test-id", data: { testPassed: true }, type: "WebSocket" }),
       500
     );
   });
@@ -44,7 +48,7 @@ describe("SocketDispatcher.apply()", () => {
   it("should return an EventDispatcher object with methods on and emit", async () => {
     expect(dispatcher)
       .to.be.an("object")
-      .that.has.all.keys("on", "emit", "$clearEvent", "disconnect")
+      .that.has.all.keys("on", "once", "emit", "$clearEvent", "destroy", "disconnect")
       .that.respondsTo("on")
       .that.respondsTo("emit")
       .that.respondsTo("$clearEvent")
@@ -53,14 +57,16 @@ describe("SocketDispatcher.apply()", () => {
   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);
+      expect(event).to.be.an("object").that.has.all.keys("id", "name", "data", "type");
+      expect(event.name).to.equal(eventName);
+      expect(event.data).to.deep.equal({ testPassed: true });
+      expect(event.type).to.equal("WebSocket");
       console.log(`I'm all the way connected too!`);
       done();
     });
 
     setTimeout(
-      () => socket.emit("dispatch", { name: eventName, data: { testPassed: true } }),
+      () => socket.to(eventName).emit(eventName, { id: "test-id", data: { testPassed: true }, type: "WebSocket" }),
       500
     );
   });

package/systemlynx/Dispatcher/Dispatcher.js

@@ -1,49 +1,93 @@
+"use strict";
 const throttle = require("../../utils/throttle");
 
-module.exports = function createDispatcher(events = {}, systemContext) {
+module.exports = function createDispatcher(_, systemContext) {
+  const events = new Map();
   const Dispatcher = this || {};
 
-  Dispatcher.emit = (eventName, data, event) => {
-    if (events[eventName])
-      events[eventName].forEach((callback) =>
-        callback.apply(systemContext, [data, event])
-      );
+  Dispatcher.emit = function (eventName, data, event) {
+    const registry = events.get(eventName);
+    if (!registry) return Dispatcher;
+    for (const listener of registry.values()) {
+      listener(data, event);
+    }
     return Dispatcher;
   };
 
-  Dispatcher.on = (eventName, callback, { limit, interval } = {}) => {
+  Dispatcher.on = function (eventName, callback, { limit, interval, eventId } = {}) {
     if (typeof callback !== "function") return Dispatcher;
-    const name = callback.name;
-    if (typeof interval === "number") callback = throttle(callback, limit, interval);
-    if (!events[eventName]) events[eventName] = [];
-
-    if (name) {
-      //if the function has a name and it already present don't add it
-      const i = events[eventName].findIndex((fn) => fn.name === callback.name);
-      if (i === -1) events[eventName].push(callback);
-      else events[eventName][i] = callback;
-    } else events[eventName].push(callback);
-    return Dispatcher;
+
+    const key = eventId || Symbol();
+    if (!events.has(eventName)) events.set(eventName, new Map());
+    const registry = events.get(eventName);
+    if (registry.has(key)) registry.delete(key);
+
+    let fn = typeof interval === "number" ? throttle(callback, limit, interval) : callback;
+    if (systemContext) fn = fn.bind(systemContext);
+    registry.set(key, fn);
+
+    return function () {
+      const currentRegistry = events.get(eventName);
+      if (!currentRegistry) return;
+      currentRegistry.delete(key);
+      if (currentRegistry.size === 0) events.delete(eventName);
+    };
   };
 
-  Dispatcher.$clearEvent = (eventName, fn) => {
-    if (!events[eventName]) return Dispatcher;
+  Dispatcher.once = function (eventName, callback, { limit, interval, eventId } = {}) {
+    if (typeof callback !== "function") return function () {};
+
+    const key = eventId || Symbol();
+    if (!events.has(eventName)) events.set(eventName, new Map());
+    const registry = events.get(eventName);
+    if (registry.has(key)) registry.delete(key);
+
+    const throttled =
+      typeof interval === "number" ? throttle(callback, limit, interval) : callback;
+
+    const boundFn = function (...args) {
+      registry.delete(key);
+      if (registry.size === 0) events.delete(eventName);
+      return throttled.apply(systemContext, args);
+    };
+
+    registry.set(key, boundFn);
+
+    return function () {
+      const currentRegistry = events.get(eventName);
+      if (!currentRegistry) return;
+      currentRegistry.delete(key);
+      if (currentRegistry.size === 0) events.delete(eventName);
+    };
+  };
+
+  Dispatcher.$clearEvent = function (eventName, fn) {
+    if (!events.get(eventName)) return Dispatcher;
 
     if (!fn) {
-      // Clear all listeners for the given event
-      delete events[eventName];
+      events.delete(eventName);
     } 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.name;
-      });
+      const registry = events.get(eventName);
+      for (const [key, listener] of registry.entries()) {
+        if (listener.name === fn.name) {
+          registry.delete(key);
+          break;
+        }
+      }
+      if (registry.size === 0) events.delete(eventName);
     } else {
       console.error(
-        "SystemLynxError: the second parameter of the Dispatcher.$clearEvent takes the original function  to the event"
+        "SystemLynxError: the second parameter of the Dispatcher.$clearEvent takes the original function to the event"
       );
     }
 
     return Dispatcher;
   };
+
+  Dispatcher.destroy = function () {
+    events.clear();
+    return Dispatcher;
+  };
+
   return Dispatcher;
 };