用于缓存的node.js同步请求

Question

I have an issue I need to resolve in my code that has to do with caching API results. I have some async.map like so:

for(var user of allUsers) {
    var requestList = fill(cache, locations, apiUrl, cacheMap);

    async.map(requestList, function(obj, callback) {
        // ...
    }, function(err, results) {
        // PUT RESULTS INTO A CACHE
    });
}

the function fill simply looks within the cache to see if a location in locations exists, and it not creates a request URL for my API to be run.

I'm realizing however that a cache won't be much use at all with my approach, because my code will dispatch the async.map and immediately start on the next loop iterations fill , meaning the cache won't be synchronized at each iteration of the user.

How would I go about ensuring that each iteration of the user has an updated version of the cache from the last user? I need to make very smart use of my limited API calls, so if there are duplicated requests I want to request once, then pull that result from the cache in later requests.

My only throught right now would be to to a synchronized request instead of an async.map, but I know this goes against the design of node.js.

for(var user of allUsers) {
    var requestList = fill(cache, locations, apiUrl, cacheMap);

    // sync map instead
    requestList.map(function(obj) {
        var res = sync-request(obj)
        // put request result into cache
    });

    // cont...
}

Answer 1

Use Promises to proxy and cache the API calls. Batching API requests and caching the results are extremely simple using Promises. The following little module of code wraps an existing expensiveAPI call in a Promise and caches the resolved result for 60 seconds.

// Existing module to call the expensive API
// using the standard callback pattern
var expensiveApi = require("./expensiveApi");
// Using bluebird promise library
// See http://bluebirdjs.com/docs/api-reference.html
var Promise = require("bluebird");

// Promisify the existing callback
expensiveApi = Promise.promisify(expensiveApi);
// Calls to the API will now return a Promise

// A cache for the Promises
var cache = {};

module.exports = function expensiveApiWithPromises(item) {
  // Check whether a cached Promise already exists
  if (cache[item]) {
    // Return it to the caller
    return cache[item];
  }

  // Promise is not in the cache
  cache[item] = expensiveApi(item)
  .then(function(result) {
    // Promise has resolved
    // set the result to expire
    setTimeout(function() {
      delete cache[item];
    }, 60 * 1000); // 60 seconds expiry
    // Return the result
    return result;
  })
  .catch(function(err) {
    // Promise rejected with an error
    // Reset the cache item
    delete cache[item];
    // Propagate the error
    throw err;
  });

  // Return the newly created cached Promise
  return cache[item];
}

Answer 2

You could just iterate over allUsers using async.eachSeries . This will step through in order and keep it asynchronous.

async.eachSeries(allUsers, (user, done) => {
  const requestList = fill(cache, locations, apiUrl, cacheMap);

  async.map(requestList, (obj, callback) => {
    // ..

    callback(null, requestResult);
  }, (err, results) => {
    // PUT RESULTS INTO A CACHE

    done(null, results);
  });
}, cb);