5

I just brought up this issue with Express and I am interested in what StackOverflow thinks about it:

https://github.com/strongloop/express/issues/2831

my question is why Express opts to disallow the developer from passing data directly between middleware functions and basically forces you to assign temporary data to the request object in what I have always considered to be a quite awkward assignment.

to be more specific:

passing data between middleware functions usually involves doing this

req.specialData = {}
next();

however, it would be perhaps much easier and more performant (!) if this were possible

next(null,data);

or

function mySpecialMiddleWare(req,res,next,data){}

//now, call the above function

mySpecialMiddleWare(req,res,next, {some:data});

the problem is that Express uses a, what I believe to be, stupid way of determining if the call is to a normal middleware function or the next error first middleware function, by checking to see if the function.length > 3 or function.length === 4...

is there any chance what I am saying makes any sense?

wouldn't it be better/easier/faster/stronger to allow direct passing of data via middleware functions instead of assigning data awkwardly to req ??

perhaps Express already has this capability and I am just misinformed?

Improve this question

2 Answers 2

Reset to default
7

my question is why Express opts to disallow the developer from passing data directly between middleware functions and basically forces you to assign temporary data to the request object in what I have always considered to be a quite awkward assignment.

So I think the API is the way it is to encourage most middleware to be modular, re-usable, and loosely coupled. That means the generally should do something without being concerned too much about what other middleware might run before them or after them. In order to achieve this and create an ecosystem of loosely-compatible middleware functions, express keeps the API fairly generic. There are pros and cons to this. But as a direct answer to your first question, I would say to keep the interface simple, consistent, and flexible as well as try to avoid strict ordering dependencies.

As in your case, there might be implicit dependencies between middlewares. Another common example would be typically your session middleware has an implicit dependency that your cookie middleware runs before it. Having these all be implicit can be argued to create bugs and unnecessary troubleshooting. On the other hand, it enables application developers to more easily mix and match middlewares that might otherwise have no awareness of one another.

In hindsight I think both I as well as some of the express maintainers would agree that using function arity (number of expected arguments) for semantic API reasons was an odd and poor choice on TJ's part. I think if the project were to be rewritten a more explicit API would be defined for error handling.

wouldn't it be better/easier/faster/stronger to allow direct passing of data via middleware functions instead of assigning data awkwardly to req ??

Better - this is highly arguable and opinion based. There is a lot to be said for the simplicity of it and the evidence is the huge ecosystem and usage. There are alternatives available such as hapi, restify, etc, though so you might consider them.

Easier - probably not. What's there is pretty easy.

Faster - probably not in any meaningful way. Not sure why you think your version would be faster, but best to bring metrics when you make such claims.

Stronger - If by "stronger" you mean more explicit that's probably true but there's a reason some people still prefer JavaScript even though TypeScript all the way up through Haskell exist and are definitely "stronger" in some sense of the word.

Improve this answer
Sign up to request clarification or add additional context in comments.

5 Comments

thanks you definitely make some good points; I meant faster/stronger more in the Daft Punk sense
assigning temporary variables like this to req will probably increase memory though? Just passing variables between functions uses less memory surely.
also, one way to jerryrig it, would be just to call a middleware function with 5 or more arguments, that should bypass the error middleware and just bring you into the next middleware function - that is - if Express doesn't clip/truncate extra arguments from the next call. but you can't call it with next(), you have to call it with middleware(req,res,next,{},{})
Sure. If the middleware pattern isn't a fit, just use good old functions.
yeah, but I just wish you could call next(null,{}), that would be so nice. Express, if all else, could put that object on the req for you, so the above call would assign the object to req.foo or whatever...and also if you could comment on the memory increase of temporary variables on req...not sure if that has an effect or not.
3

There might be advantages to what Express is doing, however, it is worth noting that Express allows passing data between middlewares using res.locals. With that said, your question inspired me to make this library. Expressjs-plus. With it, you will be able to pass data between your middlewares easily without having to use the request nor the response object.

You can use regular javascript functions e.g. function(varInResLocals, varInReqParams, callback) instead of express middleware signature.

Here is a working example for you.

 var express = require('express');
 var ExpressPlus = require('expressjs-plus').ExpressPlus;
 var app = express();
 // simple handler example
 var userHandler = function(param, paramsArray, req, res){
    if(param !== 'user') return false;
    paramsArray.push("USER WAS FOUND!");
    return true;
};

 // this handler allows you to pass res.locals properties between your middlewares seemingly,
 // it the parameter was found in locals, it attaches it to paramsArray.
 var resLocalsHandler = function(param, paramsArray, req, res){
    if(param in res.locals){
        paramsArray.push(res.locals[param]);
        return true;
    }else return false;
};
 var appPlus = new ExpressPlus(app, [userHandler, resLocalsHandler], []);
 var regularFunction = function(user, id, cb){
    return cb(null, { response: {user: user, id: id}, status: 200, resLocalsVar: "passVar" });
};

 // resLocalsVar was passed in a previous method
 var regularFunction2 = function(resLocalsVar, user, id, cb){
 // now you can have access to it
    console.log(resLocalsVar);
    return cb(null);
};

 // the responder at the end will use res.locals.status and res.locals.response to issue an HTTP response
 app.use(appPlus.GMV(regularFunction), appPlus.GMV(regularFunction2), appPlus.responder);

 // adds error handlers, it will add a default error handler along with the list of error handlers passed
 // in this case, no error handlers were passed
 appPlus.setErrorHandlers();

 app.listen(3001, function(){
    console.log('Listening!');
});
Improve this answer

Comments

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.