A fork from cacheable-request with refined interface to expose internal members, such as Cache, cachePolicy, and allow being passed in.
Wrap native HTTP requests with RFC compliant cache support
RFC 7234 compliant HTTP caching for native Node.js HTTP/HTTPS requests. Caching works out of the box in memory or is easily pluggable with a wide range of storage adapters.
Note: This is a low level wrapper around the core HTTP modules, it's not a high level request library.
- Only stores cacheable responses as defined by RFC 7234
- Fresh cache entries are served directly from cache
- Stale cache entries are revalidated with
- 304 responses from revalidation requests use cached body
Ageheader on cached responses
- Can completely bypass cache on a per request basis
- In memory cache by default
- Official support for Redis, MongoDB, SQLite, PostgreSQL and MySQL storage adapters
- Easily plug in your own or third-party storage adapters
- If DB connection fails, cache is automatically bypassed (disabled by default)
- Adds cache support to any existing HTTP code with minimal changes
- Uses http-cache-semantics internally for HTTP RFC 7234 compliance
npm install --save cacheable-request-adaptable
const http = ;const CacheableRequest = ;// Then instead ofconst req = http;req;// You can doconst options =cacheAdapter // keyv storage adpatorpolicyConstructor // CachePolicy constructornamespace // string, for keyvconst cacheableRequest = httprequest options;// its members such as store, CachePolicy, namespace can be adjusted here.const request = cacheableRequest;const cacheReq = ;cacheReq;// Future requests to 'example.com' will be returned from cache if still validcacheReq;// You pass in any other http.request API compatible method to be wrapped with cache support:const cacheableRequest = httpsrequest;const cacheableRequest = electronnet;
cacheable-request-adaptable uses Keyv to support a wide range of storage adapters.
For example, to use Redis as a cache backend, you just need to install the official Redis Keyv storage adapter:
npm install --save @keyv/redis
And then you can pass
CacheableRequest your connection string:
const cacheableRequest = httprequest cacheAdapter: 'redis://user:pass@localhost:6379' ;
Keyv also supports anything that follows the Map API so it's easy to write your own storage adapter or use a third-party solution.
e.g The following are all valid storage adapters
const storageAdapter = ;// orconst storageAdapter = ;// orconst QuickLRU = ;const storageAdapter = maxSize: 1000 ;const cacheableRequest = httprequest cacheAdapter: storageAdapter ;
View the Keyv docs for more information on how to use storage adapters.
new cacheableRequest(request, [storageAdapter])
Returns the provided request function wrapped with cache support.
Request function to wrap with cache support. Should be
http.request or a similar API compatible request function.
Keyv storage adapter
A Keyv storage adapter instance, or connection string if using with an official Keyv storage adapter.
Returns an event emitter.
Any of the default request functions options plus:
If the cache should be used. Setting this to false will completely bypass the cache for the current request.
If set to
false, after a cached resource's TTL expires it is kept in the cache and will be revalidated on the next request with
If set to
true once a cached resource has expired it is deleted and will have to be re-requested.
When set to
true, if the DB connection fails we will automatically fallback to a network request. DB errors will still be emitted to notify you of the problem even though the request callback may succeed.
The callback function which will receive the response as an argument.
request event to get the request object of the request.
Note: This event will only fire if an HTTP request is actually made, not when a response is retrieved from cache. However, you should always handle the
request event to end the request and handle any potential request errors.
response event to get the response object from the HTTP request or cache.
error event emitted in case of an error with the cache.
Errors emitted here will be an instance of
CacheableRequest.CacheError. You will only ever receive a
RequestError if the request function throws (normally caused by invalid user input). Normal request errors should be handled inside the
To properly handle all error scenarios you should use the following pattern:
Note: Database connection errors are emitted here, however
cacheable-request-adaptable will attempt to re-request the resource and bypass the cache on a connection error. Therefore a database connection error doesn't necessarily mean the request won't be fulfilled.
MIT © Luke Childs