IORedis store for node cache manager

Redis cache store for node-cache-manager.

This package is a almost identical to node-cache-manager-redis-store, but uses ioredis instead of node_redis. It aims to provide the most simple wrapper possible by just passing the configuration to the underlying ioredis package.

Installation

1npm install cache-manager-ioredis --save

or

1yarn add cache-manager-ioredis

Usage Examples

See examples below on how to implement the IORedis cache store.

Single store

1var cacheManager = require('cache-manager');
2var redisStore = require('cache-manager-ioredis');
3
4var redisCache = cacheManager.caching({
5  store: redisStore,
6  host: 'localhost', // default value
7  port: 6379, // default value
8  password: 'XXXXX',
9  db: 0,
10  ttl: 600
11});
12
13// listen for redis connection error event
14var redisClient = redisCache.store.getClient();
15
16redisClient.on('error', (error) => {
17  // handle error here
18  console.log(error);
19});
20
21var ttl = 5;
22
23redisCache.set('foo', 'bar', { ttl: ttl }, (err) => {
24  if (err) {
25    throw err;
26  }
27
28  redisCache.get('foo', (err, result) => {
29    console.log(result);
30    // >> 'bar'
31    redisCache.del('foo', (err) => {
32    });
33  });
34});
35
36function getUser(id, cb) {
37  setTimeout(() => {
38    console.log("Returning user from slow database.");
39    cb(null, { id: id, name: 'Bob' });
40  }, 100);
41}
42
43var userId = 123;
44var key = `user_${userId}`;
45
46// Note: ttl is optional in wrap()
47redisCache.wrap(key, (cb) => {
48  getUser(userId, cb);
49}, { ttl: ttl }, (err, user) => {
50  console.log(user);
51
52  // Second time fetches user from redisCache
53  redisCache
54    .wrap(key, () => getUser(userId))
55    .then(console.log)
56    .catch(err => {
57      // handle error
58    });
59});

Multi-store

1var cacheManager = require('cache-manager');
2var redisStore = require('cache-manager-ioredis');
3
4var redisCache = cacheManager.caching({ store: redisStore, db: 0, ttl: 600 });
5var memoryCache = cacheManager.caching({ store: 'memory', max: 100, ttl: 60 });
6
7var multiCache = cacheManager.multiCaching([memoryCache, redisCache]);
8
9var userId2 = 456;
10var key2 = `user_${userId2}`;
11
12// Set value in all caches
13multiCache.set('foo2', 'bar2', { ttl: ttl }, (err) => {
14  if (err) {
15    throw err;
16  }
17
18  // Fetches from highest priority cache that has the key
19  multiCache.get('foo2', (err, result) => {
20    console.log(result);
21
22    // Delete from all caches
23    multiCache.del('foo2');
24  });
25});
26
27// Note: ttl is optional in wrap
28multiCache.wrap(key2, (cb) => {
29  getUser(userId2, cb);
30}, (err, user) => {
31  console.log(user);
32
33  // Second time fetches user from memoryCache, since it's highest priority.
34  // If the data expires in the memory cache, the next fetch would pull it from
35  // the 'someOtherCache', and set the data in memory again.
36  multiCache.wrap(key2, (cb) => {
37    getUser(userId2, cb);
38  }, (err, user) => {
39    console.log(user);
40  });
41});

Use Clustering (eg Amazon elasticache)

1var cacheManager = require('cache-manager');
2var redisStore = require('cache-manager-ioredis');
3
4// https://github.com/luin/ioredis#cluster
5var redisCache = cacheManager.caching({
6  store: redisStore,
7  clusterConfig: {
8    nodes: [
9      {
10        port: 6380,
11        host: '127.0.0.1'
12      }, 
13      {
14        port: 6381,
15        host: '127.0.0.1'
16      }
17    ],
18    options: {
19      maxRedirections: 16
20    }
21  }
22});

Use an external Redis Instance

1var cacheManager = require('cache-manager');
2var redisStore = require('cache-manager-ioredis');
3var Redis = require('ioredis');
4
5var redisInstance = new Redis({
6  host: 'localhost',
7  port: 6379,
8  db: 0,
9});
10
11var redisCache = cacheManager.caching({
12  store: redisStore,
13  redisInstance: redisInstance
14});

Contribution

Want to help improve this package? We take pull requests.

License

The node-cache-manager-ioredis is licensed under the MIT license.