Async Await vs CallBack in Express Production server - node.js

Question

I was reading production best practices given in express documentation, where they mentioned do not use synchronous functions. Now, earlier I used to write my controllers like this:
without async await, only call backs.
exports.getSubjectById = (req, res) => {
const subjectId = req.query.subjectId;
Subject.findOne({
subjectId: subjectId
}, function (err, subjects) => {
if (err) {
return res.status(400).json(err);
}
return res.status(200).json(subjects);
});
}
then I started writing like this using async but not await and call backs.
exports.getSubjectById = async (req, res) => {
const subjectId = req.query.subjectId;
Subject.findOne({
subjectId: subjectId
}, function (err, subjects) => {
if (err) {
return res.status(400).json(err);
}
return res.status(200).json(subjects);
});
}
then I finally wrote this async await and NO callbacks.
exports.getSubjectById = async (req, res) => {
const subjectId = req.query.subjectId;
const subject = await Subject.findOne({
subjectId: subjectId
});
if (!subject) {
return res.status(404).json({
error: "no subject found for this id"
})
} else {
return res.status(200).json(subject);
}
}
can anyone please tell me which one should I use as production best practice and difference between these methods?

Answer 1

In this case, number 3 is better, but you need to consider the exception case.
So, you need to add try catch when you call async function.
exports.getSubjectById = async (req, res) => {
const subjectId = req.query.subjectId;
try {
const subject = await Subject.findOne({
subjectId: subjectId
});
if (!subject) {
return res.status(404).json({
error: "no subject found for this id"
})
} else {
return res.status(200).json(subject);
}
} catch (error) {
// exception, maybe db is broken when query data
console.log(error);
return res.status(500).end("Exception")
}
}
And about don't use synchronous, there is an example you could take a look.
If I want api send the response after 5 second delay, what should I do?
In Java, you maybe use sleep(5) to delay.
So you might use following code when you write node.js.
exports.getSubjectById = async (req, res) => {
const startTime = new Date().getTime()
while(new Date().getTime() - startTime < 5000){}
res.status(200).send("Success")
}
It'll work, but it'll block the thread.
In node.js, you should use setTimeout to simulate the delay 5 seconds.
exports.getSubjectById = async (req, res) => {
setTimeout(() => {
res.status(200).send("Success")
}, 5000)
}
Above example, while loop is synchronous function.
But setTimeout is asynchronous function.
Due to the mechanism of node.js, you should use asynchronous function instead of synchronous function.

Answer 2

Solution number 3 is good and also, most importantly, correct practice. Accessing the database is asynchronous by itself, it returns a promise. If you use async / await, it will return exactly what you are requesting. Also you can write simple test, for example, the speed of execution for each...