systemlynx 1.13.10 → 1.15.10

package/index.test.js

@@ -37,6 +37,7 @@ describe("SystemLynx Objects", () => {
         "emit",
         "$clearEvent",
         "before",
+        "after",
         "use",
         "startService",
         "loadService",
@@ -50,6 +51,7 @@ describe("SystemLynx Objects", () => {
       .that.respondsTo("emit")
       .that.respondsTo("$clearEvent")
       .that.respondsTo("before")
+      .that.respondsTo("after")
       .that.respondsTo("use")
       .that.respondsTo("startService")
       .that.respondsTo("loadService")
@@ -81,15 +83,18 @@ describe("SystemLynx Objects", () => {
         "WebSocket",
         "clones",
         "module",
-        "before"
+        "before",
+        "after"
       )
       .that.respondsTo("startService")
       .that.respondsTo("module")
-      .that.respondsTo("before");
+      .that.respondsTo("before")
+      .that.respondsTo("after");
     expect(LoadBalancer.clones)
       .to.be.an("object")
       .that.has.all.keys(
         "before",
+        "after",
         "on",
         "emit",
         "$clearEvent",
@@ -102,6 +107,7 @@ describe("SystemLynx Objects", () => {
       .that.respondsTo("$clearEvent")
       .that.respondsTo("on")
       .that.respondsTo("before")
+      .that.respondsTo("after")
       .that.respondsTo("register")
       .that.respondsTo("dispatch")
       .that.respondsTo("assignDispatch")
@@ -115,13 +121,14 @@ describe("SystemLynx Objects", () => {
       .that.has.all.keys([
         "startService",
         "addModule",
-        "addMiddleware",
+        "addBeforware",
+        "addAfterware",
         "server",
         "WebSocket",
       ])
       .that.respondsTo("startService")
       .that.respondsTo("addModule")
-      .that.respondsTo("addMiddleware");
+      .that.respondsTo("addBeforware");
   });
 
   it("should return a new instance of a Service", () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "systemlynx",
-  "version": "1.13.10",
+  "version": "1.15.10",
   "description": "",
   "main": "index.js",
   "browser": {

package/systemlynx/App/App.js

@@ -48,6 +48,11 @@ module.exports = function createApp(server, WebSocket, customClient) {
     return App;
   };
 
+  App.after = (...args) => {
+    system.Service.after(...args);
+    return App;
+  };
+
   App.loadService = (name, url) => {
     system.services.push({ name, url, onLoad: null, client: {} });
     return App;

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

@@ -14,6 +14,7 @@ describe("createApp()", () => {
         "on",
         "emit",
         "before",
+        "after",
         "$clearEvent",
         "use",
         "startService",
@@ -28,6 +29,7 @@ describe("createApp()", () => {
       .that.respondsTo("emit")
       .that.respondsTo("$clearEvent")
       .that.respondsTo("before")
+      .that.respondsTo("after")
       .that.respondsTo("use")
       .that.respondsTo("startService")
       .that.respondsTo("loadService")
@@ -236,7 +238,8 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
             "on",
             "emit",
             "$clearEvent",
-            "before"
+            "before",
+            "after"
           )
           .that.respondsTo("useModule")
           .that.respondsTo("useService")
@@ -244,7 +247,8 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
           .that.respondsTo("on")
           .that.respondsTo("emit")
           .that.respondsTo("$clearEvent")
-          .that.respondsTo("before");
+          .that.respondsTo("before")
+          .that.respondsTo("after");
       }).module("test2", function () {
         expect(this)
           .to.be.an("object")
@@ -255,7 +259,8 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
             "on",
             "emit",
             "$clearEvent",
-            "before"
+            "before",
+            "after"
           )
           .that.respondsTo("useModule")
           .that.respondsTo("useService")
@@ -263,7 +268,8 @@ describe("App SystemObjects: Initializing Modules,  Modules and configurations",
           .that.respondsTo("on")
           .that.respondsTo("emit")
           .that.respondsTo("$clearEvent")
-          .that.respondsTo("before");
+          .that.respondsTo("before")
+          .that.respondsTo("after");
         resolve();
       })
     );

package/systemlynx/HttpClient/HttpClient.js

@@ -9,7 +9,9 @@ module.exports = function createHttpClient() {
     method = method.toLowerCase();
     try {
       const res = await axios({ url, method, headers, data });
-      return res.data;
+      if (res.status >= 400) {
+        throw res.data;
+      } else return res.data;
     } catch (error) {
       if (!error.isAxiosError) throw error;
       if (!error.response) throw error;
@@ -33,7 +35,9 @@ module.exports = function createHttpClient() {
       const res = await axios.post(url, form, {
         headers: { ...headers, "Content-Type": "multipart/form-data" },
       });
-      return res.data;
+      if (res.status >= 400) {
+        throw res.data;
+      } else return res.data;
     } catch (error) {
       if (!error.isAxiosError) throw error;
       if (!error.response) throw error;

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

@@ -15,11 +15,13 @@ describe("LoadBalancer()", () => {
         "WebSocket",
         "module",
         "clones",
-        "before"
+        "before",
+        "after"
       )
       .that.respondsTo("startService")
       .that.respondsTo("module")
-      .that.respondsTo("before");
+      .that.respondsTo("before")
+      .that.respondsTo("after");
     expect(LoadBalancer.clones)
       .to.be.an("object")
       .that.has.all.keys(
@@ -27,6 +29,7 @@ describe("LoadBalancer()", () => {
         "emit",
         "$clearEvent",
         "before",
+        "after",
         "clones",
         "register",
         "dispatch",
@@ -36,6 +39,7 @@ describe("LoadBalancer()", () => {
       .that.respondsTo("$clearEvent")
       .that.respondsTo("on")
       .that.respondsTo("before")
+      .that.respondsTo("after")
       .that.respondsTo("register")
       .that.respondsTo("dispatch")
       .that.respondsTo("assignDispatch")
@@ -92,6 +96,7 @@ describe("LoadBalancer.clones (Module)", () => {
         "$emit",
         "$clearEvent",
         "before",
+        "after",
         "register",
         "dispatch",
         "assignDispatch",
@@ -101,6 +106,7 @@ describe("LoadBalancer.clones (Module)", () => {
       .that.respondsTo("emit")
       .that.respondsTo("$clearEvent")
       .that.respondsTo("before")
+      .that.respondsTo("after")
       .that.respondsTo("$emit")
       .that.respondsTo("register")
       .that.respondsTo("dispatch")

package/systemlynx/ServerManager/ServerManager.js

@@ -22,7 +22,8 @@ module.exports = function createServerManager(customServer, customWebSocketServe
     useService: true,
     staticRouting: false,
     ssl: { key: "", cert: "" },
-    validators: { $all: [] },
+    beforeware: { $all: [] },
+    afterware: { $all: [] },
   };
   const server = createServer(customServer);
   const router = createRouter(server, () => serverConfigurations);
@@ -97,16 +98,26 @@ module.exports = function createServerManager(customServer, customWebSocketServe
       useService,
       useREST,
       socketPort,
-      validators,
+      beforeware,
+      afterware,
     } = serverConfigurations;
 
     if (!serviceUrl) return moduleQueue.push({ name, Module, reserved_methods });
-    const exclude_methods = ["on", "emit", "before", "$clearEvent", ...reserved_methods];
+    const exclude_methods = [
+      "on",
+      "emit",
+      "before",
+      "after",
+      "$clearEvent",
+      ...reserved_methods,
+    ];
     const methods = parseMethods(Module, exclude_methods, useREST);
     const namespace = staticRouting ? name : shortId();
 
     SocketEmitter.apply(Module, [namespace, WebSocket]);
-    const _validators = [...validators.$all, ...(validators[name] || [])];
+    const before_validators = [...beforeware.$all, ...(beforeware[name] || [])];
+    const after_validators = [...afterware.$all, ...(afterware[name] || [])];
+
     if (useService) {
       const path = staticRouting ? `${route}/${name}` : `${shortId()}/${shortId()}`;
 
@@ -118,46 +129,66 @@ module.exports = function createServerManager(customServer, customWebSocketServe
       });
       methods.forEach((method) => {
         const nsp = `${name}.${method.fn}`;
-        const customValidators = [..._validators, ...(validators[nsp] || [])];
-        router.addService(Module, path, method, name, customValidators);
+        const beforeValidators = [...before_validators, ...(beforeware[nsp] || [])];
+        const afterValidators = [...after_validators, ...(afterware[nsp] || [])];
+        router.addService(Module, path, method, name, beforeValidators, afterValidators);
       });
     }
     if (useREST)
       methods.forEach((method) => {
         const nsp = `${name}.${method.fn}`;
-        const customValidators = [..._validators, ...(validators[nsp] || [])];
+        const beforeValidators = [...before_validators, ...(beforeware[nsp] || [])];
+        const afterValidators = [...after_validators, ...(afterware[nsp] || [])];
         switch (method.fn) {
           case "get":
           case "put":
           case "post":
           case "delete":
-            router.addREST(Module, `${route}/${name}`, method, name, customValidators);
+            router.addREST(
+              Module,
+              `${route}/${name}`,
+              method,
+              name,
+              beforeValidators,
+              afterValidators
+            );
         }
       });
   };
-  ServerManager.addMiddleware = (...args) => {
+
+  // Shared function for adding middleware (both beforeware and afterware)
+  const addMiddleware = (type, ...args) => {
     const name = typeof args[0] === "string" ? args.shift() : "$all";
     args.forEach(async (middleware) => {
       if (Array.isArray(middleware)) {
-        middleware.map(addMiddleware);
+        middleware.map((m) => addMiddlewareItem(type, name, m));
       } else {
-        addMiddleware(middleware);
+        addMiddlewareItem(type, name, middleware);
       }
     });
+  };
 
-    function addMiddleware(middleware) {
-      if (Array.isArray(middleware)) return middleware.map(addMiddleware);
-      if (!serverConfigurations.validators[name])
-        serverConfigurations.validators[name] = [];
-      serverConfigurations.validators[name].push(async function (req, res, next) {
-        try {
-          await middleware(req, res, next);
-        } catch (error) {
-          res.sendError(error);
-        }
-      });
+  // Helper function to add a single middleware item
+  const addMiddlewareItem = (type, name, middleware) => {
+    if (Array.isArray(middleware))
+      return middleware.map((m) => addMiddlewareItem(type, name, m));
+
+    if (!serverConfigurations[type][name]) {
+      serverConfigurations[type][name] = [];
     }
+
+    serverConfigurations[type][name].push(async function (req, res, next) {
+      try {
+        await middleware(req, res, next);
+      } catch (error) {
+        res.sendError(error);
+      }
+    });
   };
+
+  // Use the shared function for both middleware types
+  ServerManager.addBeforware = (...args) => addMiddleware("beforeware", ...args);
+  ServerManager.addAfterware = (...args) => addMiddleware("afterware", ...args);
   return ServerManager;
 };
 

package/systemlynx/ServerManager/components/Router.js

@@ -4,7 +4,14 @@ const isEmpty = (obj) => Object.getOwnPropertyNames(obj).length === 0;
 const isPromise = (p) => typeof p === "object" && typeof (p || {}).then === "function";
 
 module.exports = function createRouter(server, config) {
-  const addService = (Module, route, { fn, method }, module_name, validators) => {
+  const addService = (
+    Module,
+    route,
+    { fn, method },
+    module_name,
+    beforeware,
+    afterware
+  ) => {
     server[method](
       [`/${route}/${fn}`, `/sf/${route}/${fn}`, `/mf/${route}/${fn}`],
       (req, res, next) => {
@@ -14,13 +21,15 @@ module.exports = function createRouter(server, config) {
         req.module = Module;
         next();
       },
-      setHelpers,
-      validators,
-      requestHandler
+      parseRequest,
+      beforeware,
+      handleRequest,
+      afterware,
+      sendResponseMiddleware
     );
   };
 
-  const addREST = (Module, route, { method }, module_name, validators) => {
+  const addREST = (Module, route, { method }, module_name, beforeware, afterware) => {
     server[method](
       [`/${route}`],
       (req, res, next) => {
@@ -30,13 +39,15 @@ module.exports = function createRouter(server, config) {
         req.module = Module;
         next();
       },
-      setHelpers,
-      validators,
-      requestHandler
+      parseRequest,
+      beforeware,
+      handleRequest,
+      afterware,
+      sendResponseMiddleware
     );
   };
 
-  const setHelpers = (req, res, next) => {
+  const parseRequest = (req, res, next) => {
     const { fn, module_name, query, file, files, body, method, Module } = req;
 
     const { serviceUrl } = config();
@@ -56,17 +67,8 @@ module.exports = function createRouter(server, config) {
     };
 
     const sendResponse = (returnValue) => {
-      const status = (returnValue || {}).status >= 100 ? returnValue.status : 200;
-      if (status < 400) {
-        res.status(status).json({
-          ...presets,
-          status,
-          message:
-            (returnValue || {}).message ||
-            `[SystemLynx][response]: ${module_name}.${fn}(...) returned successfully`,
-          returnValue,
-        });
-      } else sendError(returnValue);
+      req.returnValue = returnValue;
+      sendResponseMiddleware(req, res);
     };
 
     if (typeof Module[fn] !== "function")
@@ -83,23 +85,63 @@ module.exports = function createRouter(server, config) {
       return args;
     };
     req.arguments = getArguments();
+    req.presets = presets;
     res.sendError = sendError;
     res.sendResponse = sendResponse;
     next();
   };
 
-  const requestHandler = (req, res) => {
+  const sendResponseMiddleware = (req, res, next) => {
+    const returnValue = req.returnValue;
+    const presets = req.presets;
+    const { module_name, fn } = req;
+
+    const status = (returnValue || {}).status >= 100 ? returnValue.status : 200;
+    if (status < 400) {
+      res.status(status).json({
+        ...presets,
+        status,
+        message:
+          (returnValue || {}).message ||
+          `[SystemLynx][response]: ${module_name}.${fn}(...) returned successfully`,
+        returnValue,
+      });
+    } else {
+      const unhandledMessage = `[SystemLynx]: handled error While calling ${module_name}.${fn}(...)`;
+      const error = returnValue;
+      const errorStatus = (error || {}).status || 500;
+      const message = (error || {}).message || unhandledMessage;
+      res.status(errorStatus).json({
+        ...presets,
+        ...error,
+        status: errorStatus,
+        message,
+        SystemLynxService: true,
+      });
+    }
+
+    // Call next if it exists (needed for middleware chaining)
+    if (next) next();
+  };
+
+  const handleRequest = (req, res, next) => {
     const { fn, Module } = req;
-    const { sendError, sendResponse } = res;
+    const { sendError } = res;
 
     try {
       const args = req.arguments;
       const results = Module[fn].apply({ ...Module, req, res }, args);
 
       if (isPromise(results)) {
-        results.then(sendResponse).catch(sendError);
+        results
+          .then((result) => {
+            req.returnValue = result;
+            next();
+          })
+          .catch(sendError);
       } else {
-        sendResponse(results);
+        req.returnValue = results;
+        next();
       }
     } catch (error) {
       sendError(error);

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

@@ -11,13 +11,15 @@ describe("createServerManager function", () => {
       .that.has.all.keys([
         "startService",
         "addModule",
-        "addMiddleware",
+        "addBeforware",
+        "addAfterware",
         "server",
         "WebSocket",
       ])
       .that.respondsTo("startService")
       .that.respondsTo("addModule")
-      .that.respondsTo("addMiddleware");
+      .that.respondsTo("addBeforware")
+      .that.respondsTo("addAfterware");
   });
 });
 describe("ServerManager", () => {
@@ -200,7 +202,7 @@ describe("ServerManager.startService(ServerConfiguration)", () => {
     });
   });
 
-  it("should be able to use the ServerManager.addMiddleware method to add additional route handling", async () => {
+  it("should be able to use the ServerManager.addBeforware method to add additional route handling", async () => {
     const ServerManager = createServerManager();
     const route = "/testAPI";
     const port = 5454;
@@ -228,15 +230,15 @@ describe("ServerManager.startService(ServerConfiguration)", () => {
       },
     };
 
-    ServerManager.addMiddleware((req, res, next) => {
+    ServerManager.addBeforware((req, res, next) => {
       req.$allHandlerAdded = true;
       next();
     });
-    ServerManager.addMiddleware(`${name}.put`, (req, res, next) => {
+    ServerManager.addBeforware(`${name}.put`, (req, res, next) => {
       req.putHandlerAdded = true;
       next();
     });
-    ServerManager.addMiddleware(`${name}.test`, (req, res, next) => {
+    ServerManager.addBeforware(`${name}.test`, (req, res, next) => {
       res.sendError({ status: 400, message: "tested passed" });
     });
     ServerManager.addModule(name, object);
@@ -305,4 +307,111 @@ describe("ServerManager.startService(ServerConfiguration)", () => {
       SystemLynxService: true,
     });
   });
+  it("should be able to use the ServerManager.addAfterware method to add additional route handling after the method call", async () => {
+    const ServerManager = createServerManager();
+    const route = "/testAPI";
+    const port = 5455;
+    const url = `http://localhost:${port}${route}`;
+    const name = "testObject";
+    const object = {
+      get: function () {
+        const { req } = this;
+        return {
+          SERVICE_TEST_PASSED: false,
+          $allHandlerAdded: false,
+          putHandlerAdded: false,
+        };
+      },
+      put: function () {
+        const { req } = this;
+        return {
+          SERVICE_TEST_PASSED: false,
+          $allHandlerAdded: false,
+          putHandlerAdded: false,
+        };
+      },
+      test: function () {
+        return { SERVICE_TEST_PASSED: false };
+      },
+    };
+
+    ServerManager.addAfterware((req, res, next) => {
+      req.returnValue.$allHandlerAdded = true;
+      req.returnValue.SERVICE_TEST_PASSED = true;
+      next();
+    });
+    ServerManager.addAfterware(`${name}.put`, (req, res, next) => {
+      req.returnValue.putHandlerAdded = true;
+      next();
+    });
+    ServerManager.addAfterware(`${name}.test`, (req, res, next) => {
+      res.sendError({ status: 400, message: "tested passed" });
+    });
+    ServerManager.addModule(name, object);
+    await ServerManager.startService({
+      route,
+      port,
+      staticRouting: true,
+      useREST: true,
+    });
+
+    const results = await new Promise((resolve) => {
+      request({ url: `${url}/${name}/get`, json: true }, (err, res, body) => {
+        resolve(body);
+      });
+    });
+
+    expect(results).to.deep.equal({
+      returnValue: {
+        SERVICE_TEST_PASSED: true,
+        $allHandlerAdded: true,
+        putHandlerAdded: false,
+      },
+      fn: "get",
+      message: "[SystemLynx][response]: testObject.get(...) returned successfully",
+      module_name: "testObject",
+      serviceUrl: "http://localhost:5455/testAPI",
+      status: 200,
+    });
+
+    const result2 = await new Promise((resolve) => {
+      request(
+        { url: `${url}/${name}/put`, json: true, method: "PUT" },
+        (err, res, body) => {
+          resolve(body);
+        }
+      );
+    });
+
+    expect(result2).to.deep.equal({
+      returnValue: {
+        SERVICE_TEST_PASSED: true,
+        $allHandlerAdded: true,
+        putHandlerAdded: true,
+      },
+      fn: "put",
+      message: "[SystemLynx][response]: testObject.put(...) returned successfully",
+      module_name: "testObject",
+      serviceUrl: "http://localhost:5455/testAPI",
+      status: 200,
+    });
+
+    const result3 = await new Promise((resolve) => {
+      request(
+        { url: `${url}/${name}/test`, json: true, method: "post" },
+        (err, res, body) => {
+          resolve(body);
+        }
+      );
+    });
+
+    expect(result3).to.deep.equal({
+      message: "tested passed",
+      fn: "test",
+      module_name: "testObject",
+      serviceUrl: "http://localhost:5455/testAPI",
+      status: 400,
+      SystemLynxService: true,
+    });
+  });
 });

package/systemlynx/Service/Service.js

@@ -8,8 +8,14 @@ module.exports = function createService(
   systemContext = {}
 ) {
   const ServerManager = createServerManager(customServer, customWebSocketServer);
-  const { startService, addMiddleware, server, WebSocket } = ServerManager;
-  const Service = { startService, server, WebSocket, before: addMiddleware };
+  const { startService, addBeforware, addAfterware, server, WebSocket } = ServerManager;
+  const Service = {
+    startService,
+    server,
+    WebSocket,
+    before: addBeforware,
+    after: addAfterware,
+  };
 
   Service.module = function (name, constructor, reserved_methods = []) {
     const exclude_methods = reserved_methods.concat(
@@ -19,9 +25,18 @@ module.exports = function createService(
       if (typeof args[0] === "string") {
         const arg1 = args.shift();
         const fn = arg1 === "$all" ? "" : `.${arg1}`;
-        addMiddleware(`${name}${fn}`, ...args);
+        addBeforware(`${name}${fn}`, ...args);
+      } else {
+        addBeforware(`${name}`, ...args);
+      }
+    };
+    const after = (...args) => {
+      if (typeof args[0] === "string") {
+        const arg1 = args.shift();
+        const fn = arg1 === "$all" ? "" : `.${arg1}`;
+        addAfterware(`${name}${fn}`, ...args);
       } else {
-        addMiddleware(`${name}`, ...args);
+        addAfterware(`${name}`, ...args);
       }
     };
     if (typeof constructor === "object" && constructor instanceof Object) {
@@ -33,6 +48,7 @@ module.exports = function createService(
           }, {}),
           ...systemContext,
           before,
+          after,
         },
         [undefined, systemContext]
       );
@@ -44,7 +60,7 @@ module.exports = function createService(
       if (constructor.constructor.name === "AsyncFunction")
         throw `[SystemLynx][Service][Error]: Module(name, constructor) function cannot receive an async function as the constructor`;
 
-      const Module = createDispatcher.apply({ ...systemContext, before }, [
+      const Module = createDispatcher.apply({ ...systemContext, before, after }, [
         undefined,
         systemContext,
       ]);

package/systemlynx/Service/Service.test.js

@@ -7,10 +7,18 @@ describe("createService", () => {
     const Service = createService();
     expect(Service)
       .to.be.an("object")
-      .that.has.all.keys("startService", "module", "server", "WebSocket", "before")
+      .that.has.all.keys(
+        "startService",
+        "module",
+        "server",
+        "WebSocket",
+        "before",
+        "after"
+      )
       .that.respondsTo("startService")
       .that.respondsTo("module")
-      .that.respondsTo("before");
+      .that.respondsTo("before")
+      .that.respondsTo("after");
   });
 });
 
@@ -61,11 +69,12 @@ describe("Service.module(constructor)", () => {
 
     expect(mod)
       .to.be.an("Object")
-      .that.has.all.keys("on", "emit", "$clearEvent", "before", "test", "test2")
+      .that.has.all.keys("on", "emit", "$clearEvent", "before", "after", "test", "test2")
       .that.respondsTo("on")
       .that.respondsTo("emit")
       .that.respondsTo("$clearEvent")
       .that.respondsTo("before")
+      .that.respondsTo("after")
       .that.respondsTo("test")
       .that.respondsTo("test2");
   });
@@ -144,6 +153,10 @@ describe("Service.module(object)", () => {
         req.beforeAction3 = true;
         next();
       });
+      this.after("action3", (req, res, next) => {
+        req.returnValue.afterAction3 = true;
+        next();
+      });
     });
     mod.before(
       "action1",
@@ -156,25 +169,54 @@ describe("Service.module(object)", () => {
         next();
       }
     );
+    mod.after(
+      "action1",
+      (req, res, next) => {
+        req.returnValue.afterAction1 = true;
+        next();
+      },
+      (req, res, next) => {
+        req.returnValue.afterAction12 = true;
+        next();
+      }
+    );
 
     mod.before((req, res, next) => {
       req.beforeModule = true;
       next();
     });
+    mod.after((req, res, next) => {
+      req.returnValue.afterModule = true;
+      next();
+    });
 
     Service.before((req, res, next) => {
       req.beforeService = true;
       next();
     });
+    Service.after((req, res, next) => {
+      req.returnValue.afterService = true;
+      next();
+    });
+
     expect(mod)
       .to.be.an("Object")
-      .that.has.all.keys("action1", "action2", "on", "emit", "$clearEvent", "before")
+      .that.has.all.keys(
+        "action1",
+        "action2",
+        "on",
+        "emit",
+        "$clearEvent",
+        "before",
+        "after"
+      )
       .that.respondsTo("action1")
       .that.respondsTo("action2")
       .that.respondsTo("on")
       .that.respondsTo("emit")
       .that.respondsTo("$clearEvent")
-      .that.respondsTo("before");
+      .that.respondsTo("before")
+      .that.respondsTo("after");
   });
   it("should 'Serve' Service connection data created using an object as the constructor", async () => {
     await Service.startService({ route, port });
@@ -217,19 +259,35 @@ describe("Service.module(object)", () => {
     expect(results.port, port);
   });
 
-  it("should use SeverModule.before method to add a route handler before a target method", async () => {
+  it("should use SeverModule.before method and SeverModule.after method to add a route handler before and after target method ", async () => {
     const Client = createClient();
     const { mod, mod2 } = await Client.loadService(url);
     const result = await mod.action1();
+
     expect(result).to.deep.equal({
       beforeAction1: true,
       beforeAction12: true,
       beforeModule: true,
       beforeService: true,
+
+      afterAction1: true,
+      afterAction12: true,
+      afterModule: true,
+      afterService: true,
     });
     const result2 = await mod.action2();
-    expect(result2).to.deep.equal({ beforeModule: true, beforeService: true });
+    expect(result2).to.deep.equal({
+      beforeModule: true,
+      beforeService: true,
+      afterModule: true,
+      afterService: true,
+    });
     const result3 = await mod2.action3();
-    expect(result3).to.deep.equal({ beforeAction3: true, beforeService: true });
+    expect(result3).to.deep.equal({
+      beforeAction3: true,
+      beforeService: true,
+      afterAction3: true,
+      afterService: true,
+    });
   });
 });