memoize-cache-manager

A configurable cache support for functions (https://www.npmjs.com/package/async-deco). This adapter allows to use cache-manager as its backends

cache

The constructor takes an "options" object. The options object may contain these attributes: cacheManager: a cacheManager instance

• getKey: a function used to extract the cache key (used in the push and query method for storing, retrieving the cached value). Default: a function returning a fixed key (_default). The value won't be cached if the function returns null
• maxAge: it is a function that allows you to use a different TTL for a specific item (in seconds). If it returns 0 it will avoid caching the item. The function takes the same arguments as the "push" method (an array of inputs and the output). If it returns undefined, the default ttl will be used.
• maxValidity: the maximum age of an item stored in the cache before being considered "stale" (in seconds). Default: Infinity. You can also pass a function that will calculate the validity of a specific item. The function will take the same arguments as the "push" method (an array of inputs and the output).
• serialize: it is an optional function that serialize the value stored (takes a value, returns a value). It can be used for pruning part of the object we don't want to save.
• deserialize: it is an optional function that deserialize the value stored (takes a value, returns a value).
• compress: if "true" will serialize/deserialize the values using the "snappy" compression algorithms

Example:

var Cache = require('memoize-cache-manager');
var cacheManager = require('cache-manager'); // npm install cache-manager

// using the id property of the first argument
// this cache will store maximum 100 items
// every item will be considered stale and purged after 20 seconds.
var memoryCache = cacheManager.caching({store: 'memory', max: 100, ttl: 20});

var cache = new Cache({ cacheManager: memoryCache, getKey: function (config){
  return config.id;
} });

Methods

Pushing a new cached value

cache.push(args, output);

"args" is an array containing the arguments passed to the function that generated the output. This function is a "fire and forget" caching request. So there is no need of waiting for an answer, but if you want you can use a callback as third argument. It returns an object or undefined if the value won't be cached (because the TTL is 0 for example, or the resulting cachekey is null). This object contains:

• key: the "cache key" if the value is scheduled to be cached

Querying for cache hit

cache.query(args, function (err, result){
  // result.cached is true when you find a cached value
  // result.hit is the value cached
  // result.timing is the time spent in ms to retrieve the value (also used for cache miss)
  // cached.key is the key used to store the value (might be useful for debugging)
  // cache.stale (true/false) depending on the maxValidity function (if defined)
});

"args" is an array containing the arguments passed to the function that generated the output.

Getting the cache key

var key = cache.getCacheKey(...);

It takes as arguments the same arguments of the function. It returns the cache key. It uses the function passed in the factory function.

The cache object

The cache object is in the "cache" property and it support the API specified here: https://github.com/sithmel/little-ds-toolkit#lru-cache

Purging cache items

cache.purgeByKeys(keys);
// it removes the cache item with a specific key (string) or keys (array of strings).
// You can pass an optional callback.