async/await doesn't throw exception when reject() is called

[mersadk]

TypeScript Version: 1.8.10
Tested with node v6.1.0

I have an async function that returns a Promise. If I call resolve() everything works file. If I call reject(), await will not throw any exception and program will just hang.

I used example from this blog post and it works as described (https://blogs.msdn.microsoft.com/typescript/2015/11/03/what-about-asyncawait/). If you change it to call reject() insted of resolve(), nothing will happen and a program will hang (code below).

async function main() {
 await ping();
 process.exit();
}

async function ping() {
 for (var i = 0; i < 10; i++) {
  await delay(300);
  console.log("ping");
 }
}

function delay(ms: number) {
    return new Promise((resolve, reject) => setTimeout(() => reject("This doesn't work!"), ms));
}

main();

[vladima]

you need to use Promise.then or Promise.catch to uncover the fact that Promise returned by main is rejected.

async function main() {
 await ping();
 process.exit();
}

async function ping() {
 for (var i = 0; i < 10; i++) {
  await delay(300);
  console.log("ping");
 }
}

function delay(ms: number) {
    return new Promise((resolve, reject) => setTimeout(() => reject("This doesn't work!"), ms));
}

main().catch(console.log.bind(console));

[mersadk]

you need to use Promise.then or Promise.catch to uncover the fact that Promise returned by main is rejected.

But I am using async/await to avoid using those callbecks.

I you look code at https://github.com/Microsoft/TypeScriptSamples/blob/master/async/src/lib/index.ts there is a comment at the beginning of a main() function

// The async keyword indicates to TypeScript that it must
// modify the emit of the function. As a result, this function
// will return a Promise at run-time, and will pause execution
// at any point where it encounters an await expression
// until the awaited value has either been resolved with a value,
// or rejected with an error.

Also there is a following comment as well

// Here we await the result of the asynchronous function call. In this case,
// the function call returns a Promise instance. As a result, execution of this function
// will pause until the Promise is resolved with a value, or rejected
// with an exception.

From that, I would expect it to throw exception when promise is rejected.

.

[yortus]

@mersadk await does throw if the promise it is awaiting is rejected. You can see this by putting a try/catch around it:

async function main() {
    await ping();
    process.exit();
}

async function ping() {
    for (var i = 0; i < 10; i++) {
        try {                           // <=====
            await delay(300);
            console.log("ping");
        }
        catch (err) {                   // <=====
            console.log(err);
        }
    }
}

function delay(ms: number) {
    return new Promise((resolve, reject) => setTimeout(() => reject("This doesn't work!"), ms));
}

main();

// Outputs:
// This doesn't work!
// This doesn't work!
// This doesn't work!
// This doesn't work!
// This doesn't work!
// This doesn't work!
// This doesn't work!
// This doesn't work!
// This doesn't work!
// This doesn't work!

Because in your version the error is not caught, it bubbles up and rejects the promise returned by the call to ping(). That throws an error inside main (you can check this by putting a try/catch around the await ping() there). The error inside main is not caught either, so it bubbles up and rejects the promise returned by the call to main().

Now main() is a top-level call, and you cannot write await main() at the top-level (ie outside an async function), so you cannot get it to throw. But you can catch it's rejected promise by attaching a catch handler as @vladima showed.

If you don't handle the error at all, it will be emitted as an unhandled rejection by the node process. You can check this by adding the following code to your example:

process.on('unhandledRejection', (reason) => {
    console.log(reason);
});

[jakob-e]

FWIW you could use a try catch wrapper

async function orDie(promise){
    try{ return await promise; } 
    catch(err){ return err; }
}
(async ()=>{
    const rejected = await orDie(Promise.reject('promise was rejected'));
    const resolved = await orDie(Promise.resolve('promise was resolved'));    
    console.log(rejected, resolved);
})();

[Berezza98]

reject(new Error('we have some error'));

try to do that.