Issues with Async/Await during SOAP API call Javascript

Hopefully someone can point me to the right direction. I read up on waiting for functions to complete before continuing and I resolved myself to using await/async but I am just stuck now.

I tried to get the Async/Await process to work, tried to inject the await in various locations, with adjusting the functions to be async, but i can not get the PSA_Resultbody to return to the original request. Any pointers would be appreciated.

Thank you,

CE

PSA_Resultbody = ProcessPSAAPI(xmlpackage, PSA_Action);
console.log("3 - Returned data:" + PSA_Resultbody);

calls the below:

async function ProcessPSAAPI(xmlpackage, PSA_Action) {  //psa action is part of the options

  var options = {...};
  var req = https.request(options, function (res) {
    var chunks = [];
    res.on("data", function (chunk) {
      chunks.push(chunk);
     });
  
    res.on("end", function (chunk) {
      var body =  Buffer.concat(chunks);
      console.log('0 - Start '+body.toString());
      if(res.statusCode != 200) {
         PSA_Resultcode = "Error: " +res.statusCode +" - "+ res.statusMessage;
        } else {
         PSA_Resultcode = "Success: " +res.statusCode +" - "+ res.statusMessage;
         PSA_Resultbody = ParseResults(body.toString()); //parse the results for later use  --SCRIPT NEEDS TO WAIT FOR RESULTBODY TO COMPLETE
                console.log("1 -PSA_Resultbody as part of RES = "+PSA_Resultbody);
        } 
     });
    res.on("error", function (error) {
      console.error(error);
      PSA_Resultcode = res.statusCode +" - "+ res.statusMessage;
     });

   });
   console.log('2 -RESULT BODY BEFORE SENDING BACK TO INITIATING FUNCTION: '+PSA_Resultbody);
   req.write(xmlpackage);
   req.end();
  return PSA_Resultbody;

Based on the above, my console log order is: 3,2,0,1 in stead of 0,1,2,3.

0 and 1 will have the correct data, so the API Call does work, but 2 will be "undefined" and should have the same data that is in 1.

There's no way to await an event emitter, so using async in this case isn't going to be useful. You cannot "return" from inside an event either.

The solution here is to return a new custom promise and to use resolve() inside of the "end" event of your emitter.

It will look something like this:

function ProcessPSAAPI(xmlpackage, PSA_Action) {
  return new Promise( (resolve, reject) => {
    // other code
    res.on("end", function (chunk) {
      // other code
      resolve(PSA_Resultbody);
    });
    res.on("error", function (error) {
      // other code
      reject(error);
    });
  });
}

Here's a quick tutorial on creating your own promises, which I've written to simplify comprehension of the subject (official docs are somewhat dry and complex imho).

I did not change your code. I just put the appropriate promise structure in to get you started. This should really be a lesson in promises. async await is a shorthand promise structure. A Promise is one way you wait on code. It can be thought of as an array of callbacks that will be executed when the Promise is resolved.

A simple promise works like this:

const myPromise = new Promise(function(resolve, reject) {
/* Your logic goes in here. It can be anything. 
* But the important part to remember is that when you have success, resolve it. 
* When you have a failure, reject it.
*/
someCallBackPattern(function(error, data) {
if(error) {
reject(error);
} else {
resolve(data);
}
});
});
// To get the data out you use 'then', and 'catch'. then has two arguments.
myPromise.then(function(data) {
// The first argument is the result from resolve.
}, function(err) {
// The second argument is the result from reject.
}).catch((err) => {
// you can also get to the error from the catch callback
});

This is kinda messy and complex. So there is async await.

async function() {
try {
const result = await myFunctionThatReturnsAPromise();
// result is the resolved data
} catch (err) {
// err is the rejected Error
}
}
function myFunctionThatReturnsAPromise() {
return new Promise((resolve, reject) => {
// your code
})
}

And thats how it works.

async function someFunction () { // You can not wait on results unless you are in an await function
PSA_Resultbody = await ProcessPSAAPI(xmlpackage, PSA_Action); // await on your results.
console.log("3 - Returned data:" + PSA_Resultbody);
}
function ProcessPSAAPI(xmlpackage, PSA_Action) { // This does not need to be async. Unless you are awaiting in it.
return new Promise((resolve, reject) => { // async await is a shorthand promise structure. Although you do not need to use promises. It really helps to get the structure correct.
var options = {...};
var req = https.request(options, function (res) {
var chunks = [];
res.on("data", function (chunk) {
chunks.push(chunk);
});
res.on("end", function (chunk) {
var body =  Buffer.concat(chunks);
console.log('0 - Start '+body.toString());
if(res.statusCode != 200) {
PSA_Resultcode = "Error: " +res.statusCode +" - "+ res.statusMessage;
reject(new Error(PSA_Resultcode)); // Reject you errors
} else {
PSA_Resultcode = "Success: " +res.statusCode +" - "+ res.statusMessage;
PSA_Resultbody = ParseResults(body.toString()); //parse the results for later use  --SCRIPT NEEDS TO WAIT FOR RESULTBODY TO COMPLETE
console.log("1 -PSA_Resultbody as part of RES = "+PSA_Resultbody);
resolve(PSA_Resultbody); // Resolve your result
} 
});
res.on("error", function (error) {
console.error(error);
PSA_Resultcode = res.statusCode +" - "+ res.statusMessage;
reject(new Error(PSA_Resultcode)); // Reject you errors
});
});
console.log('2 -RESULT BODY BEFORE SENDING BACK TO INITIATING FUNCTION: '+PSA_Resultbody);
req.write(xmlpackage);
req.end();
})
}