catch-async-wrapper-express

a simple middleware for handling exceptions inside of async express routes and passing them to your express or custom error handlers.

Installation

npm i catch-async-wrapper-express

1const catchAsync = require('catch-async-wrapper-express')

Requirements:

• expressjs.
• Nodejs.

Examples:

catch any async or sync error and handle it to the next() function. having the second argument as undefined, catchAsync will default to the express next function.

1// if failed, next will be called with the error
2app.get(
3  '/users',
4  catchAsync(async (req, res, next) => {
5    const data = await UserModel.find({})
6    res.status(200).json({
7      status: 'success',
8      data,
9    })
10  })
11)

You can also have a custom error handler as well by passing it as the second parameter:

1// if failed, localErrorHandler will be called with the error
2
3const localErrorHandler = (error, req, res, next) => {
4  console.log(error)
5  res.status(500).json({
6    status: 'fail',
7    message: 'Unable to create user, please try again',
8  })
9}
10
11app.post(
12  '/users',
13  catchAsync(async (req, res, next) => {
14    const data = await UserModel.create(req.body) // ex: using mongoose
15    res.status(200).json({
16      status: 'success',
17      data,
18    })
19  }, localErrorHandler)
20)

a local error handler can also be an asyncronous function as well, and calling next inside of the custom error handler will move the error to your express global error handler middleware to process.

1// if failed, localErrorHandler will be called with the error
2
3const localErrorHandler = async (error, req, res, next) => {
4  console.log('returning the money back...')
5  const invoice = await Invoices.findById(req.invoiceId)
6  await transferMoney(invoice.to, invoice.from)
7  res.status(500).json({
8    status: 'fail',
9    message:
10      "You can't buy the item because it doesn't exist in the merchant stock, please try  again",
11  })
12}
13
14app.post(
15  '/purchase-item',
16  // verify & deduct/feed balances
17  catchAsync(async (req, res, next) => {
18    const from = 'john.doe@example.com'
19    const to = 'kinder@example.com'
20    const invoiceId = await transferMoney(from, to)
21    req.invoiceId = invoiceId
22    next()
23  }),
24  // verify & remove from stock
25  catchAsync(async (req, res, next) => {
26    await Stock.pick(req.body.itemToPurchase)
27    res.status(200).json({
28      status: 'success',
29      data,
30    })
31  }, localErrorHandler)
32)

If a local error handler throw an error, the error will be handled inside your express global error handler middleware to process it.

1const localErrorHandler = (error, req, res, next) => {
2  throw error
3}
4
5app.post(
6  '/users',
7  catchAsync(async (req, res, next) => {
8    const data = await UserModel.create(req.body)
9    res.status(200).json({
10      status: 'success',
11      data,
12    })
13  }, localErrorHandler)
14)

calling next with no arguemnts inside the local error handler will get the request back on the track of the middleware stack again. This means that you handled your error, and the request is ready to continue its journy:

1const localErrorHandler = async (error, req, res, next) => {
2  console.log('handling the error...')
3  await ErrorModel.create(error) // save the error to database
4  next()
5}
6
7app.post(
8  '/users',
9  catchAsync(async (req, res, next) => {
10    throw new Error('Hello from the error!') // an error
11  }, localErrorHandler),
12  (req, res, next) => {
13    res.status(200).json({
14      status: 'success',
15      message: 'the operation was completed successfuly with (1) errors',
16    })
17  }
18)