systemlynx 1.18.12 → 1.20.0

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",
@@ -292,6 +296,9 @@ describe("Service", () => {
       this.save = ({ file, files, message }) => {
         return { file, files, message };
       };
+      this.testOtherParams = (param1, { file, files, message }) => {
+        return { files, message, param1 };
+      };
     });
     await service.startService({
       route,
@@ -311,6 +318,10 @@ describe("Service", () => {
       message: "multi file upload test confirmation",
     });
 
+    const extraParamResponse = await storage.testOtherParams("OtherParamsTest", {
+      files: [TEST_FILE, fs.createReadStream(TEST_FILE)],
+      message: "other params file upload test confirmation",
+    });
     expect(singleFileResponse).to.be.an("object").that.has.all.keys("file", "message");
     expect(singleFileResponse.message).to.be.an("string");
     expect(singleFileResponse.message).to.equal("single file upload test confirmation");
@@ -326,6 +337,21 @@ describe("Service", () => {
     expect(multiFileResponse.files[1]).to.be.an("object");
     expect(multiFileResponse.files[0].originalname).to.equal("test.file.json");
     expect(multiFileResponse.files[1].mimetype).to.equal("application/json");
+
+    expect(extraParamResponse)
+      .to.be.an("object")
+      .that.has.all.keys("files", "message", "param1");
+    expect(extraParamResponse.message).to.be.an("string");
+    expect(extraParamResponse.message).to.equal(
+      "other params file upload test confirmation"
+    );
+    expect(extraParamResponse.param1).to.be.an("string");
+    expect(extraParamResponse.param1).to.equal("OtherParamsTest");
+    expect(extraParamResponse.files).to.be.an("array");
+    expect(extraParamResponse.files[0]).to.be.an("object");
+    expect(extraParamResponse.files[1]).to.be.an("object");
+    expect(extraParamResponse.files[0].originalname).to.equal("test.file.json");
+    expect(extraParamResponse.files[1].mimetype).to.equal("application/json");
   });
 
   it("should maintain service and module level headers on a Client instance", async () => {

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;
@@ -80,11 +81,19 @@ module.exports = function createRouter(server, config) {
     const getArguments = () => {
       const args = body.__arguments || [];
       if (!isEmpty(query) && !args.length) args.push(query);
-      if (isObject(args[0]) && method === "POST")
-        args[0] = { ...args[0], ...(file && { file }), ...(files && { files }) };
       return args;
     };
-    req.arguments = getArguments();
+
+    const args = getArguments();
+
+    args.forEach((arg) => {
+      if (isObject(arg)) {
+        if (arg.file === "__file__") arg.file = file;
+        if (arg.files === "__files__") arg.files = files;
+      }
+    });
+
+    req.arguments = args;
     req.presets = presets;
     res.sendError = sendError;
     res.sendResponse = sendResponse;

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