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

Chrome devtools: Using logpoints for logging messages directly

When it comes to debugging JavaScript in Chrome devtools, there are two different camps: the console.log fans and the debugger/breakpoint maximalist. I...

How to prevent npm install for unsupported Node.js versions

npm configurations allow us to do quite a lot of nifty things. One of them is to allow the project to set...

How to terminate a process on a port using the command line

Zombie processes are usually a pain to figure out. More often than not, I end up googling about how to terminate a...

Detecting dark mode preference using JavaScript

As dark themes have become popular across the web and across operating systems, we might want to check the user's operating system...

JavaScript: Split string and keep the separators

String.prototype.split() is a valuable method to split strings based on a delimiter. There often comes a scenario when we want to split...

Related Stories

Leave A Reply

Please enter your comment!
Please enter your name here

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.