💡 [major] Prefer MSGPack over JSON

package.json

@@ -72,6 +72,7 @@
   },
   "dependencies": {
     "ioredis": "5.x",
+    "msgpackr": "1.x",
     "lru-cache": "10.x",
     "redlock": "4.x"
   }

src/lib/RedisCache.ts

@@ -1,8 +1,10 @@
 import Redis from 'ioredis';
 import * as Redlock from 'redlock';
+import { Packr } from 'msgpackr';
 
 import { CachableValue, CacheInstance } from './CacheInstance';
 
+const MPACK = new Packr({ moreTypes: true }); // `moreTypes: true` to get free support for Set & Map
 
 /**
  * Wrapper class for using Redis as a cache.
@@ -21,6 +23,7 @@ export class RedisCache extends CacheInstance {
   public static TRUE_VALUE = 'f405eed4-507c-4aa5-a6d2-c1813d584b8f-TRUE';
   public static FALSE_VALUE = 'f405eed4-507c-4aa5-a6d2-c1813d584b8f-FALSE';
   public static JSON_PREFIX = 'f405eed4-507c-4aa5-a6d2-c1813d584b8f-JSON';
+  public static MSGP_PREFIX = 'f405eed4-507c-4aa5-a6d2-c1813d584b8f-MSGP';
   public static ERROR_PREFIX = 'f405eed4-507c-4aa5-a6d2-c1813d584b8f-ERROR';
   public static NUMBER_PREFIX = 'f405eed4-507c-4aa5-a6d2-c1813d584b8f-NUMBER';
 
@@ -166,19 +169,10 @@ export class RedisCache extends CacheInstance {
     }
 
     if (value instanceof Object) {
-      return RedisCache.JSON_PREFIX + JSON.stringify(value,  (key, value) => {
-        if (value instanceof Set) {
-          return { __dataType: 'Set', value: Array.from(value) };
-        } else if (value instanceof Map) {
-          return { __dataType: 'Map', value: Array.from(value) };
-        } else {
-          return value;
-        }
-      });
+      return `${RedisCache.MSGP_PREFIX}${MPACK.pack(value).toString('binary')}`;
     }
 
     return value;
-
   }
 
   /**
@@ -212,6 +206,10 @@ export class RedisCache extends CacheInstance {
       return false;
     }
 
+    if (value.startsWith(RedisCache.MSGP_PREFIX)) {
+      return MPACK.unpack(Buffer.from(value.substring(RedisCache.MSGP_PREFIX.length), 'binary'));
+    }
+
     if (value.startsWith(RedisCache.ERROR_PREFIX)) {
       const deserializedError = JSON.parse(value.substring(RedisCache.ERROR_PREFIX.length));
       // return error, restoring potential Error metadata set as object properties
@@ -240,7 +238,6 @@ export class RedisCache extends CacheInstance {
     }
 
     return value;
-
   }
 
   /**

test/RedisCache_test.ts

@@ -53,11 +53,11 @@ describe('RedisCache', () => {
         },
       };
       let value = RedisCache.serializeValue(obj);
-      expect(value.startsWith(RedisCache.JSON_PREFIX)).to.be.true;
+      expect(value.startsWith(RedisCache.MSGP_PREFIX)).to.be.true;
       value = RedisCache.deserializeValue(value);
       expect(value).to.deep.equal(obj);
     });
-  
+
     it('can serialize an object with a nested map', () => {
       const mapStructure: Map<string, {
         checksum: number;
@@ -78,11 +78,11 @@ describe('RedisCache', () => {
         },
       };
       let value = RedisCache.serializeValue(obj);
-      expect(value.startsWith(RedisCache.JSON_PREFIX)).to.be.true;
+      expect(value.startsWith(RedisCache.MSGP_PREFIX)).to.be.true;
       value = RedisCache.deserializeValue(value);
       expect(value).to.deep.equal(obj);
     });
-  
+
     it('can serialize an object with a nested set', () => {
       const setStructure: Set<string> = new Set();
       setStructure.add('key1');
@@ -100,7 +100,7 @@ describe('RedisCache', () => {
         },
       };
       let value = RedisCache.serializeValue(obj);
-      expect(value.startsWith(RedisCache.JSON_PREFIX)).to.be.true;
+      expect(value.startsWith(RedisCache.MSGP_PREFIX)).to.be.true;
       value = RedisCache.deserializeValue(value);
       expect(value).to.deep.equal(obj);
     });
@@ -222,6 +222,47 @@ describe('RedisCache', () => {
 
       expect(await cache.itemCount()).to.equal(1);
     });
+
+    it('can set a msgpacked object', async function (): Promise<void> {
+      if (!process.env.TEST_REDIS_URL) {
+        this.skip();
+      }
+
+      const cache = new RedisCache(process.env.TEST_REDIS_URL as string);
+      await cache.isReady();
+
+      // Just to be sure that the cache is really empty...
+      await cache.clear();
+
+      const wasSet = await cache.setValue('key', { '🍌': '🥔' });
+      expect(wasSet).to.be.true;
+
+      const value = await cache.getValue('key');
+      expect(value).to.deep.equal({ '🍌': '🥔' });
+
+      expect(await cache.itemCount()).to.equal(1);
+    });
+
+    it('can get a JSON value', async function (): Promise<void> {
+      if (!process.env.TEST_REDIS_URL) {
+        this.skip();
+      }
+
+      const cache = new RedisCache(process.env.TEST_REDIS_URL as string);
+      await cache.isReady();
+
+      // Just to be sure that the cache is really empty...
+      await cache.clear();
+
+      // Manual serialization here to avoid the automatic serialization of the setValue method.
+      const wasSet = await cache.setValue('key', `${RedisCache.JSON_PREFIX}${JSON.stringify({ '🍌': '🥔' })}`);
+      expect(wasSet).to.be.true;
+
+      const value = await cache.getValue('key');
+      expect(value).to.deep.equal({ '🍌': '🥔' });
+
+      expect(await cache.itemCount()).to.equal(1);
+    });
   });
 
   describe('itemCount', async () => {
@@ -258,7 +299,7 @@ describe('RedisCache', () => {
       await cache.clear();
 
       await cache.setValue('test1', 'value1');
-      
+
       const replicationAcknowledged = await cache.waitForReplication(0, 50);
 
       // No replicas so we expect 0. This test basically confirms that waitForReplication doesn't crash. 🤷‍♂️