@keyv/redis 5.1.1 → 5.1.2

package/dist/index.cjs

@@ -328,20 +328,50 @@ var KeyvRedis = class extends import_hookified.Hookified {
    * @param {KeyvEntry[]} entries - the key value pairs to set with optional ttl
    */
   async setMany(entries) {
-    const client = await this.getClient();
     try {
-      const multi = client.multi();
-      for (const { key, value, ttl } of entries) {
-        const prefixedKey = this.createKeyPrefix(key, this._namespace);
-        if (ttl) {
-          multi.set(prefixedKey, value, { PX: ttl });
-        } else {
-          multi.set(prefixedKey, value);
+      if (this.isCluster()) {
+        await this.getClient();
+        const slotMap = /* @__PURE__ */ new Map();
+        for (const entry of entries) {
+          const prefixedKey = this.createKeyPrefix(entry.key, this._namespace);
+          const slot = (0, import_cluster_key_slot.default)(prefixedKey);
+          const slotEntries = slotMap.get(slot) ?? [];
+          slotEntries.push(entry);
+          slotMap.set(slot, slotEntries);
+        }
+        await Promise.all(
+          Array.from(slotMap.entries(), async ([slot, slotEntries]) => {
+            const client = await this.getSlotMaster(slot);
+            const multi = client.multi();
+            for (const { key, value, ttl } of slotEntries) {
+              const prefixedKey = this.createKeyPrefix(key, this._namespace);
+              if (ttl) {
+                multi.set(prefixedKey, value, { PX: ttl });
+              } else {
+                multi.set(prefixedKey, value);
+              }
+            }
+            await multi.exec();
+          })
+        );
+      } else {
+        const client = await this.getClient();
+        const multi = client.multi();
+        for (const { key, value, ttl } of entries) {
+          const prefixedKey = this.createKeyPrefix(key, this._namespace);
+          if (ttl) {
+            multi.set(prefixedKey, value, { PX: ttl });
+          } else {
+            multi.set(prefixedKey, value);
+          }
         }
+        await multi.exec();
       }
-      await multi.exec();
     } catch (error) {
       this.emit("error", error);
+      if (this._throwOnConnectError && error.message === "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true." /* RedisClientNotConnectedThrown */) {
+        throw error;
+      }
       if (this._throwOnErrors) {
         throw error;
       }
@@ -372,19 +402,46 @@ var KeyvRedis = class extends import_hookified.Hookified {
    * @returns {Promise<Array<boolean>>} - array of booleans for each key if it exists
    */
   async hasMany(keys) {
-    const client = await this.getClient();
     try {
-      const multi = client.multi();
-      for (const key of keys) {
-        const prefixedKey = this.createKeyPrefix(key, this._namespace);
-        multi.exists(prefixedKey);
-      }
-      const results = await multi.exec();
-      return results.map(
-        (result) => typeof result === "number" && result === 1
+      const prefixedKeys = keys.map(
+        (key) => this.createKeyPrefix(key, this._namespace)
       );
+      if (this.isCluster()) {
+        const slotMap = this.getSlotMap(prefixedKeys);
+        const resultMap = /* @__PURE__ */ new Map();
+        await Promise.all(
+          Array.from(slotMap.entries(), async ([slot, slotKeys]) => {
+            const client = await this.getSlotMaster(slot);
+            const multi = client.multi();
+            for (const key of slotKeys) {
+              multi.exists(key);
+            }
+            const results = await multi.exec();
+            for (const [index, result] of results.entries()) {
+              resultMap.set(
+                slotKeys[index],
+                typeof result === "number" && result === 1
+              );
+            }
+          })
+        );
+        return prefixedKeys.map((key) => resultMap.get(key) ?? false);
+      } else {
+        const client = await this.getClient();
+        const multi = client.multi();
+        for (const key of prefixedKeys) {
+          multi.exists(key);
+        }
+        const results = await multi.exec();
+        return results.map(
+          (result) => typeof result === "number" && result === 1
+        );
+      }
     } catch (error) {
       this.emit("error", error);
+      if (this._throwOnConnectError && error.message === "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true." /* RedisClientNotConnectedThrown */) {
+        throw error;
+      }
       if (this._throwOnErrors) {
         throw error;
       }
@@ -461,25 +518,53 @@ var KeyvRedis = class extends import_hookified.Hookified {
    */
   async deleteMany(keys) {
     let result = false;
-    const client = await this.getClient();
     try {
-      const multi = client.multi();
-      for (const key of keys) {
-        const prefixedKey = this.createKeyPrefix(key, this._namespace);
-        if (this._useUnlink) {
-          multi.unlink(prefixedKey);
-        } else {
-          multi.del(prefixedKey);
+      const prefixedKeys = keys.map(
+        (key) => this.createKeyPrefix(key, this._namespace)
+      );
+      if (this.isCluster()) {
+        const slotMap = this.getSlotMap(prefixedKeys);
+        await Promise.all(
+          Array.from(slotMap.entries(), async ([slot, slotKeys]) => {
+            const client = await this.getSlotMaster(slot);
+            const multi = client.multi();
+            for (const key of slotKeys) {
+              if (this._useUnlink) {
+                multi.unlink(key);
+              } else {
+                multi.del(key);
+              }
+            }
+            const results = await multi.exec();
+            for (const deleted of results) {
+              if (typeof deleted === "number" && deleted > 0) {
+                result = true;
+              }
+            }
+          })
+        );
+      } else {
+        const client = await this.getClient();
+        const multi = client.multi();
+        for (const key of prefixedKeys) {
+          if (this._useUnlink) {
+            multi.unlink(key);
+          } else {
+            multi.del(key);
+          }
         }
-      }
-      const results = await multi.exec();
-      for (const deleted of results) {
-        if (typeof deleted === "number" && deleted > 0) {
-          result = true;
+        const results = await multi.exec();
+        for (const deleted of results) {
+          if (typeof deleted === "number" && deleted > 0) {
+            result = true;
+          }
         }
       }
     } catch (error) {
       this.emit("error", error);
+      if (this._throwOnConnectError && error.message === "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true." /* RedisClientNotConnectedThrown */) {
+        throw error;
+      }
       if (this._throwOnErrors) {
         throw error;
       }
@@ -631,17 +716,25 @@ var KeyvRedis = class extends import_hookified.Hookified {
    * by separating the keys by slot to solve the CROSS-SLOT restriction.
    */
   async mget(keys) {
-    const slotMap = this.getSlotMap(keys);
     const valueMap = /* @__PURE__ */ new Map();
-    await Promise.all(
-      Array.from(slotMap.entries(), async ([slot, keys2]) => {
-        const client = await this.getSlotMaster(slot);
-        const values = await client.mGet(keys2);
-        for (const [index, value] of values.entries()) {
-          valueMap.set(keys2[index], value ?? void 0);
-        }
-      })
-    );
+    if (this.isCluster()) {
+      const slotMap = this.getSlotMap(keys);
+      await Promise.all(
+        Array.from(slotMap.entries(), async ([slot, slotKeys]) => {
+          const client = await this.getSlotMaster(slot);
+          const values = await client.mGet(slotKeys);
+          for (const [index, value] of values.entries()) {
+            valueMap.set(slotKeys[index], value ?? void 0);
+          }
+        })
+      );
+    } else {
+      const client = await this.getClient();
+      const values = await client.mGet(keys);
+      for (const [index, value] of values.entries()) {
+        valueMap.set(keys[index], value ?? void 0);
+      }
+    }
     return keys.map((key) => valueMap.get(key));
   }
   /**

package/dist/index.js

@@ -294,20 +294,50 @@ var KeyvRedis = class extends Hookified {
    * @param {KeyvEntry[]} entries - the key value pairs to set with optional ttl
    */
   async setMany(entries) {
-    const client = await this.getClient();
     try {
-      const multi = client.multi();
-      for (const { key, value, ttl } of entries) {
-        const prefixedKey = this.createKeyPrefix(key, this._namespace);
-        if (ttl) {
-          multi.set(prefixedKey, value, { PX: ttl });
-        } else {
-          multi.set(prefixedKey, value);
+      if (this.isCluster()) {
+        await this.getClient();
+        const slotMap = /* @__PURE__ */ new Map();
+        for (const entry of entries) {
+          const prefixedKey = this.createKeyPrefix(entry.key, this._namespace);
+          const slot = calculateSlot(prefixedKey);
+          const slotEntries = slotMap.get(slot) ?? [];
+          slotEntries.push(entry);
+          slotMap.set(slot, slotEntries);
+        }
+        await Promise.all(
+          Array.from(slotMap.entries(), async ([slot, slotEntries]) => {
+            const client = await this.getSlotMaster(slot);
+            const multi = client.multi();
+            for (const { key, value, ttl } of slotEntries) {
+              const prefixedKey = this.createKeyPrefix(key, this._namespace);
+              if (ttl) {
+                multi.set(prefixedKey, value, { PX: ttl });
+              } else {
+                multi.set(prefixedKey, value);
+              }
+            }
+            await multi.exec();
+          })
+        );
+      } else {
+        const client = await this.getClient();
+        const multi = client.multi();
+        for (const { key, value, ttl } of entries) {
+          const prefixedKey = this.createKeyPrefix(key, this._namespace);
+          if (ttl) {
+            multi.set(prefixedKey, value, { PX: ttl });
+          } else {
+            multi.set(prefixedKey, value);
+          }
         }
+        await multi.exec();
       }
-      await multi.exec();
     } catch (error) {
       this.emit("error", error);
+      if (this._throwOnConnectError && error.message === "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true." /* RedisClientNotConnectedThrown */) {
+        throw error;
+      }
       if (this._throwOnErrors) {
         throw error;
       }
@@ -338,19 +368,46 @@ var KeyvRedis = class extends Hookified {
    * @returns {Promise<Array<boolean>>} - array of booleans for each key if it exists
    */
   async hasMany(keys) {
-    const client = await this.getClient();
     try {
-      const multi = client.multi();
-      for (const key of keys) {
-        const prefixedKey = this.createKeyPrefix(key, this._namespace);
-        multi.exists(prefixedKey);
-      }
-      const results = await multi.exec();
-      return results.map(
-        (result) => typeof result === "number" && result === 1
+      const prefixedKeys = keys.map(
+        (key) => this.createKeyPrefix(key, this._namespace)
       );
+      if (this.isCluster()) {
+        const slotMap = this.getSlotMap(prefixedKeys);
+        const resultMap = /* @__PURE__ */ new Map();
+        await Promise.all(
+          Array.from(slotMap.entries(), async ([slot, slotKeys]) => {
+            const client = await this.getSlotMaster(slot);
+            const multi = client.multi();
+            for (const key of slotKeys) {
+              multi.exists(key);
+            }
+            const results = await multi.exec();
+            for (const [index, result] of results.entries()) {
+              resultMap.set(
+                slotKeys[index],
+                typeof result === "number" && result === 1
+              );
+            }
+          })
+        );
+        return prefixedKeys.map((key) => resultMap.get(key) ?? false);
+      } else {
+        const client = await this.getClient();
+        const multi = client.multi();
+        for (const key of prefixedKeys) {
+          multi.exists(key);
+        }
+        const results = await multi.exec();
+        return results.map(
+          (result) => typeof result === "number" && result === 1
+        );
+      }
     } catch (error) {
       this.emit("error", error);
+      if (this._throwOnConnectError && error.message === "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true." /* RedisClientNotConnectedThrown */) {
+        throw error;
+      }
       if (this._throwOnErrors) {
         throw error;
       }
@@ -427,25 +484,53 @@ var KeyvRedis = class extends Hookified {
    */
   async deleteMany(keys) {
     let result = false;
-    const client = await this.getClient();
     try {
-      const multi = client.multi();
-      for (const key of keys) {
-        const prefixedKey = this.createKeyPrefix(key, this._namespace);
-        if (this._useUnlink) {
-          multi.unlink(prefixedKey);
-        } else {
-          multi.del(prefixedKey);
+      const prefixedKeys = keys.map(
+        (key) => this.createKeyPrefix(key, this._namespace)
+      );
+      if (this.isCluster()) {
+        const slotMap = this.getSlotMap(prefixedKeys);
+        await Promise.all(
+          Array.from(slotMap.entries(), async ([slot, slotKeys]) => {
+            const client = await this.getSlotMaster(slot);
+            const multi = client.multi();
+            for (const key of slotKeys) {
+              if (this._useUnlink) {
+                multi.unlink(key);
+              } else {
+                multi.del(key);
+              }
+            }
+            const results = await multi.exec();
+            for (const deleted of results) {
+              if (typeof deleted === "number" && deleted > 0) {
+                result = true;
+              }
+            }
+          })
+        );
+      } else {
+        const client = await this.getClient();
+        const multi = client.multi();
+        for (const key of prefixedKeys) {
+          if (this._useUnlink) {
+            multi.unlink(key);
+          } else {
+            multi.del(key);
+          }
         }
-      }
-      const results = await multi.exec();
-      for (const deleted of results) {
-        if (typeof deleted === "number" && deleted > 0) {
-          result = true;
+        const results = await multi.exec();
+        for (const deleted of results) {
+          if (typeof deleted === "number" && deleted > 0) {
+            result = true;
+          }
         }
       }
     } catch (error) {
       this.emit("error", error);
+      if (this._throwOnConnectError && error.message === "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true." /* RedisClientNotConnectedThrown */) {
+        throw error;
+      }
       if (this._throwOnErrors) {
         throw error;
       }
@@ -597,17 +682,25 @@ var KeyvRedis = class extends Hookified {
    * by separating the keys by slot to solve the CROSS-SLOT restriction.
    */
   async mget(keys) {
-    const slotMap = this.getSlotMap(keys);
     const valueMap = /* @__PURE__ */ new Map();
-    await Promise.all(
-      Array.from(slotMap.entries(), async ([slot, keys2]) => {
-        const client = await this.getSlotMaster(slot);
-        const values = await client.mGet(keys2);
-        for (const [index, value] of values.entries()) {
-          valueMap.set(keys2[index], value ?? void 0);
-        }
-      })
-    );
+    if (this.isCluster()) {
+      const slotMap = this.getSlotMap(keys);
+      await Promise.all(
+        Array.from(slotMap.entries(), async ([slot, slotKeys]) => {
+          const client = await this.getSlotMaster(slot);
+          const values = await client.mGet(slotKeys);
+          for (const [index, value] of values.entries()) {
+            valueMap.set(slotKeys[index], value ?? void 0);
+          }
+        })
+      );
+    } else {
+      const client = await this.getClient();
+      const values = await client.mGet(keys);
+      for (const [index, value] of values.entries()) {
+        valueMap.set(keys[index], value ?? void 0);
+      }
+    }
     return keys.map((key) => valueMap.get(key));
   }
   /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyv/redis",
-  "version": "5.1.1",
+  "version": "5.1.2",
   "description": "Redis storage adapter for Keyv",
   "type": "module",
   "main": "dist/index.cjs",
@@ -34,20 +34,20 @@
   },
   "homepage": "https://github.com/jaredwray/keyv",
   "dependencies": {
-    "@redis/client": "^5.7.0",
+    "@redis/client": "^5.8.2",
     "cluster-key-slot": "^1.1.2",
-    "hookified": "^1.11.0"
+    "hookified": "^1.12.0"
   },
   "peerDependencies": {
-    "keyv": "^5.5.0"
+    "keyv": "^5.5.1"
   },
   "devDependencies": {
-    "@biomejs/biome": "^2.2.0",
-    "@faker-js/faker": "^9.9.0",
+    "@biomejs/biome": "^2.2.3",
+    "@faker-js/faker": "^10.0.0",
     "@vitest/coverage-v8": "^3.2.4",
     "rimraf": "^6.0.1",
     "timekeeper": "^2.3.1",
-    "tsd": "^0.32.0",
+    "tsd": "^0.33.0",
     "vitest": "^3.2.4",
     "@keyv/test-suite": "^2.1.1"
   },