@keyv/redis 4.6.0 → 5.0.0

package/README.md

@@ -25,7 +25,11 @@ 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)
@@ -100,6 +104,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 +151,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 +188,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 +223,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 +241,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 +327,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:
 

package/dist/index.cjs

@@ -35,6 +35,7 @@ __export(index_exports, {
   createClient: () => import_client2.createClient,
   createCluster: () => import_client2.createCluster,
   createKeyv: () => createKeyv,
+  createKeyvNonBlocking: () => createKeyvNonBlocking,
   default: () => KeyvRedis,
   defaultReconnectStrategy: () => defaultReconnectStrategy
 });
@@ -62,7 +63,7 @@ var KeyvRedis = class extends import_hookified.Hookified {
   _useUnlink = true;
   _noNamespaceAffectsAll = false;
   _throwOnConnectError = true;
-  _throwErrors = false;
+  _throwOnErrors = false;
   _connectionTimeout;
   /**
    * KeyvRedis constructor.
@@ -118,7 +119,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 +221,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 +273,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 +298,7 @@ var KeyvRedis = class extends import_hookified.Hookified {
       }
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
     }
@@ -321,7 +322,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 +340,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 +360,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 +385,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 +406,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 +426,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 +458,7 @@ var KeyvRedis = class extends import_hookified.Hookified {
       }
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
     }
@@ -471,7 +472,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());
     }
   }
   /**
@@ -513,7 +514,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 +530,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 +567,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 +646,7 @@ 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;
   }
   setOptions(options) {
     if (!options) {
@@ -671,8 +670,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 +703,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 +746,6 @@ function createKeyv(connect, options) {
   createClient,
   createCluster,
   createKeyv,
+  createKeyvNonBlocking,
   defaultReconnectStrategy
 });

package/dist/index.d.cts

@@ -1,4 +1,4 @@
-import { RedisClientOptions, RedisClusterOptions, RedisClientType, RedisClusterType, RedisModules, RedisFunctions, RedisScripts } from '@redis/client';
+import { RedisClientOptions, RedisClusterOptions, RedisClientType, RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping, RedisClusterType } from '@redis/client';
 export { RedisClientOptions, RedisClientType, RedisClusterOptions, RedisClusterType, createClient, createCluster } from '@redis/client';
 import { Hookified } from 'hookified';
 import { KeyvStoreAdapter, KeyvEntry, 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,9 @@ 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 RedisClientConnectionType = RedisConnectionClientType | RedisConnectionClusterType;
 declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
     private _client;
     private _namespace;
@@ -87,7 +89,7 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
     private _useUnlink;
     private _noNamespaceAffectsAll;
     private _throwOnConnectError;
-    private _throwErrors;
+    private _throwOnErrors;
     private _connectionTimeout;
     /**
      * KeyvRedis constructor.
@@ -172,22 +174,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
@@ -329,5 +331,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, RedisErrorMessages, createKeyv, createKeyvNonBlocking, KeyvRedis as default, defaultReconnectStrategy };

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { RedisClientOptions, RedisClusterOptions, RedisClientType, RedisClusterType, RedisModules, RedisFunctions, RedisScripts } from '@redis/client';
+import { RedisClientOptions, RedisClusterOptions, RedisClientType, RedisModules, RedisFunctions, RedisScripts, RespVersions, TypeMapping, RedisClusterType } from '@redis/client';
 export { RedisClientOptions, RedisClientType, RedisClusterOptions, RedisClusterType, createClient, createCluster } from '@redis/client';
 import { Hookified } from 'hookified';
 import { KeyvStoreAdapter, KeyvEntry, 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,9 @@ 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 RedisClientConnectionType = RedisConnectionClientType | RedisConnectionClusterType;
 declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
     private _client;
     private _namespace;
@@ -87,7 +89,7 @@ declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
     private _useUnlink;
     private _noNamespaceAffectsAll;
     private _throwOnConnectError;
-    private _throwErrors;
+    private _throwOnErrors;
     private _connectionTimeout;
     /**
      * KeyvRedis constructor.
@@ -172,22 +174,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
@@ -329,5 +331,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, RedisErrorMessages, createKeyv, createKeyvNonBlocking, KeyvRedis as default, defaultReconnectStrategy };

package/dist/index.js

@@ -30,7 +30,7 @@ var KeyvRedis = class extends Hookified {
   _useUnlink = true;
   _noNamespaceAffectsAll = false;
   _throwOnConnectError = true;
-  _throwErrors = false;
+  _throwOnErrors = false;
   _connectionTimeout;
   /**
    * KeyvRedis constructor.
@@ -86,7 +86,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 +188,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 +240,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 +265,7 @@ var KeyvRedis = class extends Hookified {
       }
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
     }
@@ -289,7 +289,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 +307,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 +327,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 +352,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 +373,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 +393,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 +425,7 @@ var KeyvRedis = class extends Hookified {
       }
     } catch (error) {
       this.emit("error", error);
-      if (this._throwErrors) {
+      if (this._throwOnErrors) {
         throw error;
       }
     }
@@ -439,7 +439,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());
     }
   }
   /**
@@ -481,7 +481,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 +497,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 +534,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 +613,7 @@ 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;
   }
   setOptions(options) {
     if (!options) {
@@ -639,8 +637,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 +670,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 +712,7 @@ export {
   createClient2 as createClient,
   createCluster2 as createCluster,
   createKeyv,
+  createKeyvNonBlocking,
   KeyvRedis as default,
   defaultReconnectStrategy
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyv/redis",
-  "version": "4.6.0",
+  "version": "5.0.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.6.0",
     "cluster-key-slot": "^1.1.2",
     "hookified": "^1.10.0"
   },
   "peerDependencies": {
-    "keyv": "^5.3.4"
+    "keyv": "^5.4.0"
   },
   "devDependencies": {
     "@faker-js/faker": "^9.9.0",
@@ -49,7 +49,7 @@
     "tsd": "^0.32.0",
     "vitest": "^3.2.4",
     "xo": "^1.1.1",
-    "@keyv/test-suite": "^2.0.8"
+    "@keyv/test-suite": "^2.0.9"
   },
   "tsd": {
     "directory": "test"