@keyv/redis 5.1.0 → 5.1.2

package/README.md

@@ -38,6 +38,7 @@ Redis storage adapter for [Keyv](https://github.com/jaredwray/keyv).
 * [Clustering](#clustering)
 * [Sentinel](#sentinel)
 * [TLS Support](#tls-support)
+* [Keyv Redis Options](#keyv-redis-options)
 * [API](#api)
 * [Using Custom Redis Client Events](#using-custom-redis-client-events)
 * [Migrating from v3 to v4](#migrating-from-v3-to-v4)
@@ -79,21 +80,20 @@ Here you can pass in the Redis options directly:
 import Keyv from 'keyv';
 import KeyvRedis from '@keyv/redis';
 
-const redisOptions = {
-  url: 'redis://localhost:6379', // The Redis server URL (use 'rediss' for TLS)
-  password: 'your_password', // Optional password if Redis has authentication enabled
+const uri = "redis://localhost:6379";
 
-  socket: {
-    host: 'localhost', // Hostname of the Redis server
-    port: 6379,        // Port number
-    reconnectStrategy: (retries) => Math.min(retries * 50, 2000), // Custom reconnect logic
-
-    tls: false, // Enable TLS if you need to connect over SSL
-    keepAlive: 30000, // Keep-alive timeout (in milliseconds)
-  }
+// NOTE: please use the settings that you need to configure. Check out Keyv Redis Options section
+const options = {
+  namespace: "test",
+  keyPrefixSeparator: "->",
+  clearBatchSize: 100,
+  useUnlink: true,
+  noNamespaceAffectsAll: true,
 };
 
-const keyv = new Keyv(new KeyvRedis(redisOptions));
+const keyvRedis = new KeyvRedis(uri, options);
+
+const keyv = new Keyv(keyvRedis);
 ```
 
 Or you can create a new Redis instance and pass it in with `KeyvOptions` such as setting the `store`:
@@ -465,6 +465,60 @@ const tlsOptions = {
 const keyv = new Keyv({ store: new KeyvRedis(tlsOptions) });
 ```
 
+# Keyv Redis Options
+
+Here are all the options that you can set on the constructor
+
+```ts
+export type KeyvRedisOptions = {
+	/**
+	 * Namespace for the current instance.
+	 */
+	namespace?: string;
+	/**
+	 * Separator to use between namespace and key.
+	 */
+	keyPrefixSeparator?: string;
+	/**
+	 * Number of keys to delete in a single batch.
+	 */
+	clearBatchSize?: number;
+	/**
+	 * Enable Unlink instead of using Del for clearing keys. This is more performant but may not be supported by all Redis versions.
+	 */
+	useUnlink?: boolean;
+
+	/**
+	 * Whether to allow clearing all keys when no namespace is set.
+	 * If set to true and no namespace is set, iterate() will return all keys.
+	 * Defaults to `false`.
+	 */
+	noNamespaceAffectsAll?: boolean;
+
+	/**
+	 * This is used to throw an error if the client is not connected when trying to connect. By default, this is
+	 * set to true so that it throws an error when trying to connect to the Redis server fails.
+	 */
+	throwOnConnectError?: boolean;
+
+	/**
+	 * This is used to throw an error if at any point there is a failure. Use this if you want to
+	 * ensure that all operations are successful and you want to handle errors. By default, this is
+	 * set to false so that it does not throw an error on every operation and instead emits an error event
+	 * and returns no-op responses.
+	 * @default false
+	 */
+	throwOnErrors?: boolean;
+
+	/**
+	 * Timeout in milliseconds for the connection. Default is undefined, which uses the default timeout of the Redis client.
+	 * If set, it will throw an error if the connection does not succeed within the specified time.
+	 * @default undefined
+	 */
+	connectionTimeout?: number;
+};
+```
+
 # API
 * **constructor([connection], [options])**
 * **namespace** - The namespace to use for the keys.
@@ -530,14 +584,10 @@ const keyv = new Keyv({ store: redis, namespace: 'my-namespace', useKeyPrefix: f
 
 This will make it so the storage adapter `@keyv/redis` will handle the namespace and not the `keyv` instance. If you leave it on it will just look duplicated like `my-namespace:my-namespace:key`.
 
-
-
 # About Redis Sets and its Support in v4
 
 We no longer support redis sets. This is due to the fact that it caused significant performance issues and was not a good fit for the library.
 
-
-
 # Using with NestJS
 
 > You can integrate `@keyv/redis` with NestJS by creating a custom `CacheModule`. This allows you to use Keyv as a cache store in your application.

package/dist/index.cjs

@@ -42,9 +42,9 @@ __export(index_exports, {
 });
 module.exports = __toCommonJS(index_exports);
 var import_client = require("@redis/client");
+var import_cluster_key_slot = __toESM(require("cluster-key-slot"), 1);
 var import_hookified = require("hookified");
 var import_keyv = require("keyv");
-var import_cluster_key_slot = __toESM(require("cluster-key-slot"), 1);
 var import_client2 = require("@redis/client");
 var import_keyv2 = require("keyv");
 var RedisErrorMessages = /* @__PURE__ */ ((RedisErrorMessages2) => {
@@ -79,7 +79,10 @@ var KeyvRedis = class extends import_hookified.Hookified {
     };
     if (connect) {
       if (typeof connect === "string") {
-        this._client = (0, import_client.createClient)({ url: connect, socket });
+        this._client = (0, import_client.createClient)({
+          url: connect,
+          socket
+        });
       } else if (connect.connect !== void 0) {
         if (this.isClientSentinel(connect)) {
           this._client = connect;
@@ -90,9 +93,13 @@ var KeyvRedis = class extends import_hookified.Hookified {
         }
       } else if (connect instanceof Object) {
         if (connect.sentinelRootNodes !== void 0) {
-          this._client = (0, import_client.createSentinel)(connect);
+          this._client = (0, import_client.createSentinel)(
+            connect
+          );
         } else if (connect.rootNodes === void 0) {
-          this._client = (0, import_client.createClient)(connect);
+          this._client = (0, import_client.createClient)(
+            connect
+          );
         } else {
           this._client = (0, import_client.createCluster)(connect);
         }
@@ -321,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;
       }
@@ -365,17 +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 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
+        );
       }
-      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;
       }
@@ -452,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;
       }
@@ -534,7 +628,9 @@ var KeyvRedis = class extends import_hookified.Hookified {
   async getMasterNodes() {
     if (this.isCluster()) {
       const cluster = await this.getClient();
-      const nodes = cluster.masters.map(async (main) => cluster.nodeClient(main));
+      const nodes = cluster.masters.map(
+        async (main) => cluster.nodeClient(main)
+      );
       return Promise.all(nodes);
     }
     return [await this.getClient()];
@@ -550,7 +646,10 @@ var KeyvRedis = class extends import_hookified.Hookified {
       const match = namespace ? `${namespace}${this._keyPrefixSeparator}*` : "*";
       let cursor = "0";
       do {
-        const result = await client.scan(cursor, { MATCH: match, TYPE: "string" });
+        const result = await client.scan(cursor, {
+          MATCH: match,
+          TYPE: "string"
+        });
         cursor = result.cursor.toString();
         let { keys } = result;
         if (!namespace && !this._noNamespaceAffectsAll) {
@@ -577,29 +676,37 @@ var KeyvRedis = class extends import_hookified.Hookified {
   async clear() {
     try {
       const clients = await this.getMasterNodes();
-      await Promise.all(clients.map(async (client) => {
-        if (!this._namespace && this._noNamespaceAffectsAll) {
-          await client.flushDb();
-          return;
-        }
-        let cursor = "0";
-        const batchSize = this._clearBatchSize;
-        const match = this._namespace ? `${this._namespace}${this._keyPrefixSeparator}*` : "*";
-        const deletePromises = [];
-        do {
-          const result = await client.scan(cursor, { MATCH: match, COUNT: batchSize, TYPE: "string" });
-          cursor = result.cursor.toString();
-          let { keys } = result;
-          if (keys.length === 0) {
-            continue;
-          }
-          if (!this._namespace) {
-            keys = keys.filter((key) => !key.includes(this._keyPrefixSeparator));
+      await Promise.all(
+        clients.map(async (client) => {
+          if (!this._namespace && this._noNamespaceAffectsAll) {
+            await client.flushDb();
+            return;
           }
-          deletePromises.push(this.clearWithClusterSupport(keys));
-        } while (cursor !== "0");
-        await Promise.all(deletePromises);
-      }));
+          let cursor = "0";
+          const batchSize = this._clearBatchSize;
+          const match = this._namespace ? `${this._namespace}${this._keyPrefixSeparator}*` : "*";
+          const deletePromises = [];
+          do {
+            const result = await client.scan(cursor, {
+              MATCH: match,
+              COUNT: batchSize,
+              TYPE: "string"
+            });
+            cursor = result.cursor.toString();
+            let { keys } = result;
+            if (keys.length === 0) {
+              continue;
+            }
+            if (!this._namespace) {
+              keys = keys.filter(
+                (key) => !key.includes(this._keyPrefixSeparator)
+              );
+            }
+            deletePromises.push(this.clearWithClusterSupport(keys));
+          } while (cursor !== "0");
+          await Promise.all(deletePromises);
+        })
+      );
     } catch (error) {
       this.emit("error", error);
     }
@@ -609,15 +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);
+    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(keys2[index], value ?? void 0);
+        valueMap.set(keys[index], value ?? void 0);
       }
-    }));
+    }
     return keys.map((key) => valueMap.get(key));
   }
   /**
@@ -627,10 +744,12 @@ var KeyvRedis = class extends import_hookified.Hookified {
   async clearWithClusterSupport(keys) {
     if (keys.length > 0) {
       const slotMap = this.getSlotMap(keys);
-      await Promise.all(Array.from(slotMap.entries(), async ([slot, keys2]) => {
-        const client = await this.getSlotMaster(slot);
-        return this._useUnlink ? client.unlink(keys2) : client.del(keys2);
-      }));
+      await Promise.all(
+        Array.from(slotMap.entries(), async ([slot, keys2]) => {
+          const client = await this.getSlotMaster(slot);
+          return this._useUnlink ? client.unlink(keys2) : client.del(keys2);
+        })
+      );
     }
   }
   /**
@@ -712,15 +831,11 @@ var KeyvRedis = class extends import_hookified.Hookified {
     });
   }
   async createTimeoutPromise(timeoutMs) {
-    return new Promise((_, reject) => (
-      // eslint-disable-next-line no-promise-executor-return
-      setTimeout(
-        () => {
-          reject(new Error(`Redis timed out after ${timeoutMs}ms`));
-        },
-        timeoutMs
-      )
-    ));
+    return new Promise(
+      (_, reject) => setTimeout(() => {
+        reject(new Error(`Redis timed out after ${timeoutMs}ms`));
+      }, timeoutMs)
+    );
   }
 };
 function createKeyv(connect, options) {
@@ -728,7 +843,10 @@ function createKeyv(connect, options) {
   const adapter = new KeyvRedis(connect, options);
   if (options?.namespace) {
     adapter.namespace = options.namespace;
-    const keyv2 = new import_keyv.Keyv(adapter, { namespace: options?.namespace, useKeyPrefix: false });
+    const keyv2 = new import_keyv.Keyv(adapter, {
+      namespace: options?.namespace,
+      useKeyPrefix: false
+    });
     if (options?.throwOnConnectError) {
       keyv2.throwOnErrors = true;
     }

package/dist/index.d.cts

@@ -51,7 +51,7 @@ type KeyvRedisPropertyOptions = KeyvRedisOptions & {
     /**
      * Dialect used by the adapter. This is legacy so Keyv knows what is iteratable.
      */
-    dialect: 'redis';
+    dialect: "redis";
     /**
      * URL used to connect to the Redis server. This is legacy so Keyv knows what is iteratable.
      */

package/dist/index.d.ts

@@ -51,7 +51,7 @@ type KeyvRedisPropertyOptions = KeyvRedisOptions & {
     /**
      * Dialect used by the adapter. This is legacy so Keyv knows what is iteratable.
      */
-    dialect: 'redis';
+    dialect: "redis";
     /**
      * URL used to connect to the Redis server. This is legacy so Keyv knows what is iteratable.
      */

package/dist/index.js

@@ -4,17 +4,15 @@ import {
   createCluster,
   createSentinel
 } from "@redis/client";
+import calculateSlot from "cluster-key-slot";
 import { Hookified } from "hookified";
 import { Keyv } from "keyv";
-import calculateSlot from "cluster-key-slot";
 import {
   createClient as createClient2,
   createCluster as createCluster2,
   createSentinel as createSentinel2
 } from "@redis/client";
-import {
-  Keyv as Keyv2
-} from "keyv";
+import { Keyv as Keyv2 } from "keyv";
 var RedisErrorMessages = /* @__PURE__ */ ((RedisErrorMessages2) => {
   RedisErrorMessages2["RedisClientNotConnectedThrown"] = "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.";
   return RedisErrorMessages2;
@@ -47,7 +45,10 @@ var KeyvRedis = class extends Hookified {
     };
     if (connect) {
       if (typeof connect === "string") {
-        this._client = createClient({ url: connect, socket });
+        this._client = createClient({
+          url: connect,
+          socket
+        });
       } else if (connect.connect !== void 0) {
         if (this.isClientSentinel(connect)) {
           this._client = connect;
@@ -58,9 +59,13 @@ var KeyvRedis = class extends Hookified {
         }
       } else if (connect instanceof Object) {
         if (connect.sentinelRootNodes !== void 0) {
-          this._client = createSentinel(connect);
+          this._client = createSentinel(
+            connect
+          );
         } else if (connect.rootNodes === void 0) {
-          this._client = createClient(connect);
+          this._client = createClient(
+            connect
+          );
         } else {
           this._client = createCluster(connect);
         }
@@ -289,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;
       }
@@ -333,17 +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 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
+        );
       }
-      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;
       }
@@ -420,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;
       }
@@ -502,7 +594,9 @@ var KeyvRedis = class extends Hookified {
   async getMasterNodes() {
     if (this.isCluster()) {
       const cluster = await this.getClient();
-      const nodes = cluster.masters.map(async (main) => cluster.nodeClient(main));
+      const nodes = cluster.masters.map(
+        async (main) => cluster.nodeClient(main)
+      );
       return Promise.all(nodes);
     }
     return [await this.getClient()];
@@ -518,7 +612,10 @@ var KeyvRedis = class extends Hookified {
       const match = namespace ? `${namespace}${this._keyPrefixSeparator}*` : "*";
       let cursor = "0";
       do {
-        const result = await client.scan(cursor, { MATCH: match, TYPE: "string" });
+        const result = await client.scan(cursor, {
+          MATCH: match,
+          TYPE: "string"
+        });
         cursor = result.cursor.toString();
         let { keys } = result;
         if (!namespace && !this._noNamespaceAffectsAll) {
@@ -545,29 +642,37 @@ var KeyvRedis = class extends Hookified {
   async clear() {
     try {
       const clients = await this.getMasterNodes();
-      await Promise.all(clients.map(async (client) => {
-        if (!this._namespace && this._noNamespaceAffectsAll) {
-          await client.flushDb();
-          return;
-        }
-        let cursor = "0";
-        const batchSize = this._clearBatchSize;
-        const match = this._namespace ? `${this._namespace}${this._keyPrefixSeparator}*` : "*";
-        const deletePromises = [];
-        do {
-          const result = await client.scan(cursor, { MATCH: match, COUNT: batchSize, TYPE: "string" });
-          cursor = result.cursor.toString();
-          let { keys } = result;
-          if (keys.length === 0) {
-            continue;
-          }
-          if (!this._namespace) {
-            keys = keys.filter((key) => !key.includes(this._keyPrefixSeparator));
+      await Promise.all(
+        clients.map(async (client) => {
+          if (!this._namespace && this._noNamespaceAffectsAll) {
+            await client.flushDb();
+            return;
           }
-          deletePromises.push(this.clearWithClusterSupport(keys));
-        } while (cursor !== "0");
-        await Promise.all(deletePromises);
-      }));
+          let cursor = "0";
+          const batchSize = this._clearBatchSize;
+          const match = this._namespace ? `${this._namespace}${this._keyPrefixSeparator}*` : "*";
+          const deletePromises = [];
+          do {
+            const result = await client.scan(cursor, {
+              MATCH: match,
+              COUNT: batchSize,
+              TYPE: "string"
+            });
+            cursor = result.cursor.toString();
+            let { keys } = result;
+            if (keys.length === 0) {
+              continue;
+            }
+            if (!this._namespace) {
+              keys = keys.filter(
+                (key) => !key.includes(this._keyPrefixSeparator)
+              );
+            }
+            deletePromises.push(this.clearWithClusterSupport(keys));
+          } while (cursor !== "0");
+          await Promise.all(deletePromises);
+        })
+      );
     } catch (error) {
       this.emit("error", error);
     }
@@ -577,15 +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);
+    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(keys2[index], value ?? void 0);
+        valueMap.set(keys[index], value ?? void 0);
       }
-    }));
+    }
     return keys.map((key) => valueMap.get(key));
   }
   /**
@@ -595,10 +710,12 @@ var KeyvRedis = class extends Hookified {
   async clearWithClusterSupport(keys) {
     if (keys.length > 0) {
       const slotMap = this.getSlotMap(keys);
-      await Promise.all(Array.from(slotMap.entries(), async ([slot, keys2]) => {
-        const client = await this.getSlotMaster(slot);
-        return this._useUnlink ? client.unlink(keys2) : client.del(keys2);
-      }));
+      await Promise.all(
+        Array.from(slotMap.entries(), async ([slot, keys2]) => {
+          const client = await this.getSlotMaster(slot);
+          return this._useUnlink ? client.unlink(keys2) : client.del(keys2);
+        })
+      );
     }
   }
   /**
@@ -680,15 +797,11 @@ var KeyvRedis = class extends Hookified {
     });
   }
   async createTimeoutPromise(timeoutMs) {
-    return new Promise((_, reject) => (
-      // eslint-disable-next-line no-promise-executor-return
-      setTimeout(
-        () => {
-          reject(new Error(`Redis timed out after ${timeoutMs}ms`));
-        },
-        timeoutMs
-      )
-    ));
+    return new Promise(
+      (_, reject) => setTimeout(() => {
+        reject(new Error(`Redis timed out after ${timeoutMs}ms`));
+      }, timeoutMs)
+    );
   }
 };
 function createKeyv(connect, options) {
@@ -696,7 +809,10 @@ function createKeyv(connect, options) {
   const adapter = new KeyvRedis(connect, options);
   if (options?.namespace) {
     adapter.namespace = options.namespace;
-    const keyv2 = new Keyv(adapter, { namespace: options?.namespace, useKeyPrefix: false });
+    const keyv2 = new Keyv(adapter, {
+      namespace: options?.namespace,
+      useKeyPrefix: false
+    });
     if (options?.throwOnConnectError) {
       keyv2.throwOnErrors = true;
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyv/redis",
-  "version": "5.1.0",
+  "version": "5.1.2",
   "description": "Redis storage adapter for Keyv",
   "type": "module",
   "main": "dist/index.cjs",
@@ -34,22 +34,22 @@
   },
   "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": {
-    "@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",
-    "xo": "^1.2.1",
-    "@keyv/test-suite": "^2.1.0"
+    "@keyv/test-suite": "^2.1.1"
   },
   "tsd": {
     "directory": "test"
@@ -63,8 +63,8 @@
   ],
   "scripts": {
     "build": "rimraf ./dist && tsup src/index.ts --format cjs,esm --dts --clean",
-    "test": "xo --fix && vitest run --coverage",
-    "test:ci": "xo && vitest --run --sequence.setupFiles=list --coverage",
+    "test": "biome check --write && vitest run --coverage",
+    "test:ci": "biome check && vitest --run --sequence.setupFiles=list --coverage",
     "clean": "rimraf ./node_modules ./coverage ./dist"
   }
 }