tomdale · habdelra · Aug 28, 2016 · Feb 2, 2017 · Feb 2, 2017 · Feb 3, 2017
diff --git a/index.js b/index.js
@@ -3,6 +3,7 @@
 const redis = require('redis');
 
 const FIVE_MINUTES = 5 * 60;
+const ONE_HOUR = 12 * FIVE_MINUTES;
 
 class RedisCache {
   constructor(options) {
@@ -52,27 +53,55 @@ class RedisCache {
 
     let request = response && response.req;
     let key = this.cacheKey(path, request);
+    let documentIdMatch = /\/([\d]+)/.exec(path);
+    let documentId = documentIdMatch && documentIdMatch.length ? documentIdMatch[1] : null;
 
     return new Promise((res, rej) => {
       let statusCode = response && response.statusCode;
       let statusCodeStr = statusCode && (statusCode + '');
+      let keyIndex = `key_index_${documentId || path}`;
 
       if (statusCodeStr && statusCodeStr.length &&
          (statusCodeStr.charAt(0) === '4' || statusCodeStr.charAt(0) === '5')) {
         res();
         return;
       }
 
-      this.client.multi()
-        .set(key, body)
-        .expire(path, this.expiration)
-        .exec(err => {
-          if (err) {
-            rej(err);
+      this.client.get(keyIndex, (err, reply) => {
+        if (err) {
+          rej(err);
+        } else {
+          let keys;
+          if (!reply) {
+            keys = [];
           } else {
-            res();
+            try {
+              keys = JSON.parse(reply);
+            } catch (e) {
+              console.error(`can't parse key index for ${keyIndex}: ${reply}`);
+              keys = [ reply ];
+            }
           }
-        });
+
+          keys.push(key);
+
+          console.log(`Creating cache key ${key}`);
+          console.log(`Setting cache key-index ${keyIndex}: ${JSON.stringify(keys)}`);
+
+          this.client.multi()
+            .set(key, body)
+            .set(keyIndex, JSON.stringify(keys))
+            .expire(key, this.expiration)
+            .expire(keyIndex, ONE_HOUR)
+            .exec(err => {
+              if (err) {
+                rej(err);
+              } else {
+                res();
+              }
+            });
+        }
+      });
     });
   }
 }

diff --git a/package.json b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "fastboot-redis-cache",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "A FastBoot App Server cache for Redis",
   "main": "index.js",
   "scripts": {

diff --git a/test/caching-test.js b/test/caching-test.js
@@ -66,7 +66,7 @@ describe('caching tests', function() {
     beforeEach(function() {
       cache = new RedisCache({
         cacheKey (path, request) {
-          return `${path}_${request && request.cookies && request.cookies.chocolateChip}`;
+          return `${request.hostname}${path}_${request && request.cookies && request.cookies.chocolateChip}`;
         }
       });
       cache.client = mockRedisClient();
@@ -78,22 +78,100 @@ describe('caching tests', function() {
       let body = '<body>Hola</body>';
       let mockResponse = {
         req: {
+          hostname: 'foo.com',
           cookies: {
             chocolateChip: 'mmmmmm'
           }
         }
       };
 
       return cache.put('/', body, mockResponse).then(() => {
-        expect(mockRedis['/_mmmmmm']).to.equal(body);
+        expect(mockRedis['foo.com/_mmmmmm']).to.equal(body);
+        expect(mockRedis['key_index_/']).to.equal(JSON.stringify(['foo.com/_mmmmmm']));
+      });
+    });
+
+    it('can represent mulitple cache keys from different domains with the same path', function() {
+      let body = '<body>Hola</body>';
+      let body2 = '<body>Bonjour</body>';
+      let mockResponse = {
+        req: {
+          hostname: 'foo.com',
+          cookies: {
+            chocolateChip: 'mmmmmm'
+          }
+        }
+      };
+      let mockResponse2 = {
+        req: {
+          hostname: 'bar.com',
+          cookies: {
+            chocolateChip: 'mmmmmm'
+          }
+        }
+      };
+
+      return cache.put('/', body, mockResponse)
+      .then(() => {
+        expect(mockRedis['foo.com/_mmmmmm']).to.equal(body);
+        expect(mockRedis['key_index_/']).to.equal(JSON.stringify(['foo.com/_mmmmmm']));
+      })
+      .then(() => cache.put('/', body2, mockResponse2))
+      .then(() => {
+        expect(mockRedis['foo.com/_mmmmmm']).to.equal(body);
+        expect(mockRedis['bar.com/_mmmmmm']).to.equal(body2);
+        expect(mockRedis['key_index_/']).to.equal(JSON.stringify([
+          'foo.com/_mmmmmm',
+          'bar.com/_mmmmmm'
+        ]));
+      });
+    });
+
+    it('can handle non-JSON keys (migration test)', function() {
+      mockRedis[`key_index_/`] = 'garbage_key';
+      let body = '<body>Hola</body>';
+      let mockResponse = {
+        req: {
+          hostname: 'foo.com',
+          cookies: {
+            chocolateChip: 'mmmmmm'
+          }
+        }
+      };
+
+      return cache.put('/', body, mockResponse)
+      .then(() => {
+        expect(mockRedis['foo.com/_mmmmmm']).to.equal(body);
+        expect(mockRedis['key_index_/']).to.equal(JSON.stringify([
+          'garbage_key',
+          'foo.com/_mmmmmm'
+        ]));
+      });
+    });
+
+    it('can build a custom cache key from the documentId prefix', function() {
+      let body = '<body>Hola</body>';
+      let mockResponse = {
+        req: {
+          hostname: 'foo.com',
+          cookies: {
+            chocolateChip: 'mmmmmm'
+          }
+        }
+      };
+
+      return cache.put('/123-abc', body, mockResponse).then(() => {
+        expect(mockRedis['foo.com/123-abc_mmmmmm']).to.equal(body);
+        expect(mockRedis.key_index_123).to.equal(JSON.stringify(['foo.com/123-abc_mmmmmm']));
       });
     });
 
     it('can get a cache item based on a custom cache key', function() {
       let body = '<body>Hola</body>';
       let cookieValue = 'mmmmmm';
-      mockRedis[`/_${cookieValue}`] = body;
+      mockRedis[`foo.com/_${cookieValue}`] = body;
       let mockRequest = {
+        hostname: 'foo.com',
         cookies: {
           chocolateChip: cookieValue
         }