CODEWITHSUNDEEP
node.jsexpresserror-handlingmiddleware
Steve Bennett
Steve Bennett

Reputation: 126777

Handle exceptions on every Express route

I would like some basic error handling on every route, so if there is ever an exception, the API at least responds with 500.

According to this pattern, you still need to include a try/catch block in every route:

app.post('/post', async (req, res, next) => {
  const { title, author } = req.body;
  
  try {
    if (!title || !author) {
      throw new BadRequest('Missing required fields: title or author');
    }
    const post = await db.post.insert({ title, author });
    res.json(post);
  } catch (err) {
    next(err) // passed to the error-handling middleware
  }
});

That seems a little repetitive. Is there a higher-level way where exceptions are automatically caught everywhere and passed to the middleware?

I mean, it would obviously be possible for me to just define my own appGet():

function appGet(route, cb) {
    app.get(route, async (req, res, next) => {
        try {
          await cb(req, res, next);
        } catch (e) {
            next(e);
        }
    });
}

Is there some built in version of this?

Upvotes: 1

Views: 1539

Answers (2)

Kishor
Kishor

Reputation: 450

I think the better approach would be to divide the services and the controllers which is demonstrated below.

Add post service:

async function addPostService (title, author) => {
    if (!title || !author)
      throw new BadRequest('Missing required fields: title or author');
    
    return await db.post.insert({ title, author });
};

Add post controller:

function addPost(req, res, next){
    const { title, author }= req.body;

    addPostService
      .then((post) => {
        res.json(post);
      })
      .catch(next) // will go through global error handler middleware
}

Now, we can make a global error handler middleware which will catch the error thrown by any controller throughout the app.

function globalErrorHandler(err, req, res, next){
  switch(true){
    case typeof err === 'string':
      // works for any errors thrown directly
      // eg: throw 'Some error occured!';
      return res.status(404).json({ message: 'Error: Not found!'});
    
    // our custom error
    case err.name = 'BadRequest':
      return res.status(400).json({ message: 'Missing required fields: title or author!'})
    
    default:
      return res.status(500).json({ message: err.message });
  }
}

And, don't forget to use the error handler middleware right before starting the server.

// ....
app.use(globalErrorHandler);
app.listen(port, () => { console.log('Server started...')});

Upvotes: 1

Lin Du
Lin Du

Reputation: 102597

You can use express-promise-router package.

A simple wrapper for Express 4's Router that allows middleware to return promises. This package makes it simpler to write route handlers for Express when dealing with promises by reducing duplicate code.

E.g.

app.ts:

import express from 'express';
import Router from 'express-promise-router';
import bodyParser from 'body-parser';
const router = Router();
const app = express();
const port = 3000;
app.use(bodyParser.json());
app.use(router);

router.post('/post', async (req, res) => {
  const { title, author } = req.body;
  if (!title || !author) {
    throw new Error('Missing required fields: title or author');
  }
  const post = { title, author };
  res.json(post);
});

router.use((err, req, res, next) => {
  res.status(500).send(err.message);
});

app.listen(port, () => console.log(`Server started at http://localhost:${port}`));

You don't need try/catch statement block anymore.

Test result:

enter image description here

Upvotes: 1

Related Questions