0.2.9 • Public • Published


    Cache manager that doesn't suck.

    Make the result of you async functions cacheable, automatically pickle and unpickle the data. Manage all cache keys in one place, use a simple ._clearCache() to purge cache.


    var Redis = require('redis');
    var Cacheable = require('cacheable');
    var client = Redis.createClient();
    var cached = Cacheable({
      client: client,
      ttl: 60, // set a default max age of one minute for `cached.set`
      prefix: 'myapp:' // the prefix for every cache key
    cached.set(key, value, callback)
    cached.set(key, value, 300, callback)
    cached.get(key, callback)
    cached.del(['abc', 'aba'], callback)

    Wraping an async function:

    // Get remote content that expires in 3600 seconds
    var getUrlContent = cached.wrap(function(url, callback) {
        request(url, function() {
          // ...
    }, 'url-{0}', 3600)

    Manage cache for your models:

    function User(data) {
      this.attributes = data
    User.prototype.toJSON = function() {
      return this.attributes
    // get user by id
    User.get = function(user_id, callback) {
      // get the user from data base
      // ...
      var user = new User(data)
      callback(err, user);
    User.prototype.getPostIds = function(start, limit, callback) {
      callback(null, [1,2,3...])
    // register the constructor first
    // enable cache for `User.get` method
    // So when you call `User.get(some_id)`, it will fetch data
    // from cache first, when cache not found, then the original function will be called.
    User.enableCache('get', '{_model_}:{0}') // '{0}' means the `arguments[0]`
    // You can also enable cache for an instance method
    User.enableCache('.getPostIds', '{_model_}:posts-{0}-{1}')


    cached.register(cls, name)

    You have to register all model constructors, so when cache is hit, the cached manager would know how to restore the data as a proper JavaScript Object.

    If your model constructor doesn't have a name, you can give a name as the second parameter, then cached will use this name.

    var Book = function() {
    cached.register(Book, 'Book')

    Your class.prototype must have a .toJSON method, so the cache wrapper could know how to save it to cache. The .toJSON will be extended by cache.register, the output object will always have a property __cachedname, as is the constructor's modelName. You can add a .toObject = .toJSON, and use .toObject whenever you need a clean object.

    If an ._unpickle method is also defined, it will be called each time the object is restored from cache.

    That is:

    var item = new User(json)
    return item

    Note that it would be impossible to unpickle a cache if the constructor's name was changed.

    When registered, the class will have a property ._cacheKeys and an instance would have a method ._clearCache().

    User.prototype.destroy = function(callback) {
      var self = this
      // destroy the item from database
      db.destroy(..., function() {
        // then clear the cache

    cached.wrap(fn, [key], [ttl])

    Wrap an standard nodejs async function(which should have a callback(err, result) as the last parameter). The ttl is in seconds. If no ttl set, the cache will never automatically expire, even it an options.ttl is passed when you do new Cached().

    The parameter key is a pattern for formatting real cache keys.

    The default key is:


    {_fn_} is the name of the function fn. If not found, an error will throw. So you'd better alway name your functions, like this:

    User.get = function get(id) {
      // ...

    {_model_} equals to {}, which is this.modelName || in the scope when the function is called. For a class method, this usually means the name of a constructor.

    Numbers like {0} is indexes of arguments when the function is called. %j{0} mean the first argument value will be converted to json.

    cls.enableCache(methodName, [key], [ttl])

    When a cls is registered, you can use cls.enableCache to enable cache for class/instance methods.

    If methodName starts with a dot (.), it will be considered as an instance method, otherwise, it's a class method.

     * List all ids
     * Options:
     *    `limit`: limit per page
     *    `offset`: offset 
    User.getAllIds = function(options, callback) {
    User.prototype.getPostIds = function(start, limit, callback) {
      // get user's posts
      callback(null, [1,2,3...])
    User.enableCache('getAllIds', 'ids-{0.limit}-{0.offset}')
    User.enableCache('.getPostIds', 'posts-{0}-{1}')
    // You can omit the key, cacheable will automatically use the method name
    User.enableCache('.getPostIds', 3600)
    // KEY: '{_model_}:{id}:getTagsIds', expires in: 3600 seconds

    It is strongly recommended to use this approach to add cache, instead of directly call cached.wrap.


    the MIT licence.


    npm i cacheable

    DownloadsWeekly Downloads






    Last publish


    • ktmud