CODEWITHSUNDEEP
javascriptnode.jsloopsasynchronousasync-await
aHiltn
aHiltn

Reputation: 51

Why is this async function failing to return any data?

So, a quick overview, this function is part of a larger app that ingests JSON data and prepares it to be rendered by Handlebars, which is then used for generating a PDF. This particular function has been giving me grief, as from my understanding of how async/await works, the data should be returned by the return returnArray at the bottom of the function. This however does not happen, and instead the empty array is returned. Could anyone offer insight as to why this is? (N.B. I've checked the data is present in iarr when it gets pushed, it's as though the return statement gets fired before the for loop has started.)

async function getPackageItem(item) {
  try {
    let returnArray = []
    if (fs.existsSync(__dirname + "/../json/" + item.sku + ".json")) {
      var file = fs.readFileSync(__dirname + "/../json/" + item.sku + ".json")
    } else {
      var file = fs.readFileSync(__dirname + "/../json/box.json")
    }
    const tb = JSON.parse(file);
    for (var a = 0; a < item.quantity; a++) {
      let iarr = [];
      if (tb) {
        tb.forEach(function(entry) {
          ShopifyAuth.get('/admin/products/' + entry.product_id + '.json', (err, productData) => {
            if (!err) {
              ShopifyAuth.get('/admin/products/' + entry.product_id + '/metafields.json', (err, metafieldData) => {
                if (!err) {
                  var itemObject = {};
                  var metaCounter = 0;
                  metafieldData.metafields.forEach(function(metadata) {
                    switch(metadata.key) {
                      case "notes": {
                        itemObject.wm_notes = metadata.value;
                        metaCounter++
                        break;
                      }
                      case "title": {
                        itemObject.title = metadata.value;
                        metaCounter++
                        break;
                      }
                      case "vintage": {
                        itemObject.year = metadata.value;
                        metaCounter++;
                        break;
                      }
                      case "shelfid": {
                        itemObject.shelf_id = metadata.value;
                        metaCounter++;
                        break;
                      }
                      case "bottleprice": {
                        itemObject.bottle_price = metadata.value;
                        metaCounter++;
                        break;
                      }
                      default: {
                        metaCounter++;
                        break;
                      }
                    }
                    if(metaCounter === metafieldData.metafields.length) {
                      itemObject.vendor = productData.product.vendor;
                      if (itemObject.title == undefined) {
                        itemObject.title = productData.product.title
                      }
                      if (itemObject.wm_notes == undefined) {
                        itemObject.wm_notes = " "
                      }
                      if (itemObject.year == undefined) {
                        itemObject.year = "Unspecified"
                      }
                      if (itemObject.shelf_id == undefined) {
                        itemObject.shelf_id = "N/A"
                      }
                      if (productData.product.images[1] == undefined) {
                        if (productData.product.images[0]) {
                          itemObject.logo = productData.product.images[0].src;
                        } else {
                          itemObject.logo = '';
                        };
                      } else {
                        itemObject.logo = productData.product.images[1].src;
                      }
                      itemObject.quantity = item.quantity;
                      iarr.push(itemObject)
                      if(iarr.length == tb.length) {
                        returnArray.push(iarr);
                      }
                    }
                  });
                } else {
                  throw Error('Error retrieving product metadata');
                }
              })
            } else {
              throw Error('Error retrieving product data');
            }
          })
        })
      } else {
        throw Error('Error loading JSON for specified box');
      }
    }
    return returnArray;
  } catch (e) {
    console.log(e)
  }
}

Edit: That's what I get for writing code at 3am, not sure how I missed that. Thanks for your feedback.

Upvotes: 1

Views: 116

Answers (1)

pretzelhammer
pretzelhammer

Reputation: 15115

You marked your function async but you're not using await anywhere inside of it so you're not getting any of the benefits of using async. It doesn't make your function magically synchronous, you still have to manage asynchronicity carefully.

If ShopifyAuth.get supports returning a promise then await on the result instead of passing callbacks and your code will work, otherwise construct a Promise, do the async stuff in the promise, and return the promise from the function.

async function getPackageItem(item) {
  let result = new Promise((resolve, reject) => {
    // all your ShopifyAuth stuff here
    if (err) {
      reject(err);
    }
    resolve(returnArray);
  });
  return result;
}

Upvotes: 1

Related Questions