@keyv/redis 5.1.0 → 5.1.1

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);
         }
@@ -373,7 +380,9 @@ var KeyvRedis = class extends import_hookified.Hookified {
         multi.exists(prefixedKey);
       }
       const results = await multi.exec();
-      return results.map((result) => typeof result === "number" && result === 1);
+      return results.map(
+        (result) => typeof result === "number" && result === 1
+      );
     } catch (error) {
       this.emit("error", error);
       if (this._throwOnErrors) {
@@ -534,7 +543,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 +561,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 +591,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;
+      await Promise.all(
+        clients.map(async (client) => {
+          if (!this._namespace && this._noNamespaceAffectsAll) {
+            await client.flushDb();
+            return;
           }
-          if (!this._namespace) {
-            keys = keys.filter((key) => !key.includes(this._keyPrefixSeparator));
-          }
-          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);
     }
@@ -611,13 +633,15 @@ var KeyvRedis = class extends import_hookified.Hookified {
   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);
-      }
-    }));
+    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);
+        }
+      })
+    );
     return keys.map((key) => valueMap.get(key));
   }
   /**
@@ -627,10 +651,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 +738,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 +750,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);
         }
@@ -341,7 +346,9 @@ var KeyvRedis = class extends Hookified {
         multi.exists(prefixedKey);
       }
       const results = await multi.exec();
-      return results.map((result) => typeof result === "number" && result === 1);
+      return results.map(
+        (result) => typeof result === "number" && result === 1
+      );
     } catch (error) {
       this.emit("error", error);
       if (this._throwOnErrors) {
@@ -502,7 +509,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 +527,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 +557,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);
     }
@@ -579,13 +599,15 @@ var KeyvRedis = class extends Hookified {
   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);
-      }
-    }));
+    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);
+        }
+      })
+    );
     return keys.map((key) => valueMap.get(key));
   }
   /**
@@ -595,10 +617,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 +704,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 +716,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.1",
   "description": "Redis storage adapter for Keyv",
   "type": "module",
   "main": "dist/index.cjs",
@@ -42,14 +42,14 @@
     "keyv": "^5.5.0"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.2.0",
     "@faker-js/faker": "^9.9.0",
     "@vitest/coverage-v8": "^3.2.4",
     "rimraf": "^6.0.1",
     "timekeeper": "^2.3.1",
     "tsd": "^0.32.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"
   }
 }