Merge branch 'release/0.5.0'

Author: Julien Kernec'h

README.md

@@ -75,6 +75,41 @@ redisCache.wrap(key, function (cb) {
         console.log(user);
     });
 });
+
+// The del() method accepts a single key or array of keys,
+// with or without a callback.
+redisCache.set('foo', 'bar', function () {
+    redisCache.set('bar', 'baz', function() {
+        redisCache.set('baz', 'foo', function() {
+          redisCache.del('foo');
+          redisCache.del(['bar', 'baz'], function() { });
+        });
+    });
+});
+
+// The keys() method uses the Redis SCAN command and accepts
+// optional `pattern` and `options` arguments. The `pattern`
+// must be a Redis glob-style string and defaults to '*'. The
+// options argument must be an object and accepts a single
+// `scanCount` property, which determines the number of elements
+// returned internally per call to SCAN. The default `scanCount`
+// is 100.
+redisCache.set('foo', 'bar', function () {
+    redisCache.set('far', 'boo', function () {
+        redisCache.keys('fo*', function (err, arrayOfKeys) {
+            // arrayOfKeys: ['foo']
+        });
+        
+        redisCache.keys(function (err, arrayOfKeys) {
+            // arrayOfKeys: ['foo', 'far']
+        });
+        
+        redisCache.keys('fa*', { scanCount: 10 }, function (err, arrayOfKeys) {
+            // arrayOfKeys: ['far']
+        });
+    });
+});
+
 ```
 
 ### Multi-store

index.js

@@ -186,7 +186,7 @@ function redisStore(args) {
       options = options || {};
       options.parse = true;
 
-      cb = cb ? cb : (err, result) => err ? reject(err) : resolve(result)
+      cb = cb ? cb : (err, result) => err ? reject(err) : resolve(result);
 
       var compress = (options.compress || options.compress === false) ? options.compress : redisOptions.compress;
       if (compress) {
@@ -222,7 +222,7 @@ function redisStore(args) {
         options = {};
       }
 
-      cb = cb ? cb : (err, result) => err ? reject(err) : resolve(result)
+      cb = cb ? cb : (err, result) => err ? reject(err) : resolve(result);
 
       if (!self.isCacheableValue(value)) {
         return cb(new Error('value cannot be ' + value));
@@ -267,7 +267,7 @@ function redisStore(args) {
   /**
    * Delete value of a given key
    * @method del
-   * @param {String} key - The cache key
+   * @param {String|Array} key - The cache key or array of keys to delete
    * @param {Object} [options] - The options (optional)
    * @param {Function} [cb] - A callback that returns a potential error, otherwise null
    */
@@ -281,7 +281,17 @@ function redisStore(args) {
       if (err) {
         return cb && cb(err);
       }
-      conn.del(key, handleResponse(conn, cb));
+
+      if (Array.isArray(key)) {
+        var multi = conn.multi();
+        for (var i = 0, l = key.length; i < l; ++i) {
+          multi.del(key[i]);
+        }
+        multi.exec(handleResponse(conn, cb));
+      }
+      else {
+        conn.del(key, handleResponse(conn, cb));
+      }
     });
   };
 
@@ -315,22 +325,63 @@ function redisStore(args) {
   };
 
   /**
-   * Returns all keys matching pattern.
+   * Returns all keys matching pattern using the SCAN command.
    * @method keys
-   * @param {String} pattern - The pattern used to match keys
+   * @param {String} [pattern] - The pattern used to match keys (default: *)
+   * @param {Object} [options] - The options (default: {})
+   * @param {number} [options.scanCount] - The number of keys to traverse with each call to SCAN (default: 100)
    * @param {Function} cb - A callback that returns a potential error and the response
    */
-  self.keys = function(pattern, cb) {
+  self.keys = function(pattern, options, cb) {
+
+    // Account for all argument permutations.
+    // Only cb supplied.
     if (typeof pattern === 'function') {
       cb = pattern;
+      options = {};
       pattern = '*';
     }
+    // options and cb supplied.
+    else if (typeof pattern === 'object') {
+      cb = options;
+      options = pattern;
+      pattern = '*';
+    }
+    // pattern and cb supplied.
+    else if (typeof options === 'function') {
+      cb = options;
+      options = {};
+    }
 
     connect(function(err, conn) {
       if (err) {
         return cb && cb(err);
       }
-      conn.keys(pattern, handleResponse(conn, cb));
+
+      // Use an object to dedupe as scan can return duplicates
+      var keysObj = {};
+      var scanCount = Number(options.scanCount) || 100;
+
+      (function nextBatch(cursorId) {
+        conn.scan(cursorId, 'match', pattern, 'count', scanCount, function (err, result) {
+          if (err) {
+            handleResponse(conn, cb)(err);
+          }
+
+          var nextCursorId = result[0];
+          var keys = result[1];
+
+          for (var i = 0, l = keys.length; i < l; ++i) {
+            keysObj[keys[i]] = 1;
+          }
+
+          if (nextCursorId !== '0') {
+            return nextBatch(nextCursorId);
+          }
+
+          handleResponse(conn, cb)(null, Object.keys(keysObj));
+        });
+      })(0);
     });
   };
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "cache-manager-redis",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Redis store for the node-cache-manager",
   "main": "index.js",
   "scripts": {

test/lib/redis-store-spec.js

@@ -35,6 +35,12 @@ before(function () {
   });
 });
 
+beforeEach(function(done) {
+  redisCache.reset(function() {
+    done();
+  });
+});
+
 describe ('initialization', function () {
 
   it('should create a store with password instead of auth_pass (auth_pass is deprecated for redis > 2.5)', function (done) {
@@ -257,6 +263,30 @@ describe('del', function () {
     });
   });
 
+  it('should delete multiple values for a given array of keys', function (done) {
+    redisCache.set('foo', 'bar', function () {
+      redisCache.set('bar', 'baz', function () {
+        redisCache.set('baz', 'foo', function () {
+          redisCache.del(['foo', 'bar', 'baz'], function (err) {
+            assert.equal(err, null);
+            done();
+          });
+        });
+      });
+    });
+  });
+
+  it('should delete multiple values for a given array of keys without callback', function (done) {
+    redisCache.set('foo', 'bar', function () {
+      redisCache.set('bar', 'baz', function () {
+        redisCache.set('baz', 'foo', function () {
+          redisCache.del(['foo', 'bar', 'baz']);
+          done();
+        });
+      });
+    });
+  });
+
   it('should return an error if there is an error acquiring a connection', function (done) {
     var pool = redisCache.store._pool;
     sinon.stub(pool, 'acquireDb').yieldsAsync('Something unexpected');
@@ -335,22 +365,64 @@ describe('ttl', function () {
 describe('keys', function () {
   it('should return an array of keys for the given pattern', function (done) {
     redisCache.set('foo', 'bar', function () {
-      redisCache.keys('f*', function (err, arrayOfKeys) {
-        assert.equal(err, null);
-        assert.notEqual(arrayOfKeys, null);
-        assert.notEqual(arrayOfKeys.indexOf('foo'), -1);
-        done();
+      redisCache.set('far', 'boo', function () {
+        redisCache.set('faz', 'bam', function () {
+          redisCache.keys('f*', function (err, arrayOfKeys) {
+            assert.equal(err, null);
+            assert.notEqual(arrayOfKeys, null);
+            assert.notEqual(arrayOfKeys.indexOf('foo'), -1);
+            assert.equal(arrayOfKeys.length, 3);
+            done();
+          });
+        });
+      });
+    });
+  });
+
+  it('should accept a scanCount option', function (done) {
+    redisCache.set('foo', 'bar', function () {
+      redisCache.set('far', 'boo', function () {
+        redisCache.set('faz', 'bam', function () {
+          redisCache.keys('f*', { scanCount: 10 }, function (err, arrayOfKeys) {
+            assert.equal(err, null);
+            assert.notEqual(arrayOfKeys, null);
+            assert.notEqual(arrayOfKeys.indexOf('foo'), -1);
+            assert.equal(arrayOfKeys.length, 3);
+            done();
+          });
+        });
       });
     });
   });
 
   it('should return an array of keys without pattern', function (done) {
     redisCache.set('foo', 'bar', function () {
-      redisCache.keys(function (err, arrayOfKeys) {
-        assert.equal(err, null);
-        assert.notEqual(arrayOfKeys, null);
-        assert.notEqual(arrayOfKeys.indexOf('foo'), -1);
-        done();
+      redisCache.set('far', 'boo', function () {
+        redisCache.set('faz', 'bam', function () {
+          redisCache.keys(function (err, arrayOfKeys) {
+            assert.equal(err, null);
+            assert.notEqual(arrayOfKeys, null);
+            assert.notEqual(arrayOfKeys.indexOf('foo'), -1);
+            assert.equal(arrayOfKeys.length, 3);
+            done();
+          });
+        });
+      });
+    });
+  });
+
+  it('should accept scanCount option without pattern', function (done) {
+    redisCache.set('foo', 'bar', function () {
+      redisCache.set('far', 'boo', function () {
+        redisCache.set('faz', 'bam', function () {
+          redisCache.keys({ scanCount: 10 }, function (err, arrayOfKeys) {
+            assert.equal(err, null);
+            assert.notEqual(arrayOfKeys, null);
+            assert.notEqual(arrayOfKeys.indexOf('foo'), -1);
+            assert.equal(arrayOfKeys.length, 3);
+            done();
+          });
+        });
       });
     });
   });

test/lib/redis-store-zlib-spec.js

@@ -42,6 +42,12 @@ describe('Compression Tests', function () {
     testJson = JSON.stringify(testObject);
   });
 
+  beforeEach(function(done) {
+    redisCompressCache.reset(function () {
+      done();
+    });
+  });
+
   describe('compress set', function () {
     it('should store a value without ttl', function (done) {
       redisCompressCache.set('foo', 'bar', function (err) {