@keyv/redis 4.6.0 → 5.1.0

package/README.md

@@ -25,17 +25,24 @@ Redis storage adapter for [Keyv](https://github.com/jaredwray/keyv).
 
 # Table of Contents
 * [Usage](#usage)
+* [Migrating from v4 to v5](#migrating-from-v4-to-v5)
+* [Using the createKeyv function](#using-the-createkeyv-function)
+* [Using the createKeyvNonBlocking function](#using-the-createkeyvnonblocking-function)
 * [Namespaces](#namespaces)
+* [Fixing Double Prefixing of Keys](#fixing-double-prefixing-of-keys)
 * [Using Generic Types](#using-generic-types)
 * [Performance Considerations](#performance-considerations)
 * [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)
 * [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
@@ -100,6 +107,10 @@ const keyvRedis = new KeyvRedis(redis);
 const keyv = new Keyv({ store: keyvRedis});
 ```
 
+# Migrating from v4 to v5
+
+The major change from v4 to v5 is that we are now using v5 of the `@redis/client` library which has a new API. This means that some methods have changed but it should be a drop-in replacement for most use cases.
+
 # Keyv Redis Options
 
 You can pass in options to the `KeyvRedis` constructor. Here are the available options:
@@ -143,7 +154,7 @@ export type KeyvRedisOptions = {
 	 * and returns no-op responses.
 	 * @default false
 	 */
-	throwErrors?: boolean;
+	throwOnErrors?: boolean;
 
 	/**
 	 * Timeout in milliseconds for the connection. Default is undefined, which uses the default timeout of the Redis client.
@@ -180,6 +191,30 @@ const keyv = createKeyv('redis://user:pass@localhost:6379');
 keyv.store.namespace = 'my-namespace';
 ```
 
+# Using the `createKeyv` function
+
+The `createKeyv` function is a convenience function that creates a new `Keyv` instance with the `@keyv/redis` store. It automatically sets the `useKeyPrefix` option to `false`. Here is an example of how to use it:
+
+```js
+import { createKeyv } from '@keyv/redis';
+const keyv = createKeyv('redis://user:pass@localhost:6379');
+```
+
+To use a namespace you can do it here and this will set Keyv up correctly to avoid the double namespace issue:
+
+```js
+import { createKeyv } from '@keyv/redis';
+const keyv = createKeyv('redis://user:pass@localhost:6379', {namespace: 'my-namespace'});
+```
+
+# Using the `createKeyvNonBlocking` function
+
+The `createKeyvNonBlocking` function is a convenience function that creates a new `Keyv` instance with the `@keyv/redis` store does what `createKeyv` does but also disables throwing errors, removes the offline queue redis functionality, and reconnect strategy so that when used as a secondary cache in libraries such as [cacheable](https://npmjs.org/package/cacheable) it does not block the primary cache. This is useful when you want to use Redis as a secondary cache and do not want to block the primary cache on connection errors or timeouts when using `nonBlocking`. Here is an example of how to use it:
+
+```js
+import { createKeyvNonBlocking } from '@keyv/redis';
+const keyv = createKeyvNonBlocking('redis://user:pass@localhost:6379');
+```
 
 # Namespaces
 
@@ -191,10 +226,17 @@ import KeyvRedis, { createClient } from '@keyv/redis';
 
 const redis = createClient('redis://user:pass@localhost:6379');
 const keyvRedis = new KeyvRedis(redis);
-const keyv = new Keyv({ store: keyvRedis, namespace: 'my-namespace' });
+const keyv = new Keyv({ store: keyvRedis, namespace: 'my-namespace', useKeyPrefix: false });
+```
+
+To make this easier, you can use the `createKeyv` function which will automatically set the `namespace` option to the `KeyvRedis` instance:
+
+```js
+import { createKeyv } from '@keyv/redis';
+const keyv = createKeyv('redis://user:pass@localhost:6379', { namespace: 'my-namespace' });
 ```
 
-This will prefix all keys with `my-namespace:`. You can also set the namespace after the fact:
+This will prefix all keys with `my-namespace:` and will also set `useKeyPrefix` to `false`. This is done to avoid double prefixing of keys as we transition out of the legacy behavior in Keyv. You can also set the namespace after the fact:
 
 ```js
 keyv.namespace = 'my-namespace';
@@ -202,6 +244,24 @@ keyv.namespace = 'my-namespace';
 
 NOTE: If you plan to do many clears or deletes, it is recommended to read the [Performance Considerations](#performance-considerations) section.
 
+# Fixing Double Prefixing of Keys
+
+If you are using `Keyv` with `@keyv/redis` as the storage adapter, you may notice that keys are being prefixed twice. This is because `Keyv` has a default prefixing behavior that is applied to all keys. To fix this, you can set the `useKeyPrefix` option to `false` when creating the `Keyv` instance:
+
+```js
+import Keyv from 'keyv';
+import KeyvRedis from '@keyv/redis';
+
+const keyv = new Keyv(new KeyvRedis('redis://user:pass@localhost:6379'), { useKeyPrefix: false });
+```
+
+To make this easier, you can use the `createKeyv` function which will automatically set the `useKeyPrefix` option to `false`:
+
+```js
+import { createKeyv } from '@keyv/redis';
+const keyv = createKeyv('redis://user:pass@localhost:6379');
+```
+
 ## Using Generic Types
 
 When initializing `KeyvRedis`, you can specify the type of the values you are storing and you can also specify types when calling methods:
@@ -270,11 +330,21 @@ keyv.on('error', (error) => {
 });
 ```
 
-By default, the `KeyvRedis` instance will `throw an error` if the connection fails to connect. You can disable this behavior by setting the `throwOnConnectError` option to `false` when creating the `KeyvRedis` instance:
+By default, the `KeyvRedis` instance will `throw an error` if the connection fails to connect. You can disable this behavior by setting the `throwOnConnectError` option to `false` when creating the `KeyvRedis` instance. If you want this to throw you will need to also set the Keyv instance to `throwOnErrors: true`:
+
+```js
+import Keyv from 'keyv';
+import KeyvRedis from '@keyv/redis';
+
+const keyv = new Keyv(new KeyvRedis('redis://bad-uri:1111', { throwOnConnectError: false }));
+keyv.throwOnErrors = true; // This will throw an error if the connection fails
+
+await keyv.set('key', 'value'); // this will throw the connection error only.
+```
 
 On `get`, `getMany`, `set`, `setMany`, `delete`, and `deleteMany`, if the connection is lost, it will emit an error and return a no-op value. You can catch this error and handle it accordingly. This is important to ensure that your application does not crash due to a lost connection to Redis.
 
-If you want to handle connection errors, retries, and timeouts more gracefully, you can use the `throwErrors` option. This will throw an error if any operation fails, allowing you to catch it and handle it accordingly:
+If you want to handle connection errors, retries, and timeouts more gracefully, you can use the `throwOnErrors` option. This will throw an error if any operation fails, allowing you to catch it and handle it accordingly:
 
 There is a default `Reconnect Strategy` if you pass in just a `uri` connection string we will automatically create a Redis client for you with the following reconnect strategy:
 
@@ -312,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';
@@ -337,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.
+
+# 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:
+Here is an example of how to use TLS using the `redisOptions`:
 
 ```js
 import Keyv from 'keyv';
@@ -433,6 +536,165 @@ This will make it so the storage adapter `@keyv/redis` will handle the namespace
 
 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

@@ -35,6 +35,8 @@ __export(index_exports, {
   createClient: () => import_client2.createClient,
   createCluster: () => import_client2.createCluster,
   createKeyv: () => createKeyv,
+  createKeyvNonBlocking: () => createKeyvNonBlocking,
+  createSentinel: () => import_client2.createSentinel,
   default: () => KeyvRedis,
   defaultReconnectStrategy: () => defaultReconnectStrategy
 });
@@ -62,7 +64,7 @@ var KeyvRedis = class extends import_hookified.Hookified {
   _useUnlink = true;
   _noNamespaceAffectsAll = false;
   _throwOnConnectError = true;
-  _throwErrors = false;
+  _throwOnErrors = false;
   _connectionTimeout;
   /**
    * KeyvRedis constructor.
@@ -79,9 +81,21 @@ var KeyvRedis = class extends import_hookified.Hookified {
       if (typeof connect === "string") {
         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);
@@ -118,7 +132,7 @@ var KeyvRedis = class extends import_hookified.Hookified {
       noNamespaceAffectsAll: this._noNamespaceAffectsAll,
       useUnlink: this._useUnlink,
       throwOnConnectError: this._throwOnConnectError,
-      throwErrors: this._throwErrors,
+      throwOnErrors: this._throwOnErrors,
       connectionTimeout: this._connectionTimeout,
       dialect: "redis",
       url
@@ -220,25 +234,25 @@ var KeyvRedis = class extends import_hookified.Hookified {
     this._throwOnConnectError = value;
   }
   /**
-   * Get if throwErrors is set to true.
+   * Get if throwOnErrors is set to true.
    * 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
    */
-  get throwErrors() {
-    return this._throwErrors;
+  get throwOnErrors() {
+    return this._throwOnErrors;
   }
   /**
-   * Set if throwErrors is set to true.
+   * Set if throwOnErrors is set to true.
    * 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.
    */
-  set throwErrors(value) {
-    this._throwErrors = value;
+  set throwOnErrors(value) {
+    this._throwOnErrors = value;
   }
   /**
    * Get the connection timeout in milliseconds such as 5000 (5 seconds). Default is undefined. If undefined, it will use the default.
@@ -272,10 +286,10 @@ var KeyvRedis = class extends import_hookified.Hookified {
       }
     } catch (error) {
       this.emit("error", error);
+      await this.disconnect(true);
       if (this._throwOnConnectError) {
         throw new Error("Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true." /* RedisClientNotConnectedThrown */);
       }
-      await this.disconnect(true);
     }
     this.initClient();
     return this._client;
@@ -297,7 +311,7 @@ var KeyvRedis = class extends import_hookified.Hookified {
       }
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
     }
@@ -321,7 +335,7 @@ var KeyvRedis = class extends import_hookified.Hookified {
       await multi.exec();
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
     }
@@ -339,7 +353,7 @@ var KeyvRedis = class extends import_hookified.Hookified {
       return exists === 1;
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
       return false;
@@ -359,10 +373,10 @@ var KeyvRedis = class extends import_hookified.Hookified {
         multi.exists(prefixedKey);
       }
       const results = await multi.exec();
-      return results.map((result) => result === 1);
+      return results.map((result) => typeof result === "number" && result === 1);
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
       return Array.from({ length: keys.length }).fill(false);
@@ -384,7 +398,7 @@ var KeyvRedis = class extends import_hookified.Hookified {
       return value;
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
       return void 0;
@@ -405,7 +419,7 @@ var KeyvRedis = class extends import_hookified.Hookified {
       return values;
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
       return Array.from({ length: keys.length }).fill(void 0);
@@ -425,7 +439,7 @@ var KeyvRedis = class extends import_hookified.Hookified {
       return deleted > 0;
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
       return false;
@@ -457,7 +471,7 @@ var KeyvRedis = class extends import_hookified.Hookified {
       }
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
     }
@@ -471,7 +485,7 @@ var KeyvRedis = class extends import_hookified.Hookified {
    */
   async disconnect(force) {
     if (this._client.isOpen) {
-      await (force ? this._client.disconnect() : this._client.quit());
+      await (force ? this._client.destroy() : this._client.close());
     }
   }
   /**
@@ -505,6 +519,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.
    *
@@ -513,7 +534,8 @@ var KeyvRedis = class extends import_hookified.Hookified {
   async getMasterNodes() {
     if (this.isCluster()) {
       const cluster = await this.getClient();
-      return Promise.all(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()];
   }
@@ -528,7 +550,7 @@ var KeyvRedis = class extends import_hookified.Hookified {
       const match = namespace ? `${namespace}${this._keyPrefixSeparator}*` : "*";
       let cursor = "0";
       do {
-        const result = await client.scan(Number.parseInt(cursor, 10), { 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) {
@@ -565,7 +587,7 @@ var KeyvRedis = class extends import_hookified.Hookified {
         const match = this._namespace ? `${this._namespace}${this._keyPrefixSeparator}*` : "*";
         const deletePromises = [];
         do {
-          const result = await client.scan(Number.parseInt(cursor, 10), { MATCH: match, COUNT: batchSize, TYPE: "string" });
+          const result = await client.scan(cursor, { MATCH: match, COUNT: batchSize, TYPE: "string" });
           cursor = result.cursor.toString();
           let { keys } = result;
           if (keys.length === 0) {
@@ -644,10 +666,10 @@ var KeyvRedis = class extends import_hookified.Hookified {
     return slotMap;
   }
   isClientCluster(client) {
-    if (client.options === void 0 && client.scan === void 0) {
-      return true;
-    }
-    return false;
+    return client.slots !== void 0;
+  }
+  isClientSentinel(client) {
+    return client.getSentinelNode !== void 0;
   }
   setOptions(options) {
     if (!options) {
@@ -671,8 +693,8 @@ var KeyvRedis = class extends import_hookified.Hookified {
     if (options.throwOnConnectError !== void 0) {
       this._throwOnConnectError = options.throwOnConnectError;
     }
-    if (options.throwErrors !== void 0) {
-      this._throwErrors = options.throwErrors;
+    if (options.throwOnErrors !== void 0) {
+      this._throwOnErrors = options.throwOnErrors;
     }
     if (options.connectionTimeout !== void 0) {
       this._connectionTimeout = options.connectionTimeout;
@@ -704,7 +726,40 @@ var KeyvRedis = class extends import_hookified.Hookified {
 function createKeyv(connect, options) {
   connect ??= "redis://localhost:6379";
   const adapter = new KeyvRedis(connect, options);
-  const keyv = new import_keyv.Keyv(adapter, { namespace: options?.namespace, useKeyPrefix: false });
+  if (options?.namespace) {
+    adapter.namespace = options.namespace;
+    const keyv2 = new import_keyv.Keyv(adapter, { namespace: options?.namespace, useKeyPrefix: false });
+    if (options?.throwOnConnectError) {
+      keyv2.throwOnErrors = true;
+    }
+    if (options?.throwOnErrors) {
+      keyv2.throwOnErrors = true;
+    }
+    return keyv2;
+  }
+  const keyv = new import_keyv.Keyv(adapter, { useKeyPrefix: false });
+  if (options?.throwOnConnectError) {
+    keyv.throwOnErrors = true;
+  }
+  if (options?.throwOnErrors) {
+    keyv.throwOnErrors = true;
+  }
+  keyv.namespace = void 0;
+  return keyv;
+}
+function createKeyvNonBlocking(connect, options) {
+  const keyv = createKeyv(connect, options);
+  const keyvStore = keyv.store;
+  keyvStore.throwOnConnectError = false;
+  keyvStore.throwOnErrors = false;
+  const redisClient = keyvStore.client;
+  if (redisClient.options) {
+    redisClient.options.disableOfflineQueue = true;
+    if (redisClient.options.socket) {
+      redisClient.options.socket.reconnectStrategy = false;
+    }
+  }
+  keyv.throwOnErrors = false;
   return keyv;
 }
 // Annotate the CommonJS export names for ESM import in node:
@@ -714,5 +769,7 @@ function createKeyv(connect, options) {
   createClient,
   createCluster,
   createKeyv,
+  createKeyvNonBlocking,
+  createSentinel,
   defaultReconnectStrategy
 });

package/dist/index.d.cts

@@ -1,5 +1,5 @@
-import { RedisClientOptions, RedisClusterOptions, RedisClientType, RedisClusterType, RedisModules, RedisFunctions, RedisScripts } 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';
@@ -39,7 +39,7 @@ type KeyvRedisOptions = {
      * and returns no-op responses.
      * @default false
      */
-    throwErrors?: boolean;
+    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.
@@ -78,7 +78,10 @@ declare enum RedisErrorMessages {
     RedisClientNotConnectedThrown = "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true."
 }
 declare const defaultReconnectStrategy: (attempts: number) => number | Error;
-type RedisClientConnectionType = RedisClientType | RedisClusterType<RedisModules, RedisFunctions, RedisScripts>;
+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 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;
@@ -87,14 +90,14 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
     private _useUnlink;
     private _noNamespaceAffectsAll;
     private _throwOnConnectError;
-    private _throwErrors;
+    private _throwOnErrors;
     private _connectionTimeout;
     /**
      * KeyvRedis constructor.
      * @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.
      */
@@ -172,22 +175,22 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
      */
     set throwOnConnectError(value: boolean);
     /**
-     * Get if throwErrors is set to true.
+     * Get if throwOnErrors is set to true.
      * 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
      */
-    get throwErrors(): boolean;
+    get throwOnErrors(): boolean;
     /**
-     * Set if throwErrors is set to true.
+     * Set if throwOnErrors is set to true.
      * 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.
      */
-    set throwErrors(value: boolean);
+    set throwOnErrors(value: boolean);
     /**
      * Get the connection timeout in milliseconds such as 5000 (5 seconds). Default is undefined. If undefined, it will use the default.
      * @default undefined
@@ -276,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.
      *
@@ -318,6 +326,7 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
      */
     private getSlotMap;
     private isClientCluster;
+    private isClientSentinel;
     private setOptions;
     private initClient;
     private createTimeoutPromise;
@@ -329,5 +338,6 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
  * @returns {Keyv} - Keyv instance with the Redis adapter
  */
 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, RedisErrorMessages, createKeyv, 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, RedisClusterType, RedisModules, RedisFunctions, RedisScripts } 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';
@@ -39,7 +39,7 @@ type KeyvRedisOptions = {
      * and returns no-op responses.
      * @default false
      */
-    throwErrors?: boolean;
+    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.
@@ -78,7 +78,10 @@ declare enum RedisErrorMessages {
     RedisClientNotConnectedThrown = "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true."
 }
 declare const defaultReconnectStrategy: (attempts: number) => number | Error;
-type RedisClientConnectionType = RedisClientType | RedisClusterType<RedisModules, RedisFunctions, RedisScripts>;
+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 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;
@@ -87,14 +90,14 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
     private _useUnlink;
     private _noNamespaceAffectsAll;
     private _throwOnConnectError;
-    private _throwErrors;
+    private _throwOnErrors;
     private _connectionTimeout;
     /**
      * KeyvRedis constructor.
      * @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.
      */
@@ -172,22 +175,22 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
      */
     set throwOnConnectError(value: boolean);
     /**
-     * Get if throwErrors is set to true.
+     * Get if throwOnErrors is set to true.
      * 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
      */
-    get throwErrors(): boolean;
+    get throwOnErrors(): boolean;
     /**
-     * Set if throwErrors is set to true.
+     * Set if throwOnErrors is set to true.
      * 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.
      */
-    set throwErrors(value: boolean);
+    set throwOnErrors(value: boolean);
     /**
      * Get the connection timeout in milliseconds such as 5000 (5 seconds). Default is undefined. If undefined, it will use the default.
      * @default undefined
@@ -276,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.
      *
@@ -318,6 +326,7 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
      */
     private getSlotMap;
     private isClientCluster;
+    private isClientSentinel;
     private setOptions;
     private initClient;
     private createTimeoutPromise;
@@ -329,5 +338,6 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
  * @returns {Keyv} - Keyv instance with the Redis adapter
  */
 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, RedisErrorMessages, createKeyv, 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,14 +1,16 @@
 // src/index.ts
 import {
   createClient,
-  createCluster
+  createCluster,
+  createSentinel
 } from "@redis/client";
 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
@@ -30,7 +32,7 @@ var KeyvRedis = class extends Hookified {
   _useUnlink = true;
   _noNamespaceAffectsAll = false;
   _throwOnConnectError = true;
-  _throwErrors = false;
+  _throwOnErrors = false;
   _connectionTimeout;
   /**
    * KeyvRedis constructor.
@@ -47,9 +49,21 @@ var KeyvRedis = class extends Hookified {
       if (typeof connect === "string") {
         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);
@@ -86,7 +100,7 @@ var KeyvRedis = class extends Hookified {
       noNamespaceAffectsAll: this._noNamespaceAffectsAll,
       useUnlink: this._useUnlink,
       throwOnConnectError: this._throwOnConnectError,
-      throwErrors: this._throwErrors,
+      throwOnErrors: this._throwOnErrors,
       connectionTimeout: this._connectionTimeout,
       dialect: "redis",
       url
@@ -188,25 +202,25 @@ var KeyvRedis = class extends Hookified {
     this._throwOnConnectError = value;
   }
   /**
-   * Get if throwErrors is set to true.
+   * Get if throwOnErrors is set to true.
    * 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
    */
-  get throwErrors() {
-    return this._throwErrors;
+  get throwOnErrors() {
+    return this._throwOnErrors;
   }
   /**
-   * Set if throwErrors is set to true.
+   * Set if throwOnErrors is set to true.
    * 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.
    */
-  set throwErrors(value) {
-    this._throwErrors = value;
+  set throwOnErrors(value) {
+    this._throwOnErrors = value;
   }
   /**
    * Get the connection timeout in milliseconds such as 5000 (5 seconds). Default is undefined. If undefined, it will use the default.
@@ -240,10 +254,10 @@ var KeyvRedis = class extends Hookified {
       }
     } catch (error) {
       this.emit("error", error);
+      await this.disconnect(true);
       if (this._throwOnConnectError) {
         throw new Error("Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true." /* RedisClientNotConnectedThrown */);
       }
-      await this.disconnect(true);
     }
     this.initClient();
     return this._client;
@@ -265,7 +279,7 @@ var KeyvRedis = class extends Hookified {
       }
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
     }
@@ -289,7 +303,7 @@ var KeyvRedis = class extends Hookified {
       await multi.exec();
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
     }
@@ -307,7 +321,7 @@ var KeyvRedis = class extends Hookified {
       return exists === 1;
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
       return false;
@@ -327,10 +341,10 @@ var KeyvRedis = class extends Hookified {
         multi.exists(prefixedKey);
       }
       const results = await multi.exec();
-      return results.map((result) => result === 1);
+      return results.map((result) => typeof result === "number" && result === 1);
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
       return Array.from({ length: keys.length }).fill(false);
@@ -352,7 +366,7 @@ var KeyvRedis = class extends Hookified {
       return value;
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
       return void 0;
@@ -373,7 +387,7 @@ var KeyvRedis = class extends Hookified {
       return values;
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
       return Array.from({ length: keys.length }).fill(void 0);
@@ -393,7 +407,7 @@ var KeyvRedis = class extends Hookified {
       return deleted > 0;
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
       return false;
@@ -425,7 +439,7 @@ var KeyvRedis = class extends Hookified {
       }
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
     }
@@ -439,7 +453,7 @@ var KeyvRedis = class extends Hookified {
    */
   async disconnect(force) {
     if (this._client.isOpen) {
-      await (force ? this._client.disconnect() : this._client.quit());
+      await (force ? this._client.destroy() : this._client.close());
     }
   }
   /**
@@ -473,6 +487,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 +502,8 @@ var KeyvRedis = class extends Hookified {
   async getMasterNodes() {
     if (this.isCluster()) {
       const cluster = await this.getClient();
-      return Promise.all(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()];
   }
@@ -496,7 +518,7 @@ var KeyvRedis = class extends Hookified {
       const match = namespace ? `${namespace}${this._keyPrefixSeparator}*` : "*";
       let cursor = "0";
       do {
-        const result = await client.scan(Number.parseInt(cursor, 10), { 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) {
@@ -533,7 +555,7 @@ var KeyvRedis = class extends Hookified {
         const match = this._namespace ? `${this._namespace}${this._keyPrefixSeparator}*` : "*";
         const deletePromises = [];
         do {
-          const result = await client.scan(Number.parseInt(cursor, 10), { MATCH: match, COUNT: batchSize, TYPE: "string" });
+          const result = await client.scan(cursor, { MATCH: match, COUNT: batchSize, TYPE: "string" });
           cursor = result.cursor.toString();
           let { keys } = result;
           if (keys.length === 0) {
@@ -612,10 +634,10 @@ var KeyvRedis = class extends Hookified {
     return slotMap;
   }
   isClientCluster(client) {
-    if (client.options === void 0 && client.scan === void 0) {
-      return true;
-    }
-    return false;
+    return client.slots !== void 0;
+  }
+  isClientSentinel(client) {
+    return client.getSentinelNode !== void 0;
   }
   setOptions(options) {
     if (!options) {
@@ -639,8 +661,8 @@ var KeyvRedis = class extends Hookified {
     if (options.throwOnConnectError !== void 0) {
       this._throwOnConnectError = options.throwOnConnectError;
     }
-    if (options.throwErrors !== void 0) {
-      this._throwErrors = options.throwErrors;
+    if (options.throwOnErrors !== void 0) {
+      this._throwOnErrors = options.throwOnErrors;
     }
     if (options.connectionTimeout !== void 0) {
       this._connectionTimeout = options.connectionTimeout;
@@ -672,7 +694,40 @@ var KeyvRedis = class extends Hookified {
 function createKeyv(connect, options) {
   connect ??= "redis://localhost:6379";
   const adapter = new KeyvRedis(connect, options);
-  const keyv = new Keyv(adapter, { namespace: options?.namespace, useKeyPrefix: false });
+  if (options?.namespace) {
+    adapter.namespace = options.namespace;
+    const keyv2 = new Keyv(adapter, { namespace: options?.namespace, useKeyPrefix: false });
+    if (options?.throwOnConnectError) {
+      keyv2.throwOnErrors = true;
+    }
+    if (options?.throwOnErrors) {
+      keyv2.throwOnErrors = true;
+    }
+    return keyv2;
+  }
+  const keyv = new Keyv(adapter, { useKeyPrefix: false });
+  if (options?.throwOnConnectError) {
+    keyv.throwOnErrors = true;
+  }
+  if (options?.throwOnErrors) {
+    keyv.throwOnErrors = true;
+  }
+  keyv.namespace = void 0;
+  return keyv;
+}
+function createKeyvNonBlocking(connect, options) {
+  const keyv = createKeyv(connect, options);
+  const keyvStore = keyv.store;
+  keyvStore.throwOnConnectError = false;
+  keyvStore.throwOnErrors = false;
+  const redisClient = keyvStore.client;
+  if (redisClient.options) {
+    redisClient.options.disableOfflineQueue = true;
+    if (redisClient.options.socket) {
+      redisClient.options.socket.reconnectStrategy = false;
+    }
+  }
+  keyv.throwOnErrors = false;
   return keyv;
 }
 export {
@@ -681,6 +736,8 @@ export {
   createClient2 as createClient,
   createCluster2 as createCluster,
   createKeyv,
+  createKeyvNonBlocking,
+  createSentinel2 as createSentinel,
   KeyvRedis as default,
   defaultReconnectStrategy
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyv/redis",
-  "version": "4.6.0",
+  "version": "5.1.0",
   "description": "Redis storage adapter for Keyv",
   "type": "module",
   "main": "dist/index.cjs",
@@ -34,12 +34,12 @@
   },
   "homepage": "https://github.com/jaredwray/keyv",
   "dependencies": {
-    "@redis/client": "^1.6.0",
+    "@redis/client": "^5.7.0",
     "cluster-key-slot": "^1.1.2",
-    "hookified": "^1.10.0"
+    "hookified": "^1.11.0"
   },
   "peerDependencies": {
-    "keyv": "^5.3.4"
+    "keyv": "^5.5.0"
   },
   "devDependencies": {
     "@faker-js/faker": "^9.9.0",
@@ -48,8 +48,8 @@
     "timekeeper": "^2.3.1",
     "tsd": "^0.32.0",
     "vitest": "^3.2.4",
-    "xo": "^1.1.1",
-    "@keyv/test-suite": "^2.0.8"
+    "xo": "^1.2.1",
+    "@keyv/test-suite": "^2.1.0"
   },
   "tsd": {
     "directory": "test"