Wsrtjtyk

I have a function that returns a promise like this:

let aFunction= function(){

    return new Promise((resolve, reject){

       someNodeApi(params, function(err, data)) {

          if(err) {

            return reject(err);

          }

          if(data meets certain criteria) {

             someOtherNodeApi(params, function(err, data)) {

                // handle conditions.

             }

          }

          resolve(data);

       }         

    })

}

I want to have an async function equivalent for this kind of function. In short, I need something like this:

let aFunction = async function(){

   someNodeApi(params, function(err, data){

      if(err) {

          // reject condition

      }

      // resolve condition.

   })

}

So what should be in above reject and resolve conditions so that all the places where I call the function like this:

aFunction()

  .then(data=>{})

  .catch(err=>{})

It should be unchanged.

EDIT

I have to clarify that my question is not about how to call the async function. But its about how to convert a function that returns a Promise to be able to use the goodness of async-await pattern without having to modify the way its called. (A very common scenario when you are dealing with pre async-await era node js code).

This is how I like to write async/await , makes it pretty straightforward. All of the code inside can be read as sync.
EDIT: await will work only if the API returns a promise object that is either resolved or rejected. await does not resolve promises.

function someAPI() {

    return new Promise((resolve, reject)=>{

      someNodeApi(params, function(err, data){

            if(err) {

                reject(error)

            } else {

              resolve(data)

            }

            // resolve condition.

        })

    });

  }





async function aFunction() {

  try {

    const result = await someAPI();

    return result;

  } catch(err){

    console.log(err);

  }

}



aFunction()

.then((res) => console.log(res))

When changing to async/await, what changes isn't your promise setup, but rather how you make calls to your promises. For example:

aFunction()

  .then(data=>{})

  .catch(err=>{})



// becomes

try{

  const data = await aFunction()

}catch(err){

  // do something with err

}

Just bear in mind that the function that uses await needs to be set to async.

If your someNodeApi call was already setup for promises, then the result would still be exactly the same, you simply wouldn't need aFunction at all. For example, if you used a promisifying library on your api, then you don't need aFunction at all.

someNodeApi(params)

  .then(data => {})

  .catch(err => {})



// or



const data = await someNodeApi(params)

if(data meets certain criteria) {

   const otherData = someOtherNodeApi(params)

}

Snippet1 : Here, you can see the usage of async-await

let fn = async function(a) {

	let val = 10;

	return new Promise((resolve, reject) => {

		if(a > val) {

			resolve("+++++Resolved");

		}

		else {

			reject("++++++Rejected")

		}

	})

};



(async () => {

	try {

		let result1 = await fn(20);

		console.log(result1);



		let result2 = await fn(5);

		console.log(result2);

	}

	catch(err) {

		console.error(err);

	}

    

})();

Snippet2 : Here you can see that using .then.catch will not harm or break any of your code.

let fn = async function(a) {

	let val = 10;

	return new Promise((resolve, reject) => {

		if(a > val) {

			resolve("+++++Resolved");

		}

		else {

			reject("++++++Rejected")

		}

	})

};



fn(20).then(response => {

	console.log(response);

});



fn(5)

	.then(response => {

		console.log(response);

	})

	.catch(err => {

		console.error(err);

	})

It does not break your code if you use fn().then.catch pattern on a Promise returning async fumction.

However, using await makes it more elegant.

Feel free to refer a detailed article that I have written on basics of
async-await and why async-await compared to .then.catch pattern, pros
and cons here: https://github.com/cskru/asyncAwaitSimplified

I have included code snippets which you can directly copy paste and try out.

PS: I have used async IIFE in the above snippets.

This is because awaits can be made inside async function/context only.

I'd also recommend you to check this article to get a solid foundation wrt async-await.

Happy learning!

Cheers,

Kruthika