@keyv/redis 5.0.0 → 5.1.1

package/README.md

@@ -35,11 +35,15 @@ Redis storage adapter for [Keyv](https://github.com/jaredwray/keyv).
 * [High Memory Usage on Redis Server](#high-memory-usage-on-redis-server)
 * [Gracefully Handling Errors and Timeouts](#gracefully-handling-errors-and-timeouts)
 * [Using Cacheable with Redis](#using-cacheable-with-redis)
-* [Clustering and TLS Support](#clustering-and-tls-support)
+* [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)
 * [About Redis Sets and its Support in v4](#about-redis-sets-and-its-support-in-v4)
+* [Using with NestJS](#using-with-nestjs)
 * [License](#license)
 
 # Installation
@@ -76,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`:
@@ -379,9 +382,9 @@ const cache = new Cacheable( { secondary, nonBlocking: true } );
 
 This will make it so that the secondary does not block the primary cache and will be very fast. 🚀
 
-# Clustering and TLS Support
+# Clustering
 
-If you are using a Redis Cluster or need to use TLS, you can pass in the `redisOptions` directly. Here is an example of how to do that:
+If you are using a Redis Cluster, you can pass in the `redisOptions` directly. Here is an example of how to do that:
 
 ```js
 import Keyv from 'keyv';
@@ -404,9 +407,42 @@ const cluster = createCluster({
 const keyv = new Keyv({ store: new KeyvRedis(cluster) });
 ```
 
-You can learn more about the `createCluster` function in the [documentation](https://github.com/redis/node-redis/blob/master/docs/clustering.md) at https://github.com/redis/node-redis/tree/master/docs. 
+You can learn more about the `createCluster` function in the [documentation](https://github.com/redis/node-redis/blob/master/docs/clustering.md) at https://github.com/redis/node-redis/tree/master/docs.
 
-Here is an example of how to use TLS:
+# Sentinel
+
+If you are using Sentinel to provide high availability for your Redis instances, you can pass in the `redisOptions` directly. Here is an example of how to do that:
+
+```js
+import Keyv from 'keyv';
+import KeyvRedis, { createSentinel } from '@keyv/redis';
+
+const sentinel = createSentinel({
+    name: 'sentinel-db',
+    sentinelRootNodes: [
+      {
+        host: '127.0.0.1',
+        port: 26379,
+      },
+      {
+        host: '127.0.0.1',
+        port: 26380,
+      },
+      {
+        host: '127.0.0.1',
+        port: 26381,
+      },
+    ],
+});
+
+const keyv = new Keyv({ store: new KeyvRedis(sentinel) });
+```
+
+You can learn more about the `createSentinel` function in the [documentation](https://github.com/redis/node-redis/blob/master/docs/sentinel.md) at https://github.com/redis/node-redis/tree/master/docs.
+
+# TLS Support
+
+Here is an example of how to use TLS using the `redisOptions`:
 
 ```js
 import Keyv from 'keyv';
@@ -429,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.
@@ -494,12 +584,167 @@ 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.
+
+### 1. Install Dependencies
+
+```bash
+npm install @keyv/redis keyv @nestjs/cache-manager cache-manager cacheable
+```
+
+### 2. Create a Cache Module
+
+Create a file `cache.module.ts`:
+
+```ts
+import { Module } from '@nestjs/common';
+import { CacheModule as NestCacheModule } from '@nestjs/cache-manager';
+import { createKeyv } from '@keyv/redis';
+
+@Module({
+  imports: [
+    NestCacheModule.registerAsync({
+      useFactory: () => ({
+        stores: [createKeyv('redis://localhost:6379')],
+      }),
+    }),
+  ],
+  providers: [],
+  exports: [],
+})
+export class CacheModule {}
+```
+
+### 3. Import the Cache Module in AppModule
+Update `app.module.ts`:
+
+```ts
+import { Module } from '@nestjs/common';
+import { CacheModule } from './modules/config/cache/cache.module';
+
+@Module({
+  imports: [
+    CacheModule, // Import your custom cache module
+    // other modules...
+  ],
+})
+export class AppModule {}
+```
+
+### 4. Create the Cache Service
+Create a file `cache.service.ts`:
+
+```ts
+import { CACHE_MANAGER } from '@nestjs/cache-manager';
+import { Inject, Injectable } from '@nestjs/common';
+import { Cache } from 'cache-manager';
+
+@Injectable()
+export class CacheService {
+  constructor(@Inject(CACHE_MANAGER) private cacheManager: Cache) {}
+
+  async get<T>(key: string): Promise<T | undefined> {
+    return this.cacheManager.get<T>(key);
+  }
+
+  async set<T>(key: string, value: T, ttl?: number): Promise<void> {
+    await this.cacheManager.set(key, value, ttl);
+  }
+
+  async delete(key: string): Promise<void> {
+    await this.cacheManager.del(key);
+  }
+}
+```
+
+### 5. Register CacheService in CacheModule
+Update `cache.module.ts`:
+
+```ts
+import { Module } from '@nestjs/common';
+import { CacheModule as NestCacheModule } from '@nestjs/cache-manager';
+import { createKeyv } from '@keyv/redis';
+import { CacheService } from './services/cache.service';
+
+@Module({
+  imports: [
+    NestCacheModule.registerAsync({
+      useFactory: () => ({
+        stores: [createKeyv('redis://localhost:6379')],
+      }),
+    }),
+  ],
+  providers: [CacheService],
+  exports: [CacheService],
+})
+export class CacheModule {}
+```
+### 6. Import CacheModule in the Target Module (e.g. TaskModule)
+```ts
+import { Module } from '@nestjs/common';
+import { TaskService } from './task.service';
+import { TaskRepository } from './repositories/task.repository';
+import { CacheModule } from 'src/modules/config/cache/cache.module';
+
+@Module({
+  imports: [CacheModule],
+  providers: [TaskService, TaskRepository],
+})
+export class TaskModule {}
+```
+
+### 7. Using the Cache in a Service
+
+```ts
+import { Injectable, NotFoundException } from '@nestjs/common';
+import { TaskRepository } from '../repositories/task.repository';
+import { TaskDto } from '../dto/task.dto';
+import { CacheService } from 'src/modules/config/cache/services/cache.service';
+
+@Injectable()
+export class TaskService {
+  constructor(
+    private readonly taskRepository: TaskRepository,
+    private readonly cache: CacheService, // Inject the CacheService
+  ) {}
+
+  async findById(id: number): Promise<TaskDto> {
+    const cacheKey = `task:${id}`;
+
+    // 1. Try to get from cache
+    const cached = await this.cache.get<TaskDto>(cacheKey);
+    
+	if (cached) {
+      return cached;
+    }
+
+    // 2. If not found in cache, fetch from database
+    const task = await this.taskRepository.findById(id);
+
+    if (!task) {
+      throw new NotFoundException('Task not found');
+    }
+
+    // 3. Set in cache for future requests
+    await this.cache.set(cacheKey, task, 300 * 1000); // 5 minutes TTL
+    return task;
+  }
+}
+```
+
+
+You can learn more about caching in NestJS in the [official documentation](https://docs.nestjs.com/techniques/caching#in-memory-cache).
+
+
+---
+
+
 # License
 
 [MIT © Jared Wray](LISCENCE)

package/dist/index.cjs

@@ -36,14 +36,15 @@ __export(index_exports, {
   createCluster: () => import_client2.createCluster,
   createKeyv: () => createKeyv,
   createKeyvNonBlocking: () => createKeyvNonBlocking,
+  createSentinel: () => import_client2.createSentinel,
   default: () => KeyvRedis,
   defaultReconnectStrategy: () => defaultReconnectStrategy
 });
 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) => {
@@ -78,11 +79,30 @@ 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) {
-        this._client = this.isClientCluster(connect) ? connect : connect;
+        if (this.isClientSentinel(connect)) {
+          this._client = connect;
+        } else if (this.isClientCluster(connect)) {
+          this._client = connect;
+        } else {
+          this._client = connect;
+        }
       } else if (connect instanceof Object) {
-        this._client = connect.rootNodes === void 0 ? (0, import_client.createClient)(connect) : (0, import_client.createCluster)(connect);
+        if (connect.sentinelRootNodes !== void 0) {
+          this._client = (0, import_client.createSentinel)(
+            connect
+          );
+        } else if (connect.rootNodes === void 0) {
+          this._client = (0, import_client.createClient)(
+            connect
+          );
+        } else {
+          this._client = (0, import_client.createCluster)(connect);
+        }
       }
     }
     this.setOptions(options);
@@ -360,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) {
@@ -506,6 +528,13 @@ var KeyvRedis = class extends import_hookified.Hookified {
   isCluster() {
     return this.isClientCluster(this._client);
   }
+  /**
+   * Is the client a sentinel.
+   * @returns {boolean} - true if the client is a sentinel, false if not
+   */
+  isSentinel() {
+    return this.isClientSentinel(this._client);
+  }
   /**
    * Get the master nodes in the cluster. If not a cluster, it will return the single client.
    *
@@ -514,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()];
@@ -530,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) {
@@ -557,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;
-          }
-          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);
     }
@@ -591,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));
   }
   /**
@@ -607,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);
+        })
+      );
     }
   }
   /**
@@ -648,6 +694,9 @@ var KeyvRedis = class extends import_hookified.Hookified {
   isClientCluster(client) {
     return client.slots !== void 0;
   }
+  isClientSentinel(client) {
+    return client.getSentinelNode !== void 0;
+  }
   setOptions(options) {
     if (!options) {
       return;
@@ -689,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) {
@@ -705,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;
     }
@@ -747,5 +795,6 @@ function createKeyvNonBlocking(connect, options) {
   createCluster,
   createKeyv,
   createKeyvNonBlocking,
+  createSentinel,
   defaultReconnectStrategy
 });

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { RedisClientOptions, RedisClusterOptions, RedisClientType, RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping, RedisClusterType } from '@redis/client';
-export { RedisClientOptions, RedisClientType, RedisClusterOptions, RedisClusterType, createClient, createCluster } from '@redis/client';
+import { RedisClientOptions, RedisClusterOptions, RedisSentinelOptions, RedisClientType, RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping, RedisClusterType, RedisSentinelType } from '@redis/client';
+export { RedisClientOptions, RedisClientType, RedisClusterOptions, RedisClusterType, RedisSentinelType, createClient, createCluster, createSentinel } from '@redis/client';
 import { Hookified } from 'hookified';
 import { KeyvStoreAdapter, KeyvEntry, Keyv } from 'keyv';
 export { Keyv } from 'keyv';
@@ -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.
      */
@@ -80,7 +80,8 @@ declare enum RedisErrorMessages {
 declare const defaultReconnectStrategy: (attempts: number) => number | Error;
 type RedisConnectionClientType = RedisClientType | RedisClientType<RedisModules, RedisFunctions, RedisScripts, RespVersions> | RedisClientType<RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping>;
 type RedisConnectionClusterType = RedisClusterType | RedisClusterType<RedisModules, RedisFunctions, RedisScripts, RespVersions> | RedisClusterType<RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping>;
-type RedisClientConnectionType = RedisConnectionClientType | RedisConnectionClusterType;
+type RedisConnectionSentinelType = RedisSentinelType | RedisSentinelType<RedisModules, RedisFunctions, RedisScripts, RespVersions> | RedisSentinelType<RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping>;
+type RedisClientConnectionType = RedisConnectionClientType | RedisConnectionClusterType | RedisConnectionSentinelType;
 declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
     private _client;
     private _namespace;
@@ -96,7 +97,7 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
      * @param {string | RedisClientOptions | RedisClientType} [connect] How to connect to the Redis server. If string pass in the url, if object pass in the options, if RedisClient pass in the client.
      * @param {KeyvRedisOptions} [options] Options for the adapter such as namespace, keyPrefixSeparator, and clearBatchSize.
      */
-    constructor(connect?: string | RedisClientOptions | RedisClusterOptions | RedisClientConnectionType, options?: KeyvRedisOptions);
+    constructor(connect?: string | RedisClientOptions | RedisClusterOptions | RedisSentinelOptions | RedisClientConnectionType, options?: KeyvRedisOptions);
     /**
      * Get the Redis client.
      */
@@ -278,6 +279,11 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
      * @returns {boolean} - true if the client is a cluster, false if not
      */
     isCluster(): boolean;
+    /**
+     * Is the client a sentinel.
+     * @returns {boolean} - true if the client is a sentinel, false if not
+     */
+    isSentinel(): boolean;
     /**
      * Get the master nodes in the cluster. If not a cluster, it will return the single client.
      *
@@ -320,6 +326,7 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
      */
     private getSlotMap;
     private isClientCluster;
+    private isClientSentinel;
     private setOptions;
     private initClient;
     private createTimeoutPromise;
@@ -333,4 +340,4 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
 declare function createKeyv(connect?: string | RedisClientOptions | RedisClientType, options?: KeyvRedisOptions): Keyv;
 declare function createKeyvNonBlocking(connect?: string | RedisClientOptions | RedisClientType, options?: KeyvRedisOptions): Keyv;
 
-export { type KeyvRedisEntry, type KeyvRedisOptions, type KeyvRedisPropertyOptions, type RedisClientConnectionType, type RedisConnectionClientType, type RedisConnectionClusterType, RedisErrorMessages, createKeyv, createKeyvNonBlocking, KeyvRedis as default, defaultReconnectStrategy };
+export { type KeyvRedisEntry, type KeyvRedisOptions, type KeyvRedisPropertyOptions, type RedisClientConnectionType, type RedisConnectionClientType, type RedisConnectionClusterType, type RedisConnectionSentinelType, RedisErrorMessages, createKeyv, createKeyvNonBlocking, KeyvRedis as default, defaultReconnectStrategy };

package/dist/index.d.ts

@@ -1,5 +1,5 @@
-import { RedisClientOptions, RedisClusterOptions, RedisClientType, RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping, RedisClusterType } from '@redis/client';
-export { RedisClientOptions, RedisClientType, RedisClusterOptions, RedisClusterType, createClient, createCluster } from '@redis/client';
+import { RedisClientOptions, RedisClusterOptions, RedisSentinelOptions, RedisClientType, RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping, RedisClusterType, RedisSentinelType } from '@redis/client';
+export { RedisClientOptions, RedisClientType, RedisClusterOptions, RedisClusterType, RedisSentinelType, createClient, createCluster, createSentinel } from '@redis/client';
 import { Hookified } from 'hookified';
 import { KeyvStoreAdapter, KeyvEntry, Keyv } from 'keyv';
 export { Keyv } from 'keyv';
@@ -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.
      */
@@ -80,7 +80,8 @@ declare enum RedisErrorMessages {
 declare const defaultReconnectStrategy: (attempts: number) => number | Error;
 type RedisConnectionClientType = RedisClientType | RedisClientType<RedisModules, RedisFunctions, RedisScripts, RespVersions> | RedisClientType<RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping>;
 type RedisConnectionClusterType = RedisClusterType | RedisClusterType<RedisModules, RedisFunctions, RedisScripts, RespVersions> | RedisClusterType<RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping>;
-type RedisClientConnectionType = RedisConnectionClientType | RedisConnectionClusterType;
+type RedisConnectionSentinelType = RedisSentinelType | RedisSentinelType<RedisModules, RedisFunctions, RedisScripts, RespVersions> | RedisSentinelType<RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping>;
+type RedisClientConnectionType = RedisConnectionClientType | RedisConnectionClusterType | RedisConnectionSentinelType;
 declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
     private _client;
     private _namespace;
@@ -96,7 +97,7 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
      * @param {string | RedisClientOptions | RedisClientType} [connect] How to connect to the Redis server. If string pass in the url, if object pass in the options, if RedisClient pass in the client.
      * @param {KeyvRedisOptions} [options] Options for the adapter such as namespace, keyPrefixSeparator, and clearBatchSize.
      */
-    constructor(connect?: string | RedisClientOptions | RedisClusterOptions | RedisClientConnectionType, options?: KeyvRedisOptions);
+    constructor(connect?: string | RedisClientOptions | RedisClusterOptions | RedisSentinelOptions | RedisClientConnectionType, options?: KeyvRedisOptions);
     /**
      * Get the Redis client.
      */
@@ -278,6 +279,11 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
      * @returns {boolean} - true if the client is a cluster, false if not
      */
     isCluster(): boolean;
+    /**
+     * Is the client a sentinel.
+     * @returns {boolean} - true if the client is a sentinel, false if not
+     */
+    isSentinel(): boolean;
     /**
      * Get the master nodes in the cluster. If not a cluster, it will return the single client.
      *
@@ -320,6 +326,7 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
      */
     private getSlotMap;
     private isClientCluster;
+    private isClientSentinel;
     private setOptions;
     private initClient;
     private createTimeoutPromise;
@@ -333,4 +340,4 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
 declare function createKeyv(connect?: string | RedisClientOptions | RedisClientType, options?: KeyvRedisOptions): Keyv;
 declare function createKeyvNonBlocking(connect?: string | RedisClientOptions | RedisClientType, options?: KeyvRedisOptions): Keyv;
 
-export { type KeyvRedisEntry, type KeyvRedisOptions, type KeyvRedisPropertyOptions, type RedisClientConnectionType, type RedisConnectionClientType, type RedisConnectionClusterType, RedisErrorMessages, createKeyv, createKeyvNonBlocking, KeyvRedis as default, defaultReconnectStrategy };
+export { type KeyvRedisEntry, type KeyvRedisOptions, type KeyvRedisPropertyOptions, type RedisClientConnectionType, type RedisConnectionClientType, type RedisConnectionClusterType, type RedisConnectionSentinelType, RedisErrorMessages, createKeyv, createKeyvNonBlocking, KeyvRedis as default, defaultReconnectStrategy };

package/dist/index.js

@@ -1,18 +1,18 @@
 // src/index.ts
 import {
   createClient,
-  createCluster
+  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
+  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;
@@ -45,11 +45,30 @@ 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) {
-        this._client = this.isClientCluster(connect) ? connect : connect;
+        if (this.isClientSentinel(connect)) {
+          this._client = connect;
+        } else if (this.isClientCluster(connect)) {
+          this._client = connect;
+        } else {
+          this._client = connect;
+        }
       } else if (connect instanceof Object) {
-        this._client = connect.rootNodes === void 0 ? createClient(connect) : createCluster(connect);
+        if (connect.sentinelRootNodes !== void 0) {
+          this._client = createSentinel(
+            connect
+          );
+        } else if (connect.rootNodes === void 0) {
+          this._client = createClient(
+            connect
+          );
+        } else {
+          this._client = createCluster(connect);
+        }
       }
     }
     this.setOptions(options);
@@ -327,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) {
@@ -473,6 +494,13 @@ var KeyvRedis = class extends Hookified {
   isCluster() {
     return this.isClientCluster(this._client);
   }
+  /**
+   * Is the client a sentinel.
+   * @returns {boolean} - true if the client is a sentinel, false if not
+   */
+  isSentinel() {
+    return this.isClientSentinel(this._client);
+  }
   /**
    * Get the master nodes in the cluster. If not a cluster, it will return the single client.
    *
@@ -481,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()];
@@ -497,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) {
@@ -524,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);
     }
@@ -558,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));
   }
   /**
@@ -574,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);
+        })
+      );
     }
   }
   /**
@@ -615,6 +660,9 @@ var KeyvRedis = class extends Hookified {
   isClientCluster(client) {
     return client.slots !== void 0;
   }
+  isClientSentinel(client) {
+    return client.getSentinelNode !== void 0;
+  }
   setOptions(options) {
     if (!options) {
       return;
@@ -656,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) {
@@ -672,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;
     }
@@ -713,6 +760,7 @@ export {
   createCluster2 as createCluster,
   createKeyv,
   createKeyvNonBlocking,
+  createSentinel2 as createSentinel,
   KeyvRedis as default,
   defaultReconnectStrategy
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyv/redis",
-  "version": "5.0.0",
+  "version": "5.1.1",
   "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.6.0",
+    "@redis/client": "^5.7.0",
     "cluster-key-slot": "^1.1.2",
-    "hookified": "^1.10.0"
+    "hookified": "^1.11.0"
   },
   "peerDependencies": {
-    "keyv": "^5.4.0"
+    "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.1.1",
-    "@keyv/test-suite": "^2.0.9"
+    "@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"
   }
 }