In Node.js, what's the correct way to handle an error using async / await? - node.js

Question

Currently, I have a function as follows:
export async function getFiles (param: any) {
try {
const results = await ... // code to get results from database;
const files = [];
for (let i = 0; i < results.length; i++) {
files.push(results[i]);
}
return files;
}
catch (error) {
console.log(error);
}
}
Separately, I use the library function as follows:
const files = await lib.getFilesAsync(param);
for (const file of files) {
// process file here
}
How do I properly add error handling to this code?
I've tried returning an error in catch:
catch (error) {
console.log(error);
return new Error("getFiles error");
}
but then I get the following error at compile time:
Type 'Error' must have a '[Symbol.iterator]()' method that returns an iterator. (2488)

Answer 1

An async function returns a promise. So, inside that async function you have to make a design decision about whether you want an error to return a rejected promise or some sort of specific error that you can test for. In either case, the caller of the async function needs to do error checking. Here are two possible ways to implement it. It's really your design choice which way to go.
It's somewhat analogous to a synchronous function that can either return a sentinel value like null that must be tested for by the caller when it has an error or it can throw an exception that would be caught by the caller with try/catch.
Caller uses .catch() or try/catch
export async function getFiles (param: any) {
// if any await operation here rejects, the promise returned
// from getFiles() will reject and the caller can .catch() the error
const results = await ... // code to get results from database;
const files = [];
for (let i = 0; i < results.length; i++) {
files.push(results[i]);
}
return files;
}
// usage
getFiles(...).then(files => {
console.log(files);
}).catch(err => {
console.log(err);
})
// or, you could use it this way
try {
let files = await getFiles(...);
console.log(files);
} catch(e) {
console.log(e);
}
Caller checks for error on resolved promise
export async function getFiles (param: any) {
try {
const results = await ... // code to get results from database;
const files = [];
for (let i = 0; i < results.length; i++) {
files.push(results[i]);
}
return files;
}
catch (error) {
console.log(error);
return new Error("getFiles error");
}
}
// usage:
getFiles(...).then(files => {
console.log(files);
if (files instanceof Error) {
// error
} else {
// process files array here
}
});
// or, you could use it this way
let files = await getFiles(...);
console.log(files);
if (files instanceof Error) {
// error
} else {
// process files array here
}
Personally, I prefer to use the rejected promise because it's a lot easier to sequence or chain async operations if you let the promises manage the error propagation for you.