feat!: use hashtags to ensure hyper cache store keys hash to the same slot #22 #17

BREAKING CHANGE: all cache store keys that currently exist in a hyper cache
will MISS. The the values will need to be recomputed and then re-stored
in hyper cache

Author: TillaTheHun0

adapter.js

@@ -4,7 +4,23 @@ import { handleHyperErr } from './utils.js'
 const { Async } = crocks
 const { always, append, identity, ifElse, isNil, map, not, compose } = R
 
-const createKey = (store, key) => `${store}_${key}`
+/**
+ * Create a hyper store cache key, with the given prefix.
+ * By default, the prefix is hashtagged to ensure all keys "contained" in the prefix
+ * are stored within the same hash slot. This is useful when performing multi-key operations
+ * on a Redis cluster. See https://github.com/hyper63/hyper-adapter-redis/issues/17
+ *
+ * See: https://redis.io/docs/reference/cluster-spec/#hash-tags
+ *
+ * @param {string} prefix - the prefix for the key, typically the hyper cache store name
+ * @param {string} key - the key
+ * @param {boolean} [noHashSlot] - whether to hashtag the prefix, which will cause all keys
+ * "within" this prefix to be mapped to the same hash slot. This is useful for multi-key operations
+ * performed on a Redis cluster. Defaults to false, which is to say "hashtag the prefix"
+ * @returns
+ */
+const createKey = (prefix, key, noHashSlot = false) =>
+  `${noHashSlot ? `${prefix}` : `{${prefix}}`}_${key}`
 
 const mapTtl = (ttl) =>
   ifElse(
@@ -48,7 +64,7 @@ export default function (client, options) {
   }
 
   const checkIfStoreExists = (store) => (key) =>
-    get(createKey('store', store))
+    get(createKey('store', store, true))
       .chain(
         (_) =>
           _ ? Async.Resolved(key) : Async.Rejected(HyperErr({
@@ -77,7 +93,7 @@ export default function (client, options) {
    */
   const createStore = (name) =>
     Async.of([])
-      .map(append(createKey('store', name)))
+      .map(append(createKey('store', name, true)))
       .map(append('active'))
       .chain((args) => set(...args))
       .bichain(
@@ -113,7 +129,7 @@ export default function (client, options) {
         ),
       )
       // Delete the key that tracks the store's existence
-      .chain(() => del(createKey('store', name)))
+      .chain(() => del(createKey('store', name, true)))
       .bichain(
         handleHyperErr,
         always(Async.Resolved({ ok: true })),
@@ -146,8 +162,9 @@ export default function (client, options) {
    * @returns {Promise<object>}
    */
   const getDoc = ({ store, key }) =>
-    checkIfStoreExists(store)()
-      .chain(() => get(createKey(store, key)))
+    Async.of(createKey(store, key))
+      .chain(checkIfStoreExists(store))
+      .chain(get)
       .chain((v) => {
         if (!v) {
           return Async.Rejected(HyperErr({

adapter.test.js

@@ -41,11 +41,11 @@ Deno.test('adapter', async (t) => {
       })
 
       assertObjectMatch(scan.calls[0].args, [0, {
-        pattern: 'word_*',
+        pattern: '{word}_*',
         count: 100,
       }])
       assertObjectMatch(scan.calls[1].args, ['50', {
-        pattern: 'word_*',
+        pattern: '{word}_*',
         count: 100,
       }])
       assert(results.docs.length === 100)
@@ -122,14 +122,14 @@ Deno.test('adapter', async (t) => {
         const adapter = createAdapter({
           ...baseStubClient,
           del,
-          scan: resolves(['0', ['baz', 'bar']]),
+          scan: resolves(['0', ['{foo}_baz', '{foo}_bar']]),
         }, baseOptions)
 
         const result = await adapter.destroyStore('foo')
 
         assert(result.ok)
-        assertObjectMatch(del.calls[0], { args: ['baz'] })
-        assertObjectMatch(del.calls[1], { args: ['bar'] })
+        assertObjectMatch(del.calls[0], { args: ['{foo}_baz'] })
+        assertObjectMatch(del.calls[1], { args: ['{foo}_bar'] })
         assertObjectMatch(del.calls[2], { args: ['store_foo'] })
       },
     )
@@ -139,7 +139,8 @@ Deno.test('adapter', async (t) => {
     await t.step('should save the doc in redis as serialized JSON', async () => {
       const adapter = createAdapter({
         ...baseStubClient,
-        set: (_k, v, opts) => {
+        set: (k, v, opts) => {
+          assertEquals(k, '{foo}_bar')
           assertEquals(v, JSON.stringify({ bam: 'baz' }))
           assertObjectMatch(opts, { px: 5000 })
           return Promise.resolve('OK')
@@ -229,7 +230,11 @@ Deno.test('adapter', async (t) => {
       const adapter = createAdapter({
         ...baseStubClient,
         // serialized JSON
-        get: resolves(JSON.stringify(value)),
+        get: (k) => {
+          return k === 'store_foo'
+            ? Promise.resolve(JSON.stringify({ active: true })) // store
+            : (assertEquals(k, '{foo}_bar'), Promise.resolve(JSON.stringify(value)))
+        },
       }, baseOptions)
 
       const result = await adapter.getDoc({
@@ -266,12 +271,16 @@ Deno.test('adapter', async (t) => {
     await t.step('should upsert the doc into Redis as serialized JSON', async () => {
       const adapter = createAdapter({
         ...baseStubClient,
-        set: (_k, v, opts) => {
+        set: (k, v, opts) => {
+          assertEquals(k, '{foo}_bar')
           assertEquals(v, JSON.stringify({ hello: 'world' }))
           assertObjectMatch(opts, { px: 123 })
           return Promise.resolve('OK')
         },
-        get: (k) => k === 'store_foo' ? Promise.resolve('{"active": true}') : Promise.resolve(null),
+        get: (k) =>
+          k === 'store_foo'
+            ? Promise.resolve(JSON.stringify({ active: true }))
+            : Promise.resolve(undefined),
       }, baseOptions)
 
       const result = await adapter.updateDoc({