allow service middleware to access/change method

hudson-taylor · May 15, 2015 · d893fbb · d893fbb
1 parent 13d73eb
commit d893fbb
Show file tree

Hide file tree

Showing 2 changed files with 77 additions and 20 deletions.
diff --git a/src/service.js b/src/service.js
@@ -30,30 +30,18 @@ let Service = function Service(Transports, config) {
     };
 
     this.fn = function(method, data, cb) {
-        let _tmp = self._methods[method];
-        if(!_tmp) return cb({ error: "unknown-method", method: method });
-
-        if(_tmp.schema) {
-            try {
-                if(!_tmp.schema.hasOwnProperty('$validators')) {
-                    data = s.Object(_tmp.schema).validate(data);
-                } else {
-                    data = _tmp.schema.validate(data);
-                }
-            } catch(e) {
-                return cb({
-                    error: e.message
-                });
-            }
-        }
+
+        let context = {
+            method
+        };
 
         let _beforeMiddleware = self._middleware.before.filter((m) => {
-            if(m.method && m.method !== method) return false;
+            if(m.method && m.method !== context.method) return false;
             return true;
         });
 
         async.eachSeries(_beforeMiddleware, function(middleware, done) {
-            middleware.fn(data, function(err, result) {
+            middleware.fn.call(context, data, function(err, result) {
                 if(err) {
                     return done(err);
                 }
@@ -65,19 +53,36 @@ let Service = function Service(Transports, config) {
                 return cb(err);
             }
 
+            let _tmp = self._methods[context.method];
+            if(!_tmp) return cb({ error: "unknown-method", method: context.method });
+
+            if(_tmp.schema) {
+                try {
+                    if(!_tmp.schema.hasOwnProperty('$validators')) {
+                        data = s.Object(_tmp.schema).validate(data);
+                    } else {
+                        data = _tmp.schema.validate(data);
+                    }
+                } catch(e) {
+                    return cb({
+                        error: e.message
+                    });
+                }
+            }
+
             let finish = function(err, response) {
 
                 if(err) {
                     return cb(err);
                 }
 
                 let _afterMiddleware = self._middleware.after.filter((m) => {
-                    if(m.method && m.method !== method) return false;
+                    if(m.method && m.method !== context.method) return false;
                     return true;
                 });
 
                 async.eachSeries(_afterMiddleware, function(middleware, done) {
-                    middleware.fn(response, function(err, _response) {
+                    middleware.fn.call(context, response, function(err, _response) {
                         if(err) {
                             return done(err);
                         }

diff --git a/test-src/service.js b/test-src/service.js
@@ -425,6 +425,58 @@ describe("Service", function() {
 
   });
 
+  it("should expose method to middleware", function(done) {
+
+    let _method = "hello";
+
+    let transport = mockTransport();
+
+    let service = new Service(transport());
+
+    service.before(function(data, callback) {
+      assert.equal(this.method, _method);
+      return callback(null, data);
+    });
+
+    service.after(function(data, callback) {
+      assert.equal(this.method, _method);
+      return callback(null, data);
+    });
+
+    service.on(_method, (req, callback) => callback());
+
+    service.call(_method, "", function(err) {
+      assert.ifError(err);
+      return done();
+    });
+
+  });
+
+  it("should be able to change method in before middleware", function(done) {
+
+    let _method1 = "hello";
+    let _method2 = "world";
+
+    let transport = new mockTransport();
+
+    let service = new Service(transport());
+
+    service.before(function(data, callback) {
+      assert.equal(this.method, _method1);
+      this.method = _method2;
+      return callback(null, data);
+    });
+
+    service.on(_method2, (req, callback) => callback(null, req));
+
+    service.call(_method1, "hi", function(err, res) {
+      assert.ifError(err);
+      assert.equal(res, "hi");
+      done();
+    });
+
+  });
+
   it("should immediately return if server is not listening", function(done) {
 
     let service = new Service(mockTransport()());