Using async/await in ExpressJs

If you have not been living under a rock for the past few years, you probably have heard of async/await. It has been one of the interesting additions to EcmaScript. It makes control flow easier to understand and read and also allows to write concise, maintainable code. If you need a refresher on async/await, you can refer to the MDN article about it. We are going to be more focused on using async/await in ExpressJs in this post.

Using async/await in ExpressJs controllers

Node 8+ supports async/await out of the box and you can start using them right away in your node/express application. So if we had a method like this in our controller:

- Advertisement -
app.post('/test', (req, res) => {
  // Call async function here
})

We can convert this into a function that uses async/await in Express by first marking the handler as an async function. Then we can call await inside of the request handler.

app.post('/test', async (req, res) => {
  const result = await asyncFunction(req.body);
  res.json(result);
})

What about error handling?

If the above function would have worked and you already knew about async/await syntax, this blog post would have been a waste of your time. What would happen if asyncFunction above throws an error? If you do not handle anything in there, express will throw a UnhandledPromiseRejection error and the client would not know what happened.

To handle an error in the asynchronous function, it needs to be wrapped in a try-catch block.

app.post('/test', async (req, res) => {
  try {
    const result = await asyncFunction(req.body);
    res.json(result);
  catch (error){
    console.log(error);
  }
})

This will handle the error, but express still does not know that an error has occurred. So the error needs to be passed to express using the next method.

app.post('/test', async (req, res) => {
  try {
    const result = await asyncFunction(req.body);
    res.json(result);
  catch (error){
    console.log(error);
    next(error);
  }
})

What happens if there are more than 2 async functions?

If there are 2 asynchronous functions that need to be invoked, the first thing that would come to mind would be:

app.post('/test', async (req, res) => {
  try {
    await asyncFunction1(req.body);
  }
  catch (error){
    next(error);
  }
  try {
    await asyncFunction2(req.body);
  }
  catch (error){
    next(error);
  }
})

But this is not needed. If the first function throws an error, the request would be returned to the error handler immediately. The second function will not be invoked anyway. Since only one of these will throw an error, we can refactor it as:

app.post('/test', async (req, res) => {
  try {
    await asyncFunction1(req.body);
    await asyncFunction2(req.body);
  }
  catch (error){
    next(error);
  }
})

Can we refactor this code even more?

Writing try/catch blocks in every request handler would not be a great way of writing code. Whenever you see duplication, you know things are getting more complicated than they should be.

A simpler way to do this would be to convert the above code into a promise:

app.post('/test', async (req, res) => {
  let runAsync = () => {
    await asyncFunction1(req.body);
    await asyncFunction2(req.body);
  }
  runAsync().catch(next);
})

And the logical next step is to abstract the catch mechanism into a different method of it’s own.

function runAsyncWrapper (callback) {
  return function (req, res, next) {
    callback(req, res, next)
      .catch(next)
  }
}

app.post('/test', runAsyncWrapper(async (req, res) => {
    await asyncFunction1(req.body);
    await asyncFunction2(req.body);
}));

Now you can keep using the wrapper function and keep writing async/await in ExpressJs just like you would anywhere else, without having to worry about other things.

You can also use packages like express-async-handler and @awaitjs/express to do the same thing if you do not like writing the wrapper function yourself. The packages do the same thing but in a robust way, they ensure that next is always the last argument being passed.

And that is it! Start using async/await in express as if it’s nobody’s business.

Recent Articles

Common Data Distributions for Data Science

Data distributions lie at the heart of all the machine learning algorithms and data science techniques. A machine learning algorithm is only...

The new Logical Assignment Operators in JavaScript

The latest version of ECMAScript introduced three new logical assignment operators: nullish, AND, and OR operators. These are supported from Firefox 79...

How to groupby using reduce in JavaScript

The groupBy method is one of the reasons people use lodash in their project. In this blog post, we will write our...

Overcoming Procrastination and The Akrasia Effect

We all know what we should be doing right now. But we don't want to! That is procrastination in a nutshell.

Learning context API and the useContext React hook

In this react hooks series, we have already explored the react hooks useState, useEffect, and useReducer. The next react hook we will...

Related Stories

Hi there! Want some more knowledge?

Think that the knowledge shared is helpful? You might want to give our mailing list a try. We'll send you 2-4 emails a month, right when new posts come out.

Hi there! Want some more knowledge?

Think that the knowledge shared is helpful? You might want to give our mailing list a try. We'll send you 2-4 emails a month, right when new posts come out.