How to bubble up Exceptions from inside async/await functions in NodeJs?-CodePudding

Assume an Express route that makes a call to Mongoose and has to be async so it can await on the mongoose.find(). Also assume we are receiving XML but we have to change it to JSON, and that also needs to be async so I can call await inside of it.

If I do this:

app.post('/ams', async (req, res) => {
try {
    xml2js.parseString(xml, async (err, json) => {
        if (err) {
           throw new XMLException();
        }


        // assume many more clauses here that can throw exceptions
        
        res.status(200);
        res.send("Data saved")

    });

} catch(err) {
    if (err instanceof XML2JSException) {
        res.status(400);
        message = "Malformed XML error: "   err;
        res.send(message);
    }
}
}

The server hangs forever. I'm assuming the async/await means that the server hits a timeout before something concludes.

If I put this:

        res.status(200);
        res.send("Data saved")

on the line before the catch(), then that is returned, but it is the only thing every returned. The client gets a 200, even if an XMLException is thrown.

I can see the XMLException throw in the console, but I cannot get a 400 to send back. I cannot get anything I that catch block to execute in a way that communicates the response to the client.

Is there a way to do this?

CodePudding user response：

In a nutshell, there is no way to propagate an error from the xml2js.parseString() callback up to the higher code because that parent function has already exited and returned. This is how plain callbacks work with asynchronous code.

To understand the problem here, you have to follow the code flow for xml2js.parseString() in your function. If you instrumented it like this:

app.post('/ams', async (req, res) => {
    try {
        console.log("1");
        xml2js.parseString(xml, async (err, json) => {
            console.log("2");
            if (err) {
                throw new XMLException();
            }

            // assume many more clauses here that can throw exceptions

            res.status(200);
            res.send("Data saved")

        });
        console.log("3");
    } catch (err) {
        if (err instanceof XML2JSException) {
            res.status(400);
            message = "Malformed XML error: "   err;
            res.send(message);
        }
    }
    console.log("4");
});

Then, you would see this in the logs:

1    // about to call xml2js.parseString()
3    // after the call to xml2js.parseString()
4    // function about to exit
2    // callback called last after function returned

The outer function has finished and returned BEFORE your callback has been called. This is because xml2js.parseString() is asynchronous and non-blocking. That means that calling it just initiates the operation and then it immediately returns and the rest of your function continues to execute. It works in the background and some time later, it posts an event to the Javascript event queue and when the interpreter is done with whatever else it was doing, it will pick up that event and call the callback.

The callback will get called with an almost empty call stack. So, you can't use traditional try/catch exceptions with these plain, asynchronous callbacks. Instead, you must either handle the error inside the callback or call some function from within the callback to handle the error for you.

When you try to throw inside that plain, asynchronous callback, the exception just goes back into the event handler that triggered the completion of the asynchronous operation and no further because there's nothing else on the call stack. Your try/catch you show in your code cannot catch that exception. In fact, no other code can catch that exception - only code within the exception.

This is not a great way to write code, but nodejs survived with it for many years (by not using throw in these circumstances). However, this is why promises were invented and when used with the newer language features async/await, they provide a cleaner way to do things.

And, fortunately in this circumstance xml2js.parseString() has a promise interface already.

So, you can do this:

app.post('/ams', async (req, res) => {
    try {
        // get the xml data from somewhere
        const json = await xml2js.parseString(xml);
        // do something with json here
        res.send("Data saved");
    } catch (err) {
        console.log(err);
        res.status(400).send("Malformed XML error: "   err.message);
    }
});

With the xml2js.parseString() interface, if you do NOT pass it a callback, it will return a promise instead that resolves to the final value or rejects with an error. This is not something all asynchronous interfaces can do, but is fairly common these days if the interface had the older style callback originally and then they want to now support promises. Newer interfaces are generally just built with only promise-based interfaces. Anyway, per the doc, this interface will return a promise if you don't pass a callback.

You can then use await with that callback. If the promise resolves, the await will retrieve the resolved value of the promise. If the promise rejects, because you awaiting the rejection will be caught by the try/catch. FYI, you can also use .then() and .catch() with the promise, but in many cases, async and await are simpler so that's what I've shown here.

So, in this code, if there is invalid XML, then the promise that xml2js.parseString() returns will reject and control flow will go to the catch block where you can handle the error.

If you want to capture only the xml2js.parseString() error separately from other exceptions that could occur elsewhere in your code, you can put a try/catch around just it (though this code didn't show anything else that would likely throw an exception so I didn't add another try/catch). In fact, this form of try/catch can be used pretty much like you would normally use it with synchronous code. You can throw up to a higher level of try/catch too.

A few other notes, many people who first start programming with asynchronous operations try to just put await in front of anything asynchronous and hope that it solves their problem. await only does anything useful when you await a promise so your asynchronous function must return a promise that resolves/rejects when the asynchronous operation is complete for the await to do anything useful.

It is also possible to take a plain callback asynchronous function that does not have a promise interface and wrap a promise interface around it. You pretty much never want to mix promise interface functions with plain callback asynchronous operations because error handling and propagation is a nightmare with a mixed model. So, sometimes you have to "promisify" an older interface so you can use promises with it. In most cases, you can do that with util.promisify() built into the util library in nodejs. Fortunately, since promises and async/await are the modern and easier way to do asynchronous things, most newer asynchronous interfaces in the nodejs world come with promise interfaces already.

CodePudding user response：

You are throwing exceptions inside the callback function. So you cant expect the catch block of the router to receive it.

One way to handle this is by using util.promisify.

try{
const util = require('util');
const parseString = util.promisify(xml2js.parseString);
let json = await parsestring(xml);
}catch(err)
{
...
}