chore(connect): use response object instead of string.

Author: azu

src/connect/junction.js

@@ -4,20 +4,20 @@ function isErrorHandingMiddleware(middleware) {
     let arity = middleware.length;
     return arity === 3;
 }
-function applyMiddleware(error, data, middleware, next) {
+function applyMiddleware(error, response, middleware, next) {
     let errorOnMiddleware = null;
     try {
         if (error && isErrorHandingMiddleware(middleware)) {
-            middleware(error, data, next);
+            middleware(error, response, next);
         } else {
-            middleware(data, next);
+            middleware(response, next);
         }
         return;
     } catch (error) {
         errorOnMiddleware = error;
     }
     // skip the middleware or Error on the middleware
-    next(errorOnMiddleware, data);
+    next(errorOnMiddleware, response);
 }
 
 export default class Junction {
@@ -29,14 +29,15 @@ export default class Junction {
         this.stack.push(middleware);
     }
 
-    process(initialData, callback) {
-        let next = (error, data) => {
+    process(initialValue, callback) {
+        let response = {value: initialValue};
+        let next = (error) => {
             let middleware = this.stack.shift();
             if (!middleware) {
-                return callback(error, data);
+                return callback(error, response);
             }
-            applyMiddleware(error, data, middleware, next);
+            applyMiddleware(error, response, middleware, next);
         };
-        next(null, initialData);
+        next();
     }
 }

test/connect/junction-test.js

@@ -5,42 +5,45 @@ import Junction from "../../src/connect/junction";
 describe("junction", function () {
     context("when register middlewares", function () {
         it("should connect middleware, the order is register", function (done) {
-            var junction = new Junction();
+            let junction = new Junction();
             junction.use(function errorHandling(error, text, next) {
                 next(error);
             });
-            junction.use(function toUpper(text, next) {
-                next(null, text.toLocaleUpperCase());
+            junction.use(function toUpper(res, next) {
+                res.value = res.value.toLocaleUpperCase();
+                next();
             });
-            junction.use(function addDesu(text, next) {
-                next(null, text + " suffix");
+            junction.use(function addDesu(res, next) {
+                res.value += " suffix";
+                next();
             });
             junction.process("text", (error, result) => {
                 if (error) {
                     return done(error);
                 }
-                assert.equal(result, "TEXT suffix");
+                assert.equal(result.value, "TEXT suffix");
                 done();
             });
         });
     });
     context("when occur error in middleware", function () {
         it("should call errorHandling middleware", function (done) {
-            var junction = new Junction();
-            junction.use(function toUpper(text, next) {
-                throw new Error("ROL");
+            let junction = new Junction();
+            junction.use(function toUpper(res) {
+                throw new Error("error on " + res);
             });
-            // TODO: 順番に依存してる
-            junction.use(function errorHandling(error, text, next) {
+            junction.use(function errorHandling(error, res, next) {
                 assert(error instanceof Error);
-                done();
+                assert.equal(res.value, "text");
+                next();
             });
-            junction.process("text", (error, result) => {
+            junction.process("text", (error, res) => {
                 if (error) {
                     return done(error);
                 }
+                assert.equal(res.value, "text");
                 done();
             });
         });
-    })
+    });
 });