Provides caching and throttling of promises.
JavaScript
Switch branches/tags
Nothing to show
Clone or download
Fetching latest commit…
Cannot retrieve the latest commit at this time.
Permalink
Failed to load latest commit information.
lib
test
.gitignore
README.md
circle.yml
index.js
package.json

README.md

Circle CI

promise-cache-throttle

Provides caching and throttling of promises.

  • Promise.cachify(func, options) - Returns the function wrapped with caching
  • Promise.cachifyAll(target, options) - Patches all the target's methods with caching
  • Promise.throttlify(func, options) - Returns the function wrapped with throttling
  • Promise.throttlifyAll(target, options) - Patches all the target's methods with throttling

These have similar definitions to bluebird's promisify:

You can also use the underlying functions directly:

  • throttler.throttleAsync(func) - Limits the number of concurrent calls. Any additional calls will wait.
  • lockableCache.callAsync(key, func) - Ensures a function isn't called concurrently. Any subsequent calls with same key before the first has resolved will wait and receive the same response.

Examples

npm install promise-cache-throttle
var Promise = require('bluebird');
require('promise-cache-throttle')(Promise);
var superagent = require('superagent');
var agent = require('superagent-promise')(superagent, Promise);

var API = {
    getUsersAsync: function() { 
        return agent.get('/users/').end();
    },
    getDriversAsync: function() {
        return agent.get('/drivers/').end();
    },
    getDriverAsync: function(driverId) {
        return agent.get('/drivers/' + driverId).end();
    }
};

Promise.throttlifyAll(API, /* optional */ {
    concurrency: 1,
    queueLimit: 100,
    suffix: 'Throttled', // or leave empty to override methods
    filter: function(name, func, target, passesDefaultFilter) { // optional filter
        return _.includes(['getUsersAsync', 'getDriverAsync'], name);
    },
    resolvers: {
        "getDriverAsync": [String]
    }
});
Promise.cachifyAll(API, /* optional */ {
    suffix: 'Cached', // or leave empty to override methods,
    filter: function(name, func, target, passesDefaultFilter) { // optional filter
        return _.includes(['getUsersAsync', 'getDriversAsync'], name);
    }
});
// NOTE: throttling should be applied before caching

Or for single functions:

var getDriversAsyncThrottled = Promise.throttlify(API.getDriversAsync, /* optional */ {context: API});
var getDriverAsyncCached = Promise.cachify(API.getDriverAsync, /* optional */  {
    context: API,
    resolvers: [(ob) => { return obj.id; }, String, Number, Boolean]
});

To apply throttlify with the same throttler:

var throttler = new Promise.throttlify.Throttler(/* optional */ {
    concurrency: 1,
    queueLimit: 100
});
var getDriversAsyncThrottled = Promise.throttlify(API.getDriversAsync, {
    context: API,
    throttler: throttler
});
var getUsersAsyncThrottled = Promise.throttlify(API.getUsersAsync, {
    context: API,
    throttler: throttler
});
Promise.throttlifyAll(API, /* optional */ {
    throttler: throttler,
    filter: function(name, func, target, passesDefaultFilter) { // optional filter
        return name === 'getDriverAsync';
    }
});

Or use LockableCache and Throttler directly:

var throttler = new Promise.throttlify.Throttler(/* optional */ {
    concurrency: 1,
    queueLimit: 100
});
var lockableCache = new Promise.cachify.LockableCache();

lockableCache.callAsync('users', function() {
    return throttler.throttleAsync(function() {
        return agent.get('/users/').end();
    });
});