initial implementation

Author: BryanDonovan

.gitignore

@@ -0,0 +1 @@
+node_module

index.js

@@ -0,0 +1,6 @@
+var cache = {
+    caching: require('./lib/caching'),
+    multi_caching: require('./lib/multi_caching')
+};
+
+module.exports = cache;

lib/caching.js

@@ -0,0 +1,47 @@
+var caching = function(args) {
+    args = args || {};
+    var self = {};
+    self.store_name = args.store || 'redis';
+    self.store = require('./stores/' + self.store_name).create(args);
+
+    /**
+     * Wraps a function in cache. I.e., the first time the function is run,
+     * its results are stored in cache so subsequent calls retrieve from cache
+     * instead of calling the function.
+     *
+     * @example
+     *
+     *   var key = 'user_' + user_id;
+     *   cache.run(key, function(cb) {
+     *       user_adapter.get(user_id, cb);
+     *   }, function(err, user) {
+     *       console.log(user);
+     *   });
+     */
+    self.run = function(key, work, cb) {
+        self.store.get(key, function(err, result) {
+            if (err) { return cb(err); }
+            if (result) {
+                return cb(null, result);
+            }
+
+            work(function() {
+                var work_args = Array.prototype.slice.call(arguments, 0);
+                self.store.set(key, work_args[1], function(err) {
+                    if (err) { return cb(err); }
+                    cb.apply(null, work_args);
+                });
+            });
+        });
+    };
+
+    self.get = self.store.get;
+
+    self.set = self.store.set;
+
+    self.del = self.store.del;
+
+    return self;
+};
+
+module.exports = caching;

lib/multi_caching.js

@@ -0,0 +1,79 @@
+var async = require('async');
+
+/**
+ * Module that lets you specify a hiearchy of caches.
+ */
+var multi_caching = function(caches) {
+    var self = {};
+    if (!Array.isArray(caches)) { throw new Error('multi_caching requires an array of caches'); }
+
+    function get_from_highest_priority_cache(key, cb) {
+        var i = 0;
+        async.forEachSeries(caches, function(cache, async_cb) {
+            cache.store.get(key, function(err, result) {
+                if (err) { return cb(err); }
+                if (result) {
+                    // break out of async loop.
+                    return cb(err, result, i);
+                }
+
+                i += 1;
+                async_cb(err);
+            });
+        }, cb);
+    }
+
+    function set_in_multiple_caches(caches, key, value, cb) {
+        async.forEach(caches, function(cache, async_cb) {
+            cache.store.set(key, value, async_cb);
+        }, cb);
+    };
+
+    /**
+     * Wraps a function in one or more caches.
+     * Has same API as regular caching module.
+     *
+     * If a key doesn't exist in any cache, it gets set in all caches.
+     * If a key exists in a high-priority (e.g., first) cache, it gets returned immediately
+     * without getting set in other lower-priority caches.
+     * If a key doesn't exist in a higher-priority cache but exists in a lower-priority
+     * cache, it gets set in all higher-priority caches.
+     */
+    self.run = function(key, work, cb) {
+        get_from_highest_priority_cache(key, function(err, result, index) {
+            if (err) { return cb(err); }
+            if (result) {
+                var caches_to_set = caches.slice(0, index);
+                set_in_multiple_caches(caches_to_set, key, result, function(err) {
+                    return cb(err, result);
+                });
+            } else {
+                work(function() {
+                    var work_args = Array.prototype.slice.call(arguments, 0);
+
+                    set_in_multiple_caches(caches, key, work_args[1], function(err) {
+                        cb.apply(null, work_args);
+                    });
+                });
+            }
+        });
+    };
+
+    self.set = function(key, value, cb) {
+        set_in_multiple_caches(caches, key, value, cb);
+    };
+
+    self.get = function(key, cb) {
+        get_from_highest_priority_cache(key, cb);
+    };
+
+    self.del = function(key, cb) {
+        async.forEach(caches, function(cache, async_cb) {
+            cache.store.del(key, async_cb);
+        }, cb);
+    };
+
+    return self;
+};
+
+module.exports = multi_caching;

lib/stores/memory.js

@@ -0,0 +1,38 @@
+var Lru = require("lru-cache")
+
+var memory_store = function(args) {
+    args = args || {};
+    var db = args.db || 'cache';
+    var self = {};
+    var ttl = args.ttl;
+    var lru_opts = {
+        max: args.max || 500,
+        maxAge: ttl ? ttl * 1000 : null
+    };
+
+    var lru_cache = new Lru(lru_opts);
+
+    self.set = function(key, value, cb) {
+        lru_cache.set(key, value);
+        cb(null);
+    };
+
+    self.get = function(key, cb) {
+        cb(null, lru_cache.get(key));
+    };
+
+    self.del = function(key, cb) {
+        lru_cache.del(key);
+        cb(null);
+    };
+
+    return self;
+};
+
+var methods = {
+    create: function(args) {
+        return memory_store(args);
+    }
+};
+
+module.exports = methods;

lib/stores/redis.js

@@ -0,0 +1,68 @@
+/*
+var redis_store = function(args) {
+    args = args || {};
+    var db = args.db || 'cache';
+    var self = {};
+    var ttl = args.ttl;
+    var client = djs.backends.redis.client({db: djs.settings.redis.dbs[db]});
+
+    self.set = function(key, value, cb) {
+        var val = JSON.stringify(value);
+        if (ttl) {
+            client.command('setex', {key: key, ttl: ttl, value: val}, cb);
+        } else {
+            client.command('set', {key: key, value: val}, cb);
+        }
+    };
+
+    self.get = function(key, cb) {
+        client.command('get', {key: key}, function(err, result) {
+            if (err) { return cb(err); }
+            if (result === undefined) { return cb(null, null); }
+            return cb(null, JSON.parse(result));
+        });
+    };
+
+    self.del = function(key, cb) {
+        client.command('del', {key: key}, cb);
+    };
+
+    return self;
+};
+*/
+
+function redis_store(args) {
+    args = args || {};
+    var self = {};
+    var ttl = args.ttl;
+    self.client = require('redis').createClient(args.port, args.host, args);
+
+    self.get = function(key, cb) {
+        self.client.get(key, function(err, result) {
+            cb(err, JSON.parse(result));
+        });
+    };
+
+    self.set = function(key, value, cb) {
+        if (ttl) {
+            self.client.setex(key, ttl, JSON.stringify(value), cb);
+        } else {
+            self.client.set(key, JSON.stringify(value), cb);
+        }
+    };
+
+    self.del = function(key, cb) {
+        self.client.del(key, cb);
+    };
+
+    return self;
+}
+
+
+var methods = {
+    create: function(args) {
+        return redis_store(args);
+    }
+};
+
+module.exports = methods;

package.json

@@ -0,0 +1,33 @@
+{
+  "name": "cashew",
+  "version": "0.0.1",
+  "description": "Cache module for Node.JS",
+  "main": "index.js",
+  "scripts": {
+    "test": "mocha"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/BryanDonovan/node-cashew.git"
+  },
+  "keywords": [
+    "cache",
+    "redis",
+    "lru-cache"
+  ],
+  "author": "Bryan Donovan",
+  "license": "BSD",
+  "dependencies": {
+    "async": "0.1.22",
+    "hiredis": "0.1.14",
+    "lru-cache": "2.3.0",
+    "redis": "0.6.7"
+  },
+  "devDependencies": {
+    "Faker" : "0.5.6",
+    "istanbul": "0.1.29",
+    "jshint": "1.0.0",
+    "mocha": "1.8.1",
+    "sinon": "1.5.2"
+  }
+}