0.6 Manipulating data Express async/await

nayib

hello @davidmarkclements ,

**I wonder if this statement from your course is still relevant
**

" ... using async/await with Express is recommended against. Express was built before async/await syntax was part of the JavaScript language and as a result it does not always behave as expected." source: https://trainingportal.linuxfoundation.org/learn/course/nodejs-services-development-lfw212/manipulating-data-with-restful-services/manipulating-data-with-restful-services?page=8

**I wondering in which case handling asynchronous code errors with try/catch will not work. Can you give me some examples?
**

I add one here that works and can not identify any use case where the try/catch block will not catch the error:

const express = require('express')
const PORT = process.env.PORT || 3000;
const app = express()

app.use(express.json());

function foo() {
  return new Promise((resolve, reject) => {
    setTimeout(() => {
      reject(new Error('Rejection from promise foo function'))
    }, 2000);
  })
};

function errorHandler(req, res, next) {
  res.status( err.status || 500 )
     .json({
       error:'handled by errorHandler NOT from the try catch'
     });
}

app.get('/', async  (req, res, next) => {
  try {
    const result = await foo();
    res.status(200).json(result);
  } catch (err) {
    res.status(404).json({ error: err.message });
  }
});

app.use(errorHandler)

app.listen(PORT, () => console.log(`Server listening at PORT: ${PORT}`));

The above will catch the rejected Promise and handle the error from the promise.

Looking forward to your response. Thanks

davidmarkclements

hey @nayib - you've handled the case with a try/catch - as long as you do that it's fine. The problem is, it can be very easy to neglect to use a try/catch in an async route handler particularly when refactoring. e.g:

app.get('/', async  (req, res) => {
    const result = await foo();
    res.status(200).json(result);
});

Also consider that multiple people may work on the same code base, and your chances of someone forgetting to try/catch increase significantly.

When that happens, promise rejections can be swallowed. When promise rejections are swallowed two unwanted things happen. 1. You get a memory leak. This is per the Promise spec, and the memory leak is internal to the JS engine, there is no way to clean that up. 2. Your application enters an unknown state, you have an error, it wasn't handled, you may not even know about it.

So essentially, it's a foot gun. Hopefully a future Express update will automatically check for promises and provide an integrated catch handler that converts promise rejections into HTTP errors - at the time of writing the material (and I think it's still the case) Express does not do that.

On a side note, in your code you set up an error handler and then manually handled the error, you're probably better off doing this per Express convention:

app.get('/', async  (req, res, next) => {
  try {
    const result = await foo();
    res.status(200).json(result);
  } catch (err) {
    err.status = err.status || 404
    next(err)
  }
});