Merge pull request #33 from dial-once/feature/options-by-url

Add support for using url instead of options for redis.

Author: mrister

README.md

@@ -124,6 +124,20 @@ multiCache.wrap(key2, function (cb) {
 });
 ```
 
+### Using a URL instead of options (if url is correct it overrides options host, port, db, auth_pass and ttl)
+Urls should be in this format `redis://[:password@]host[:port][/db-number][?ttl=value]`
+```js
+var cacheManager = require('cache-manager');
+var redisStore = require('cache-manager-redis');
+
+var redisCache = cacheManager.caching({
+	store: redisStore,
+	url: 'redis://:XXXX@localhost:6379/0?ttl=600'
+});
+
+// proceed with redisCache
+```
+
 Tests
 -----
 

index.js

@@ -2,6 +2,7 @@
 
 var RedisPool = require('sol-redis-pool');
 var EventEmitter = require('events').EventEmitter;
+var redisUrl = require('redis-url');
 
 /**
  * The cache manager Redis Store module
@@ -20,11 +21,11 @@ function redisStore(args) {
 
   // cache-manager should always pass in args
   /* istanbul ignore next */
-  var redisOptions = args || {};
+  var redisOptions = getFromUrl(args) || args || {};
   var poolSettings = redisOptions;
 
-  redisOptions.host = args.host || '127.0.0.1';
-  redisOptions.port = args.port || 6379;
+  redisOptions.host = redisOptions.host || '127.0.0.1';
+  redisOptions.port = redisOptions.port || 6379;
 
   var pool = new RedisPool(redisOptions, poolSettings);
 
@@ -74,7 +75,7 @@ function redisStore(args) {
 
         try {
           // allow undefined only if allowed by isCacheableValue
-          if(! ( (result === undefined || result === "undefined") && typeof args.isCacheableValue === 'function' && args.isCacheableValue(result))) {
+          if(! ( (result === undefined || result === 'undefined') && typeof args.isCacheableValue === 'function' && args.isCacheableValue(result))) {
             result = JSON.parse(result);
           }
         } catch (e) {
@@ -88,6 +89,63 @@ function redisStore(args) {
     };
   }
 
+  /**
+   * Extracts options from an args.url
+   * @param {Object} args
+   * @param {String} args.url a string in format of redis://[:password@]host[:port][/db-number][?option=value]
+   * @returns {Object} the input object args if it is falsy, does not contain url or url is not string, otherwise a new object with own properties of args
+   * but with host, port, db, ttl and auth_pass properties overridden by those provided in args.url.
+   */
+  function getFromUrl(args) {
+    if (!args || typeof args.url !== 'string') {
+      return args;
+    }
+
+    try {
+      var options = redisUrl.parse(args.url);
+      // make a clone so we don't change input args
+      return applyOptionsToArgs(args, options);
+    } catch (e) {
+      //url is unparsable so returning original
+      return args;
+    }
+
+  }
+
+  /**
+   * Clones args'es own properties to a new object and sets isCacheableValue on the new object
+   * @param  {Object} args
+   * @returns {Object} a clone of the args object
+   */
+  function cloneArgs(args) {
+    var newArgs = {};
+    for(var key in args){
+      if (key && args.hasOwnProperty(key)) {
+        newArgs[key] = args[key];
+      }
+    }
+    newArgs.isCacheableValue = args.isCacheableValue && args.isCacheableValue.bind(newArgs);
+    return newArgs;
+  }
+
+  /**
+   * Apply some options like hostname , port, db, ttl auth_pass from options to newArgs host, port, db, auth_pass and ttl and return clone of args
+   * @param {Object} args
+   * @param {Object} options
+   * @returns {Object} clone of args param with properties set to those of options
+   */
+  function applyOptionsToArgs(args, options) {
+    var newArgs = cloneArgs(args);
+    newArgs.host = options.hostname;
+    newArgs.port = parseInt(options.port, 10);
+    newArgs.db = parseInt(options.database, 10);
+    newArgs.auth_pass = options.password;
+    if(options.query && options.query.ttl){
+      newArgs.ttl = parseInt(options.query.ttl, 10);
+    }
+    return newArgs;
+  }
+
   /**
    * Get a value for a given key.
    * @method get

package.json

@@ -23,6 +23,7 @@
   "license": "MIT",
   "dependencies": {
     "cache-manager": "^1.2.2",
+    "redis-url": "^1.2.1",
     "sol-redis-pool": "^0.2.1"
   },
   "devDependencies": {

spec/lib/redis-store-spec.js

@@ -346,6 +346,44 @@ describe('redisErrorEvent', function () {
   });
 });
 
+describe('uses url to override redis options', function () {
+  var redisCacheByUrl;
+
+  beforeAll(function () {
+    redisCacheByUrl = require('cache-manager').caching({
+      store: redisStore,
+      // redis://[:password@]host[:port][/db-number][?option=value]
+      url: 'redis://:' + config.redis.auth_pass +'@' + config.redis.host + ':' + config.redis.port + '/' + config.redis.db +'?ttl=' + config.redis.ttl,
+      // some fakes to see that url overrides them
+      host: 'test-host',
+      port: -78,
+      db: -7,
+      auth_pass: 'test_pass',
+      ttl: -6
+    });
+  });
+
+  it('should ignore other options if set in url', function() {
+    expect(redisCacheByUrl.store._pool._redis_host).toBe(config.redis.host);
+    expect(redisCacheByUrl.store._pool._redis_port).toBe(config.redis.port);
+    expect(redisCacheByUrl.store._pool._redis_default_db).toBe(config.redis.db);
+    expect(redisCacheByUrl.store._pool._redis_options.auth_pass).toBe(config.redis.auth_pass);
+  });
+
+  it('should get and set values without error', function (done) {
+    var key = 'byUrlKey';
+    var value = 'test';
+    redisCacheByUrl.set(key, value, function (err) {
+      expect(err).toBe(null);
+      redisCacheByUrl.get(key, function(getErr, val){
+        expect(getErr).toBe(null);
+        expect(val).toEqual(value);
+        done();
+      });
+    });
+  });
+});
+
 describe('overridable isCacheableValue function', function () {
   var redisCache2;