systemlynx 1.19.12 → 1.21.0

package/systemlynx/Dispatcher/Dispatcher.test.js

@@ -3,15 +3,18 @@ const Dispatcher = require("./Dispatcher");
 
 describe("createDispatcher", () => {
   const dispatcher = new Dispatcher();
-  it("should return an EventDispatcher object with methods on and emit", async () => {
+
+  it("should return an EventDispatcher object with on, emit, $clearEvent, once, and destroy", () => {
     expect(dispatcher)
       .to.be.an("object")
-      .that.has.all.keys("on", "emit", "$clearEvent")
       .that.respondsTo("on")
       .that.respondsTo("emit")
-      .that.respondsTo("$clearEvent");
+      .that.respondsTo("$clearEvent")
+      .that.respondsTo("once")
+      .that.respondsTo("destroy");
   });
-  it("Should be able to emit and handle events", (done) => {
+
+  it("should emit and handle events", (done) => {
     dispatcher.on("test", (data) => {
       expect(data).to.deep.equal({ testPassed: true });
       done();
@@ -19,4 +22,84 @@ describe("createDispatcher", () => {
 
     dispatcher.emit("test", { testPassed: true });
   });
+
+  it("on() should return an unsubscribe function that removes the listener", (done) => {
+    const d = new Dispatcher();
+    let callCount = 0;
+
+    const unsubscribe = d.on("ping", () => callCount++);
+    expect(unsubscribe).to.be.a("function");
+
+    d.emit("ping");
+    unsubscribe();
+    d.emit("ping");
+
+    setTimeout(() => {
+      expect(callCount).to.equal(1);
+      done();
+    }, 0);
+  });
+
+  it("eventId should replace the existing listener on re-register", (done) => {
+    const d = new Dispatcher();
+    let callCount = 0;
+
+    d.on("ping", () => callCount++, { eventId: "my-listener" });
+    d.on("ping", () => callCount++, { eventId: "my-listener" });
+
+    d.emit("ping");
+
+    setTimeout(() => {
+      expect(callCount).to.equal(1);
+      done();
+    }, 0);
+  });
+
+  it("once() should fire the callback only once", (done) => {
+    const d = new Dispatcher();
+    let callCount = 0;
+
+    d.once("ping", () => callCount++);
+    d.emit("ping");
+    d.emit("ping");
+    d.emit("ping");
+
+    setTimeout(() => {
+      expect(callCount).to.equal(1);
+      done();
+    }, 0);
+  });
+
+  it("destroy() should remove all listeners", (done) => {
+    const d = new Dispatcher();
+    let callCount = 0;
+
+    d.on("a", () => callCount++);
+    d.on("b", () => callCount++);
+    d.destroy();
+    d.emit("a");
+    d.emit("b");
+
+    setTimeout(() => {
+      expect(callCount).to.equal(0);
+      done();
+    }, 0);
+  });
+
+  it("$clearEvent should still work with a named function (backward compat)", (done) => {
+    const d = new Dispatcher();
+    let callCount = 0;
+
+    function myHandler() { callCount++; }
+
+    d.on("ping", myHandler);
+    d.emit("ping");
+    d.$clearEvent("ping", myHandler);
+    d.emit("ping");
+
+    setTimeout(() => {
+      expect(callCount).to.equal(1);
+      done();
+    }, 0);
+  });
 });

package/systemlynx/LoadBalancer/tests/LoadBalancer.test.js

@@ -26,8 +26,10 @@ describe("LoadBalancer()", () => {
       .to.be.an("object")
       .that.has.all.keys(
         "on",
+        "once",
         "emit",
         "$clearEvent",
+        "destroy",
         "before",
         "after",
         "clones",
@@ -93,9 +95,11 @@ describe("LoadBalancer.clones (Module)", () => {
       .to.be.an("Object")
       .that.has.all.keys(
         "on",
+        "once",
         "emit",
         "$emit",
         "$clearEvent",
+        "destroy",
         "before",
         "after",
         "register",

package/systemlynx/ServerManager/components/Router.js

@@ -34,6 +34,7 @@ module.exports = function createRouter(server, config) {
       [`/${route}`],
       (req, res, next) => {
         req.module_name = module_name;
+        req.moduleName = module_name;
         req.fn = method;
         req.Module = Module;
         req.module = Module;
@@ -57,6 +58,18 @@ module.exports = function createRouter(server, config) {
     const sendError = (error) => {
       const status = (error || {}).status || 500;
       const message = (error || {}).message || unhandledMessage;
+      // Emit a local-only "error" event on the module so server-side observers
+      // (e.g. a SystemView plugin) can monitor failures. $emit does not broadcast
+      // over websockets — the failing client already receives the error over HTTP.
+      if (Module && typeof Module.$emit === "function")
+        Module.$emit("error", {
+          module_name,
+          fn,
+          arguments: req.arguments,
+          status,
+          message,
+          error,
+        });
       res.status(status).json({
         ...presets,
         ...error,

package/systemlynx/ServerManager/components/SocketEmitter.js

@@ -6,13 +6,19 @@ module.exports = function SocketEmitter(namespace, WebSocket) {
     (this || {}).on && (this || {}).emit ? this : createDispatcher.apply(this);
 
   const socket = WebSocket.of(`/${namespace}`);
+
+  socket.on("connection", (clientSocket) => {
+    clientSocket.on("subscribe", (name) => clientSocket.join(name));
+    clientSocket.on("unsubscribe", (name) => clientSocket.leave(name));
+  });
+
   //use $emit to emit events locally only
   Emitter.$emit = Emitter.emit;
 
   Emitter.emit = (name, data) => {
     const id = shortid();
     const type = "WebSocket";
-    socket.emit("dispatch", { id, name, data, type });
+    socket.to(name).emit(name, { id, data, type });
     //emit the same event locally
     Emitter.$emit(name, data);
   };

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

@@ -11,19 +11,22 @@ describe("SocketEmiiter", () => {
     SocketServer.listen(port);
     const emmiter = SocketEmiiter(namespace, WebSocket);
 
-    setTimeout(() => {
-      emmiter.emit(eventName, { testPassed: true });
-    }, 500);
     const socket = io.connect(`http://localhost:${port}/${namespace}`);
-    socket.on("dispatch", dispatch => {
-      expect(dispatch)
+    socket.on("connect", () => {
+      console.log(`socket connected to namespace: ${namespace}`);
+      socket.emit("subscribe", eventName);
+    });
+    socket.on(eventName, (payload) => {
+      expect(payload)
         .to.be.an("object")
-        .that.has.all.keys("id", "name", "data", "type");
-      expect(dispatch.name).to.equal(eventName);
-      expect(dispatch.data).to.deep.equal({ testPassed: true });
+        .that.has.all.keys("id", "data", "type");
+      expect(payload.data).to.deep.equal({ testPassed: true });
       done();
     });
     socket.on("disconnect", () => console.log("---------> disconnect"));
-    socket.on("connect", () => console.log(`socket connected to namespace: ${namespace}`));
+
+    setTimeout(() => {
+      emmiter.emit(eventName, { testPassed: true });
+    }, 500);
   });
 });

package/systemlynx/Service/Service.test.js

@@ -70,7 +70,7 @@ describe("Service.module(constructor)", () => {
 
     expect(mod)
       .to.be.an("Object")
-      .that.has.all.keys("on", "emit", "$clearEvent", "before", "after", "test", "test2")
+      .that.has.all.keys("on", "once", "emit", "$clearEvent", "destroy", "before", "after", "test", "test2")
       .that.respondsTo("on")
       .that.respondsTo("emit")
       .that.respondsTo("$clearEvent")
@@ -205,8 +205,10 @@ describe("Service.module(object)", () => {
         "action1",
         "action2",
         "on",
+        "once",
         "emit",
         "$clearEvent",
+        "destroy",
         "before",
         "after"
       )