In my Node 8.1.2 project, I encountered a scenario where one file is calling another file's function within a map structure. While in a real example, I would normally use Promise.all on the map, that specific implementation is not the focus of this question. Here is the existing structure:
A.js:
const { b } = require('./B')
function expressStuff (req, res, next) {
things.map(thing => {
return b(thing)
}))
return res.status(200).json(...)
}
B.js:
// Thing -> Promise<Object>
function b (thing) {
return ThingModel.update(...) // Even though this returns a Promise, it fails and throws an error
}
module.exports = { b }
Inside the b function, there is an attempt to fetch async data from a database, which results in an Uncaught Promise Rejection.
How can this issue be resolved?
I have experimented with various solutions:
A1.js:
const { b } = require('./B')
function expressStuff (req, res, next) {
things.map(thing => {
try {
return b(thing)
} catch (err) {
return next(err)
}
}))
return res.status(200).json(...)
}
Unfortunately, this approach still does not handle the error correctly.
A2.js:
const { b } = require('./B')
function expressStuff (req, res, next) {
try {
things.map(thing => {
return b(thing)
}))
} catch (err) {
return next(err)
}
return res.status(200).json(...)
}
This method also proves to be ineffective in handling the error properly. Despite attempts including using Promise.all and double try-catch blocks, the error remains unhandled.
The closest solution found so far was to manage the error within the function itself, but this resulted in code execution not waiting for the error to be thrown, leading to race conditions and errors related to setting headers after they are already sent.
The main objective is to allow the function b to throw an error and catch it in the expressStuff function to rethrow a custom UnprocessableEntityError through next. It seems like the error originating from file B is not propagating up to the map where it is invoked.
How can this desired behavior be achieved?
UPDATE:
The only way I managed to handle this rejection was by implementing a try-catch within B.js. However, any attempts to rethrow or return the error were unsuccessful as the error seemed to get swallowed. Interestingly, logging the error using console.log did work.
FURTHER DETAILS:
Following the advice provided in the accepted answer, I refactored my actual code and successfully resolved the issue:
function expressStuff (res, req, next) {
try {
await Promise.all(things.map(async thing => {
if (ifSomething()) {
await b(thing)
}
}))
} catch (err) {
return next(new MyCustomError('My Custom Error Message'))
}
return res.status(200).json(...)
}