Node.JS - Can`t Get Async Throws With Try/catch Blocks

When I create an async function in node and use await, I'm making the execution waits for a promise resolution (that can be a resolve or a rejection), what I do is put an await pro

Solution 1:

async functions always return promises. In fact, they always return native promises (even if you returned a bluebird or a constant). The point of async/await is to reduce the version of .then callback hell. Your program will still have to have at least one .catch in the main function to handle any errors that get to the top.

It is really nice for sequential async calls, e.g.;

async function a() { /* do some network call, return a promise */ }

async function b(aResult) { /* do some network call, return a promise */ }

async function c() {
   const firstRes = (await (a() /* promise */) /* not promise */);
   const secondRes = await b(firstRes/* still not a promise*/);
}

You cannot await something without being inside a function. Usually this means your main function, or init or whatever you call it, is not async. This means it cannot call await and must use .catch to handle any errors or else they will be unhandled rejections. At some point in the node versions, these will start taking out your node process.

Think about async as returning a native promise - no matter what - and await as unwrapping a promise "synchronously".

• note async functions return native promises, which do not resolve or reject synchronously:

  Promise.resolve(2).then(r => console.log(r)); console.log(3); // 3 printed before 2
  Promise.reject(new Error('2)).catch(e => console.log(e.message)); console.log(3); // 3 before 2
  

• async functions return sync errors as rejected promises.

  async function a() { throw new Error('test error'); }
  
  // the following are true if a is defined this way too
  async function a() { return Promise.reject(new Error('test error')); }
  
  /* won't work */ try { a() } catch(e) { /* will not run */ }
  
  /* will work */ try { await a() } catch (e) { /* will run */ }
  
  /* will work */ a().catch(e => /* will run */)
  
  /* won't _always_ work */ try { return a(); } catch(e) { /* will not usually run, depends on your promise unwrapping behavior */ }
  

Solution 2:

Main must be an async function to catch async errors

// wont work
let main = () =>{
    try{
        test();
    }catch(error){
        console.log("error in main() =", error);
    }
}

// will work
let main = async () =>{
    try{
        test();
    }catch(error){
        console.log("error in main() =", error);
    }
}