How to send a custom http status message in node / express?

Question

My node.js app is modeled like the express/examples/mvc app.

In a controller action I want to spit out a HTTP 400 status with a custom http message. By default the

Answer 1

When using Axios you can retrieve the custom response message with:

Axios.get(“your_url”)
.then(data => {
... do something
}.catch( err => {
console.log(err.response.data) // you want this
})

...after setting it in Express as:

res.status(400).send(“your custom message”)

Answer 2

Well in the case of Restify we should use sendRaw() method

Syntax is: res.sendRaw(200, 'Operation was Successful', <some Header Data> or null)

Answer 3

You can check this res.send(400, 'Current password does not match') Look express 3.x docs for details

UPDATE for Expressjs 4.x

Use this way (look express 4.x docs):

res.status(400).send('Current password does not match');
// or
res.status(400);
res.send('Current password does not match');

Answer 4

If your goal is just to reduce it to a single/simple line, you could rely on defaults a bit...

return res.end(res.writeHead(400, 'Current password does not match'));

Answer 5

None of the existing answers accomplish what the OP originally asked for, which is to override the default Reason-Phrase (the text appearing immediately after the status code) sent by Express.

What you want is res.statusMessage. This is not part of Express, it's a property of the underlying http.Response object in Node.js 0.11+.

You can use it like this (tested in Express 4.x):

function(req, res) {
    res.statusMessage = "Current password does not match";
    res.status(400).end();
}

Then use curl to verify that it works:

$ curl -i -s http://localhost:3100/
HTTP/1.1 400 Current password does not match
X-Powered-By: Express
Date: Fri, 08 Apr 2016 19:04:35 GMT
Connection: keep-alive
Content-Length: 0

Answer 6

My use-case is sending a custom JSON error message, since I'm using express to power my REST API. I think this is a fairly common scenario, so will focus on that in my answer.

Short Version:

Express Error Handling

Define error-handling middleware like other middleware, except with four arguments instead of three, specifically with the signature (err, req, res, next). ... You define error-handling middleware last, after other app.use() and routes calls

app.use(function(err, req, res, next) {
    if (err instanceof JSONError) {
      res.status(err.status).json({
        status: err.status,
        message: err.message
      });
    } else {
      next(err);
    }
  });

Raise errors from any point in the code by doing:

var JSONError = require('./JSONError');
var err = new JSONError(404, 'Uh oh! Can't find something');
next(err);

Long Version

The canonical way of throwing errors is:

var err = new Error("Uh oh! Can't find something");
err.status = 404;
next(err)

By default, Express handles this by neatly packaging it as a HTTP Response with code 404, and body consisting of the message string appended with a stack trace.

This doesn't work for me when I'm using Express as a REST server, for example. I'll want the error to be sent back as JSON, not as HTML. I'll also definitely not want my stack trace moving out to my client.

I can send JSON as a response using req.json(), eg. something like req.json({ status: 404, message: 'Uh oh! Can't find something'}). Optionally, I can set the status code using req.status(). Combining the two:

req.status(404).json({ status: 404, message: 'Uh oh! Can't find something'});

This works like a charm. That said, I find it quite unwieldy to type every time I have an error, and the code is no longer self-documenting like our next(err) was. It looks far too similar to how a normal (i.e, valid) response JSON is sent. Further, any errors thrown by the canonical approach still result in HTML output.

This is where Express' error handling middleware comes in. As part of my routes, I define:

app.use(function(err, req, res, next) {
    console.log('Someone tried to throw an error response');
  });

I also subclass Error into a custom JSONError class:

JSONError = function (status, message) {
    Error.prototype.constructor.call(this, status + ': ' + message);
    this.status = status;
    this.message = message;
  };
JSONError.prototype = Object.create(Error);
JSONError.prototype.constructor = JSONError;

Now, when I want to throw an Error in the code, I do:

var err = new JSONError(404, 'Uh oh! Can't find something');
next(err);

Going back to the custom error handling middleware, I modify it to:

app.use(function(err, req, res, next) {
  if (err instanceof JSONError) {
    res.status(err.status).json({
      status: err.status,
      message: err.message
    });
  } else {
    next(err);
  }
}

Subclassing Error into JSONError is important, as I suspect Express does an instanceof Error check on the first parameter passed to a next() to determine if a normal handler or an error handler must be invoked. I can remove the instanceof JSONError check and make minor modifications to ensure unexpected errors (such as a crash) also return a JSON response.