Redis Cache for Sequelize

This helps in caching sequelize objects in redis based on 3 strategies and not queries. There are methods like #search , #setCache and #expire for handling your caches based on id, action for setting caches and searching based on id, action, all and expiry based on id, action and all. These caches are in context of some object and are not global. For example:

• A cache for the api response /users/connections for User with id 1 will be different than that of the User with id 2.

Initialization and configuration

• It is basically namespaced globally and you can do that by providing options.namespace while initializing the cacheStore :

  var initCacheStore = require("redis-cache-sequelize");
  var cacheStore = initCacheStore(redisClient, {namespace: 'VADER'});

• We are using sequelize models for using this as of now.

    var redisClient = redis.createClient(redisPort, redisHost);
    db = new Sequelize(opts.database, opts.username, opts.password, opts);
    cacheStore = initCacheStore(redisClient, {namespace: 'VADER'});

    User = db.define('User', {
      id: {
        allowNull: false,
        autoIncrement: true,
        primaryKey: true,
        type: Sequelize.INTEGER
      },
      name: {
        type: Sequelize.STRING(255)
      }
    }, {
      instanceMethods: {
        toApi: function() {
          return {
            name: this.name
          }
        }
      }
    });

    User.sync({force: true})
      .then(function() {
        return done();
      })
      .catch(onErr);
    /**
    * enabled - decides if this cacheStore will enable caching or not. 
    * ttl - Time to live for the redis objects. After that the entire cacheStore expires.
    */
    var userCache = cacheStore(User, {ttl: 500, enabled: true});

Setting Cache:

#setCache returns a promise that resolves by successfully setting the cache and returns the result.

#setCache with id only - {id: <id>}

You can set cache which always needs an id and / or with action. Pattern is restricted while setting cache for obvious reasons.

Global Namespace : javascript VADER Model: javascript User id: javascript 1

The key will be formed as javascript VADER::User::1

• Usage

  userCache.setCache(_data, {id: 1})
    .then(_data => // Use the data)
    .catch(_err => // Handle Error)

setCache with id and action

Global Namespace: javascript VADER Model: javascript User id: javascript 1 Action: javascript "connections"

The key will be formed as javascript VADER::USER::CONNECTIONS::1

• Usage

  userCache.setCache(_data, {action: 'connections', id: 1})
    .then(_data => // Use the data)
    .catch(_err => // Handle Error)

Searching in Cache

#search provides multiple ways to search the cached objects:

• {id: <id>}
• {id: <id>, action: <action>}
• {id: <id>, all: true}

#search with just id - { id: <id> } :

This basically searches based on the id of the object, a global namespace is present which is set while initializing the cache and apart from that the model name is used as the secondary namespace. For example :

Global Namespace : javascript VADER Model: javascript User id: javascript 1

The key will be formed as javascript VADER::User::1

• Usage

  userCache.search({id: 1})
    .then(_data => // Use the data)
    .catch(_err => // Handle Error)

#search with id and action - { id: <id>, action: <action> } :

This basically searches based on actions or however you set the keys.

Global Namespace: javascript VADER Model: javascript User Action: javascript ALL id: javascript 1

The key will be formed as javascript VADER::USER::ALL::1

• Usage

  userCache.search({action: 'ALL', id: 1})
    .then(_data => // Use the data)
    .catch(_err => // Handle Error)

#search for all cached objects for that id - { id: <id>, all: <boolean> } :

This searches for all the cached objects for the mentioned id with a key pattern.

Global Namespace: javascript VADER Model: javascript User id: javascript 1

The key will be formed as javascript VADER::User*1

• Usage

  userCache.search({id: 1, all: true })
    .then(_data => // Use the data)
    .catch(_err => // Handle Error)

Expiring Cache :

#expire provides multiple ways to search the cached objects:

• {id: <id>}
• {id: <id>, action: <action>}
• {id: <id>, all: true}
• {expire_all: true}

#expire with just id - { id: <id> } :

This expires a particular cache object for that id.

Global Namespace : javascript VADER Model: javascript User id: javascript 1

The key will be formed as javascript VADER::User::1

• Usage

  userCache.expire({id: 1})
    .then(_data => // Use the data)
    .catch(_err => // Handle Error)

#expire with id and action - { id: <id>, action: <action> } :

This basically expires based on actions or however you set the keys.

Global Namespace: javascript VADER Model: javascript User Action: javascript ALL id: javascript 1

The key will be formed as javascript VADER::USER::ALL::1

• Usage

  userCache.expire({action: 'ALL', id: 1})
    .then(_data => // Use the data)
    .catch(_err => // Handle Error)

#expire for all cached objects for that id - { id: <id>, all: <boolean> } :

This expires all the cached objects for the mentioned id with a key pattern.

Global Namespace: javascript VADER Model: javascript User id: javascript 1

The key will be formed as javascript VADER::User*1

• Usage

  userCache.expire({id: 1, all: true })
    .then(_data => // Use the data)
    .catch(_err => // Handle Error)

#expire for all cached objects available - { expire_all: <boolean> } :

This expires all the cached objects for the model with a key pattern.

Global Namespace: javascript VADER Model: javascript User

The key will be formed as javascript VADER::User*

• Usage

  userCache.expire({expire_all: true })
    .then(_data => // Use the data)
    .catch(_err => // Handle Error)

Searching with legacy functions:

• These are deprecated, will be removed in future releases. Please use #search instead.

searchOne

This basically searches based on the id of the object, a global namespace is present which is set while initializing the cache and apart from that the model name is used as the secondary namespace. For example :

Global Namespace : javascript VADER Model: javascript User id: javascript 1

The key will be formed as javascript VADER::User::1

• Usage

userCache.searchOne({id: 1})
    .then(function(result) {  
      /** */
    })

searchScoped

This basically searches based on actions / methods or however you set the keys. It's agostic of that at the moment intentionally.

Global Namespace: javascript VADER Model: javascript User Scope/Method/Action: javascript ALL id: javascript 1

The key will be formed as javascript VADER::USER::ALL::1

• Usage

userCache.searchScoped({action: 'ALL', id: 1})
    .then(function(result) {  
      /** */
    })

searchPattern

This searches all keys based on the pattern provided

Global Namespace: javascript VADER Model: javascript User id: javascript 1 Pattern: javascript "*"

The key will be formed as javascript VADER::USER::1::*

• Usage

userCache.searchPattern({action: '*', id: 1})
    .then(function(result) {  
      /** */
    })

Cache Expiry

expireOne

This expires a particular value based on the key generated from what you pass in options.

Global Namespace : javascript VADER Model: javascript User id: javascript 1

The key will be formed as javascript VADER::User::1

• Usage

userCache.expireOne({id: 1})
    .then(function(result) {  
      /** */
    })