Develop Reference

How does express.js catch ReferenceError

// Sample code
app.get("/test", (res, res) => {
return res.status(200).send(SOME_UNDEFINED_VAR);
});
In case of ReferenceError, express.js sends 500 by default.
express.js writes the ReferenceError on std out but i want to write such error on a file using my logger.
tried using
app.use((err, res, res) => {
logger.error(err) // this handler is not getting called
// this handler is only for `next(err)`
})
I know reference errors can be caught by linting tools and this case will never come but I still want to know how to catch such error.

I stumbled across the same problem.
My solution to catch references error with expressjs Error handler was to use the try and catch block inside route function and then use next(err) in the catch block. You'll have to check if the error is really a references error though.

How Expressjs decides which error handler to call. if we have multiple error handles

I am just curious to know that how express decides which error handler to call (next(err)), when we have multiple error handlers.

If you have multiple errorhandlers, they will be called in the order you put them in your .use statements. Every errorhandler has to do next(err) though in order to pass the error on.
Taken from expressjs documentation:
app.use(logErrors)
app.use(clientErrorHandler)
app.use(errorHandler)
As an example from the documentation:
function errorHandler (err, req, res, next) {
if (res.headersSent) {
return next(err)
}
res.status(500)
res.render('error', { error: err })
}
So an error is beeing passed from handler to handler with the next(err) statement. And within that handler you decide what to do. You could for example check for a specific error and only act on that specific error.
expressjs documentation for errorhandling

Undefined Argument when using Callback function for express route

Currently, I am using many routes in Express. Some of the routes can be quite lengthy. A common route look like the following:
router.get('/api/comments', function(req, res, next){
Comment.find({"user": req.payload._id}).exec(function(err,comments){
if(err){return next(err); }
res.json(comments);
})
}
This works fine. But I am calling routes multiple times and it can be quite lengthy. So I am trying to create a callback function which can be invoked by the various routes. E.g.
var testFunction = function(req, res, next){
Comment.find({"user": req.payload._id}).exec(function(err,comments){
if(err){return next(err); }
res.json(comments);
})
}
router.get('/api/comments', testFunction(req,res,next));
However, I will always get a "req is not defined" error on the last line. Just wondering what I am doing wrong here?

router takes a function as argument not the result of executing that function.
router.get('/api/comments', testFunction); will work.

Try doing router.get('/api/comments', testFunction); instead of router.get('/api/comments', function(req, res, next)

How can I convert a rejected promise to an exception and throw it from an Express route handler?

In one of my app's route handlers, I am calling a method that returns a Q promise. Rather than handling the rejection using the .catch method, I want it to be thrown and get caught by my Express app's catch-all error handler.
I tried Q's done method, but it throws the exception asynchronously, so rather than it getting handled by my catch-all error handler, it gets propagated all the way up and my app gets terminated:
// The route handler
function index(req, res) {
dao.findById(id).then(function (data) {
res.send(data);
}).done();
}
// The catch all event-handler
function catchAllErrorHandler(err, req, res, next) {
console.log(err, req, res);
}
// Registration of the catch-all event handler
app.use(catchAllErrorHandler);
The error never enters the catch all error handler. Is there a way to make the thrown errors get handled by catchAllErrorHandler?

This does not answer your question directly, but rather shows another way to achieve your goal.
Every middleware handler in express has the signature (request, response, next). Currently your index function does not have next defined.
When calling next with an argument, express considers that argument to be an error, and manages it appropriately.
So, in your case, change your index function to include the next parameter, and change .done() to .catch(next) which will call next with any error that occurs, and allow express to handle it.
dao.findById(id)
// Handle success
.then(function (data) {
res.send(data);
})
// Handle failure
.catch(next);

I tried Q's done method
That's probably the best you get to throw exceptions from promises.
but it throws the exception asynchronously
Of course it does, promises are always asynchronous. You cannot determine whether your promise will reject in the future and synchronously throw an exception…
Is there a way to make the thrown errors get handled by catchAllErrorHandler?
Pass the handler explicitly as a handler:
dao.findById(id).then(function (data) {
res.send(data);
}).catch(catchAllErrorHandler);
Alternatively, since Q v1.3 you can used the unhandled rejection tracking and put your catchAllErrorHandler there.

How do you access values passed to next() functions in Node

I'm using Node with Express.js to write a back-end for a project I'm working on.
next() functions are used in middleware to move to the next piece in the middleware chain, and finally onto the app.VERB() function. Where and how (further down the line) do I access this variable?
Example code:
app.use(function (req, res, next) {
User.findOne({
'email': emailValue
}, function (err, foundUser) {
if (err) return next(err);
// Else do something
}
});
});
What has access to the err value passed to next()?

When you pass an error parameter into next, Express invokes whatever error middleware handler you've installed. The error middleware function has four arguments, so you'd install your own handler as:
app.use(function(err, req, res, next) {
// handle the err from a previous middleware's next(err) call
});
You'd typically add this at the end of your middleware chain so that it handles all other middlewares' errors.
See here for the Express documentation on this.