多个 API 调用的 Nodejs 中的套接字挂断错误

Question

I am trying to fetch a list of all companies listed in stock market from an external API, and after getting the list, I am trying to fetch all details regarding individual companies including graph data. It was all working fine. However, today I am getting socket hangup error. I have tried going through other posts here in stackoverflow. However, none of them works.

const request = require('request');

const fetchAPI = apiPath => {
    return new Promise(function (resolve, reject) {
        request(apiPath, function (error, response, body) {
            if (!error && response.statusCode == 200) {
                resolve(body);
            } else {
                reject(error);
            }
        });
    });
}


// get list of all companies listed in
const fetchCompanyDetails = () => {
    return new Promise(function (resolve, reject) {
        let details = [];
        fetchAPI('https://api//')
        .then(res => {
            res = JSON.parse(res)
            details.push(res);
            resolve(details);
        })
        .catch(err => {
            console.log("error at fetchcompany details" + err);
        })
    });
}

const getDateAndPriceForGraphData = (graphData) => {
    let res = []
    graphData.forEach(data => {
        let d = {}
        d["x"] = new Date(data.businessDate).getTime() / 1000
        d["y"] = data.lastTradedPrice
        res.push(d)
    })
    return res
}


// get graph data for individual assets
const getGraphDataForAssets = (assetID) => {
    return new Promise((resolve, reject) => {
        let details = {};
        fetchAPI(`https://api/${assetID}`)
        .then(async (res) => {
            res = JSON.parse(res)
            let data = await getDateAndPriceForGraphData(res)
            details = data
            resolve(details);
        })
        .catch(err => {
            console.log("error at getGraphDataForAssets" + err);
        })
    });
}


// fetch data about individual assets
const fetchAssetDetailsOfIndividualCompanies = (assetID) => {
    return new Promise((resolve, reject) => {
        let details = {"assetData" : {}, "graphData": {}};
        fetchAPI(`https://api/${assetID}`)
        .then(async (res1) => {
            res1 = JSON.parse(res1)
            details["assetData"] = res1
            // get graph data
            var graphData = await getGraphDataForAssets(assetID)
            details["graphData"] = graphData
            resolve(details);
        })
        .catch(err => {
            console.log("error at fetchAssetDetailsOfIndividualCompanies" + err);
            reject(err)
        })
    });
}


// returns list of details of all tradeable assets (Active and Suspended but not delisted)
const fetchDetailsForEachCompany = async (companyList) => {
    let result = []

    await Promise.all(companyList.map(async (company) => {
        try {
            // return data for active and suspended assets
            if(company.status != "D") {
                let companyData = await fetchAssetDetailsOfIndividualCompanies(company.id)
                result.push(companyData)
            }
        } catch (error) {
          console.log('error at fetchDetailsForEachCompany'+ error);
        }
    }))
    return result
}


exports.fetchAssetDetails = async () => {
    
    let companyDetails = await fetchCompanyDetails()
    let det = await fetchDetailsForEachCompany(companyDetails[0])

    return det
}

Answer 1

To expand on what I meant with not needing those new Promise() s, this would be an idiomatic async function refactoring for the above code.

I eliminated getGraphDataForAssets , since it was eventually not used; fetchAssetDetailsOfIndividualCompanies fetched the same data (based on URL, anyway), and then had getGraphDataForAssets fetch it again.

const request = require("request");

function fetchAPI(apiPath) {
  return new Promise(function (resolve, reject) {
    request(apiPath, function (error, response, body) {
      if (!error && response.statusCode === 200) {
        resolve(body);
      } else {
        reject(error);
      }
    });
  });
}

async function fetchJSON(url) {
  return JSON.parse(await fetchAPI(url));
}

async function fetchCompanyDetails() {
  return [await fetchAPI("https://api//")];
}

function getDateAndPriceForGraphData(graphData) {
  return graphData.map((data) => ({
    x: new Date(data.businessDate).getTime() / 1000,
    y: data.lastTradedPrice,
  }));
}

// fetch data about individual assets
async function fetchAssetDetailsOfIndividualCompanies(assetID) {
  const assetData = await fetchJSON(`https://api/${assetID}`);
  const graphData = getDateAndPriceForGraphData(assetData);
  return { assetID, assetData, graphData };
}

// returns list of details of all tradeable assets (Active and Suspended but not delisted)
async function fetchDetailsForEachCompany(companyList) {
  const promises = companyList.map(async (company) => {
    if (company.status === "D") return null;
    return fetchAssetDetailsOfIndividualCompanies(company.id);
  });
  const results = await Promise.all(promises);
  return results.filter(Boolean); // drop nulls
}

async function fetchAssetDetails() {
  const companyDetails = await fetchCompanyDetails();
  return await fetchDetailsForEachCompany(companyDetails[0]);
}

exports.fetchAssetDetails = fetchAssetDetails;