I have tried:
app.get('/', function(req, res, next) {
var e = new Error('error message');
e.status = 400;
next(e);
});
and:
app.get('/', function(req, res, next) {
res.statusCode = 400;
var e = new Error('error message');
next(e);
});
but always an error code of 500 is announced.
Per the Express (Version 4+) docs, you can use:
res.status(400);
res.send('None shall pass');
http://expressjs.com/4x/api.html#res.status
<=3.8
res.statusCode = 401;
res.send('None shall pass');
res.status(400).json({ error: 'message' })
res.sendStatus(401);.
res.send('Then you shall die').
.status() is deprecated. .sendStatus() is just a shorthand for .status(code).send(codeName) where the codeName is the standard HTTP response text for the given code.A simple one liner;
res.status(404).send("Oh uh, something went wrong");
I'd like to centralize the creation of the error response in this way:
app.get('/test', function(req, res){
throw {status: 500, message: 'detailed message'};
});
app.use(function (err, req, res, next) {
res.status(err.status || 500).json({status: err.status, message: err.message})
});
So I have always the same error output format.
PS: of course you could create an object to extend the standard error like this:
const AppError = require('./lib/app-error');
app.get('/test', function(req, res){
throw new AppError('Detail Message', 500)
});
'use strict';
module.exports = function AppError(message, httpStatus) {
Error.captureStackTrace(this, this.constructor);
this.name = this.constructor.name;
this.message = message;
this.status = httpStatus;
};
require('util').inherits(module.exports, Error);
throw works only if the route is synchronous. If it's an async route, you have to manually call next(). I suppose (but haven't tried) you could just pass the same object you show in throw but to next().In express 4.0 they got it right :)
res.sendStatus(statusCode)
// Sets the response HTTP status code to statusCode and send its string representation as the response body.
res.sendStatus(200); // equivalent to res.status(200).send('OK')
res.sendStatus(403); // equivalent to res.status(403).send('Forbidden')
res.sendStatus(404); // equivalent to res.status(404).send('Not Found')
res.sendStatus(500); // equivalent to res.status(500).send('Internal Server Error')
//If an unsupported status code is specified, the HTTP status is still set to statusCode and the string version of the code is sent as the response body.
res.sendStatus(2000); // equivalent to res.status(2000).send('2000')
You can use res.send('OMG :(', 404); just res.send(404);
res.send(404) is deprecated. It's now res.sendStatus(404). expressjs.com/en/api.html#res.sendStatusFrom what I saw in Express 4.0 this works for me. This is example of authentication required middleware.
function apiDemandLoggedIn(req, res, next) {
// if user is authenticated in the session, carry on
console.log('isAuth', req.isAuthenticated(), req.user);
if (req.isAuthenticated())
return next();
// If not return 401 response which means unauthroized.
var err = new Error();
err.status = 401;
next(err);
}
The version of the errorHandler middleware bundled with some (perhaps older?) versions of express seems to have the status code hardcoded. The version documented here: http://www.senchalabs.org/connect/errorHandler.html on the other hand lets you do what you are trying to do. So, perhaps trying upgrading to the latest version of express/connect.
I tried
res.status(400);
res.send('message');
..but it was giving me error:
(node:208) UnhandledPromiseRejectionWarning: Error: Can't set headers after they are sent.
This work for me
res.status(400).send(yourMessage);
Old question, but still coming up on Google. In the current version of Express (3.4.0), you can alter res.statusCode before calling next(err):
res.statusCode = 404;
next(new Error('File not found'));
next is calling next handler which in express.js usually are trying to render error pages.Express deprecated res.send(body, status).
Use res.status(status).send(body) or res.sendStatus(status) instead
If you want to send the status code without its string representation you can do:
res.status(200).send();
Async way:
myNodeJs.processAsync(pays)
.then((result) => {
myLog.logger.info('API 200 OK');
res.statusCode = 200;
res.json(result);
myLog.logger.response(result);
})
.fail((error) => {
if (error instanceof myTypes.types.MyError) {
log.logger.info(`My Custom Error:${error.toString()}`);
res.statusCode = 400;
res.json(error);
} else {
log.logger.error(error);
res.statusCode = 500;
// it seems standard errors do not go properly into json by themselves
res.json({
name: error.name,
message: error.message
});
}
log.logger.response(error);
})
.done();
