systemlynx 1.19.12 → 1.20.0

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;
 };

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;

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"
       )