request promise with cache
npm install request-promise-cacheresolved first argument is no longer {response, body, ?error} but just the body. But, you can pass in resolveWithFullResponse=true to the request({..params}) to get the full response object instead of the body.By default, this module uses the native javascript Promise introduced in Node.js 0.12+, however you can use it with others, by passing your own Promise constructor
``javascript
// if you want to use bluebird for example
// just do this once, somewhere in your app, ideally whatever file loads first, i.e. app.js
var request = require('request-promise-cache').use( require('bluebird').Promise )
// you dont have to do it again in the same app's other files
`
#### Tested with
* bluebird
* when
* q
* and native Promise
if you want me to test another one, just add it and make a pull request to the promiseTypes
`javascript
var request = require('request-promise-cache');
var query = { recordId: 27 };
var queryString = Object.keys(query).sort().map(function (k) { return k + '=' query[k] }).join('&');
var cacheKey = url + '?' + queryString;
var url = 'http://google.com';
request({
url: url,
cacheKey: url,
cacheTTL: 3600,
cacheLimit: 12,
/* bust the cache and get fresh results
qs: query || {
_: +new Date()
},
*/
// like https://github.com/request/request-promise#get-the-full-response-instead-of-just-the-body
resolveWithFullResponse: false,
})
.then(function(body) {
// ...
})
.catch(function(error) {
// ...
});
`
All of the original request library's options, plus the following:
* cacheKey: string, the cache key use, typically, it's just the URL, maybe add the query stringcacheTTL: milliseconds
* , automatically expire a cache entry after Y number of milliseconds, if used with cacheLimit, whichever comes first will take precedencecacheLimit: integer
* , automatically expire a cache entry after X amount of reads, if used with cacheTTL, whichever comes first will take precedencefresh: true/false
* , delete the cached entry and get a fresh oneqs._: 123456789 / anything truthy */
, same as fresh however, this query param will be sent over to the remote server, so it will, most likely, bypass the cache on the other end if there is oneresolveWithFullResponse: true/false
* , copied from request-promise options, defaults to false, basically instead of resolving with the body, it uses the response, which then you need to do response.body to access the body
If you make 2 or more requests with the same cacheKey at the _same_ time, and of course, the response comes back within the cacheTTL of the first request, __only__ 1 request will go out, the rest will wait for it and resolve at the _same_ time.
On the returned request object, you can:
* request.original access the original request function,request.defaults()
* another request object function generator, which is used exactly like the original request.defaults but this one will return a __promisified__ request with the __caching__.request.cache
* is the cache instance using, which is a nano-cache instance, say you need to request.cache.clear()`
MIT