@keyv/redis 4.4.1 → 4.5.0

package/README.md

@@ -26,9 +26,10 @@ Redis storage adapter for [Keyv](https://github.com/jaredwray/keyv).
 # Table of Contents
 * [Usage](#usage)
 * [Namespaces](#namespaces)
-* [Typescript](#typescript)
+* [Using Generic Types](#using-generic-types)
 * [Performance Considerations](#performance-considerations)
 * [High Memory Usage on Redis Server](#high-memory-usage-on-redis-server)
+* [Gracefully Handling Connection Errors, Retries, and Timeouts](#gracefully-handling-connection-errors-retries-and-timeouts)
 * [Using Cacheable with Redis](#using-cacheable-with-redis)
 * [Clustering and TLS Support](#clustering-and-tls-support)
 * [API](#api)
@@ -99,6 +100,71 @@ const keyvRedis = new KeyvRedis(redis);
 const keyv = new Keyv({ store: keyvRedis});
 ```
 
+# Keyv Redis Options
+
+You can pass in options to the `KeyvRedis` constructor. Here are the available options:
+
+```typescript
+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;
+
+	/**
+	 * Timeout for connecting to Redis in milliseconds. This is used to prevent hanging indefinitely when connecting to Redis.
+	 * Defaults to `200`.
+	 */
+	connectTimeout?: number;
+};
+```
+You can pass these options when creating a new `KeyvRedis` instance:
+
+```js
+import Keyv from 'keyv';
+import KeyvRedis from '@keyv/redis';
+
+const keyvRedis = new KeyvRedis({
+  namespace: 'my-namespace',
+  keyPrefixSeparator: ':',
+  clearBatchSize: 1000,
+  useUnlink: true,
+  noNamespaceAffectsAll: false,
+  connectTimeout: 200
+});
+
+const keyv = new Keyv({ store: keyvRedis });
+```
+
+You can also set these options after the fact by using the `KeyvRedis` instance properties:
+
+```js
+import {createKeyv} from '@keyv/redis';
+
+const keyv = createKeyv('redis://user:pass@localhost:6379');
+keyv.store.namespace = 'my-namespace';
+```
+
+
 # Namespaces
 
 You can set a namespace for your keys. This is useful if you want to manage your keys in a more organized way. Here is an example of how to set a `namespace` with the `store` option:
@@ -120,7 +186,7 @@ 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.
 
-## Typescript
+## 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:
 
@@ -129,7 +195,7 @@ import Keyv from 'keyv';
 import KeyvRedis, { createClient } from '@keyv/redis';
 
 
-interface User {
+type User {
   id: number
   name: string
 }
@@ -175,6 +241,38 @@ const keyv = new Keyv(new KeyvRedis('redis://user:pass@localhost:6379', { useUnl
 keyv.useUnlink = false;
 ```
 
+# Gracefully Handling Connection Errors, Retries, and Timeouts
+
+When using `@keyv/redis`, it is important to handle connection errors gracefully. You can do this by listening to the `error` event on the `KeyvRedis` instance. Here is an example of how to do that:
+
+```js
+import Keyv from 'keyv';
+import KeyvRedis from '@keyv/redis';
+const keyv = new Keyv(new KeyvRedis('redis://user:pass@localhost:6379'));
+keyv.on('error', (error) => {
+  console.error('error', error);
+});
+```
+
+We also attempt to connect to Redis and have a `connectTimeout` option that defaults to `200ms`. If the connection is not established within this time, it will emit an error. You can catch this error and handle it accordingly.
+
+On `get`, `getMany`, `set`, `setMany`, `delete`, `deleteMany`, and `clear` methods, 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 pass in just a `uri` connection string we will automatically create a Redis client for you with the following reconnect strategy:
+
+```typescript
+export const defaultReconnectStrategy = (attempts: number): number | Error => {
+	// Exponential backoff base: double each time, capped at 2s.
+	// Parentheses make it clear we do (2 ** attempts) first, then * 100
+	const backoff = Math.min((2 ** attempts) * 100, 2000);
+
+	// Add random jitter of up to ±50ms to avoid thundering herds:
+	const jitter = (Math.random() - 0.5) * 100;
+
+	return backoff + jitter;
+};
+```
+
 # Using Cacheable with Redis
 
 If you are wanting to see even better performance with Redis, you can use [Cacheable](https://npmjs.org/package/cacheable) which is a multi-layered cache library that has in-memory primary caching and non-blocking secondary caching. Here is an example of how to use it with Redis:

package/dist/index.cjs

@@ -31,10 +31,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   Keyv: () => import_keyv2.Keyv,
+  RedisErrorMessages: () => RedisErrorMessages,
   createClient: () => import_client2.createClient,
   createCluster: () => import_client2.createCluster,
   createKeyv: () => createKeyv,
-  default: () => KeyvRedis
+  default: () => KeyvRedis,
+  defaultReconnectStrategy: () => defaultReconnectStrategy
 });
 module.exports = __toCommonJS(index_exports);
 var import_node_events = __toESM(require("events"), 1);
@@ -43,6 +45,15 @@ 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) => {
+  RedisErrorMessages2["RedisClientNotConnected"] = "Redis client is not connected or has failed to connect";
+  return RedisErrorMessages2;
+})(RedisErrorMessages || {});
+var defaultReconnectStrategy = (attempts) => {
+  const backoff = Math.min(2 ** attempts * 100, 2e3);
+  const jitter = (Math.random() - 0.5) * 100;
+  return backoff + jitter;
+};
 var KeyvRedis = class extends import_node_events.default {
   _client = (0, import_client.createClient)();
   _namespace;
@@ -50,6 +61,10 @@ var KeyvRedis = class extends import_node_events.default {
   _clearBatchSize = 1e3;
   _useUnlink = true;
   _noNamespaceAffectsAll = false;
+  _connectTimeout = 200;
+  // Timeout for connecting to Redis in milliseconds
+  _reconnectClient = false;
+  // Whether to reconnect the client
   /**
    * 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.
@@ -57,9 +72,12 @@ var KeyvRedis = class extends import_node_events.default {
    */
   constructor(connect, options) {
     super();
+    const socket = {
+      reconnectStrategy: defaultReconnectStrategy
+    };
     if (connect) {
       if (typeof connect === "string") {
-        this._client = (0, import_client.createClient)({ url: connect });
+        this._client = (0, import_client.createClient)({ url: connect, socket });
       } else if (connect.connect !== void 0) {
         this._client = this.isClientCluster(connect) ? connect : connect;
       } else if (connect instanceof Object) {
@@ -180,18 +198,50 @@ var KeyvRedis = class extends import_node_events.default {
   set noNamespaceAffectsAll(value) {
     this._noNamespaceAffectsAll = value;
   }
+  /**
+   * Get the timeout for connecting to Redis in milliseconds. This is used to prevent hanging indefinitely when connecting to Redis.
+   * @default 200
+   */
+  get connectTimeout() {
+    return this._connectTimeout;
+  }
+  /**
+   * Set the timeout for connecting to Redis in milliseconds. This is used to prevent hanging indefinitely when connecting to Redis.
+   * @default 200
+   */
+  set connectTimeout(value) {
+    if (value > 0) {
+      this._connectTimeout = value;
+      this._reconnectClient = true;
+    } else {
+      this.emit("error", "connectTimeout must be greater than 0");
+    }
+  }
   /**
    * Get the Redis URL used to connect to the server. This is used to get a connected client.
    */
   async getClient() {
+    if (this._client.isOpen && !this._reconnectClient) {
+      return this._client;
+    }
+    if (this._reconnectClient && this._client.isOpen) {
+      await this._client.disconnect();
+    }
     try {
-      if (!this._client.isOpen) {
-        await this._client.connect();
-      }
+      const timeoutPromise = new Promise((resolves, reject) => setTimeout(() => {
+        reject(new Error("Redis client is not connected or has failed to connect" /* RedisClientNotConnected */));
+      }, this._connectTimeout));
+      await Promise.race([
+        this._client.connect(),
+        timeoutPromise
+      ]);
+      this._reconnectClient = false;
+      this.initClient();
+      return this._client;
     } catch (error) {
       this.emit("error", error);
+      return void 0;
     }
-    return this._client;
   }
   /**
    * Set a key value pair in the store. TTL is in milliseconds.
@@ -201,6 +251,10 @@ var KeyvRedis = class extends import_node_events.default {
    */
   async set(key, value, ttl) {
     const client = await this.getClient();
+    if (!client) {
+      this.emit("error", new Error("Redis client is not connected or has failed to connect" /* RedisClientNotConnected */));
+      return;
+    }
     key = this.createKeyPrefix(key, this._namespace);
     if (ttl) {
       await client.set(key, value, { PX: ttl });
@@ -214,6 +268,10 @@ var KeyvRedis = class extends import_node_events.default {
    */
   async setMany(entries) {
     const client = await this.getClient();
+    if (!client) {
+      this.emit("error", new Error("Redis client is not connected or has failed to connect" /* RedisClientNotConnected */));
+      return;
+    }
     const multi = client.multi();
     for (const { key, value, ttl } of entries) {
       const prefixedKey = this.createKeyPrefix(key, this._namespace);
@@ -232,6 +290,10 @@ var KeyvRedis = class extends import_node_events.default {
    */
   async has(key) {
     const client = await this.getClient();
+    if (!client) {
+      this.emit("error", new Error("Redis client is not connected or has failed to connect" /* RedisClientNotConnected */));
+      return false;
+    }
     key = this.createKeyPrefix(key, this._namespace);
     const exists = await client.exists(key);
     return exists === 1;
@@ -243,6 +305,10 @@ var KeyvRedis = class extends import_node_events.default {
    */
   async hasMany(keys) {
     const client = await this.getClient();
+    if (!client) {
+      this.emit("error", new Error("Redis client is not connected or has failed to connect" /* RedisClientNotConnected */));
+      return Array.from({ length: keys.length }).fill(false);
+    }
     const multi = client.multi();
     for (const key of keys) {
       const prefixedKey = this.createKeyPrefix(key, this._namespace);
@@ -258,6 +324,10 @@ var KeyvRedis = class extends import_node_events.default {
    */
   async get(key) {
     const client = await this.getClient();
+    if (!client) {
+      this.emit("error", new Error("Redis client is not connected or has failed to connect" /* RedisClientNotConnected */));
+      return void 0;
+    }
     key = this.createKeyPrefix(key, this._namespace);
     const value = await client.get(key);
     if (value === null) {
@@ -275,8 +345,13 @@ var KeyvRedis = class extends import_node_events.default {
       return [];
     }
     keys = keys.map((key) => this.createKeyPrefix(key, this._namespace));
-    const values = await this.mget(keys);
-    return values;
+    try {
+      const values = await this.mget(keys);
+      return values;
+    } catch (error) {
+      this.emit("error", error);
+      return Array.from({ length: keys.length }).fill(void 0);
+    }
   }
   /**
    * Delete a key from the store.
@@ -285,6 +360,10 @@ var KeyvRedis = class extends import_node_events.default {
    */
   async delete(key) {
     const client = await this.getClient();
+    if (!client) {
+      this.emit("error", new Error("Redis client is not connected or has failed to connect" /* RedisClientNotConnected */));
+      return false;
+    }
     key = this.createKeyPrefix(key, this._namespace);
     let deleted = 0;
     deleted = await (this._useUnlink ? client.unlink(key) : client.del(key));
@@ -298,6 +377,10 @@ var KeyvRedis = class extends import_node_events.default {
   async deleteMany(keys) {
     let result = false;
     const client = await this.getClient();
+    if (!client) {
+      this.emit("error", new Error("Redis client is not connected or has failed to connect" /* RedisClientNotConnected */));
+      return false;
+    }
     const multi = client.multi();
     for (const key of keys) {
       const prefixedKey = this.createKeyPrefix(key, this._namespace);
@@ -468,6 +551,9 @@ var KeyvRedis = class extends import_node_events.default {
    */
   async getSlotMaster(slot) {
     const connection = await this.getClient();
+    if (!connection) {
+      throw new Error("Redis client is not connected or has failed to connect" /* RedisClientNotConnected */);
+    }
     if (this.isCluster()) {
       const cluster = connection;
       const mainNode = cluster.slots[slot].master;
@@ -520,11 +606,23 @@ var KeyvRedis = class extends import_node_events.default {
     if (options.noNamespaceAffectsAll !== void 0) {
       this._noNamespaceAffectsAll = options.noNamespaceAffectsAll;
     }
+    if (options.connectTimeout !== void 0 && options.connectTimeout > 0) {
+      this._connectTimeout = options.connectTimeout;
+    }
   }
   initClient() {
     this._client.on("error", (error) => {
       this.emit("error", error);
     });
+    this._client.on("connect", () => {
+      this.emit("connect", this._client);
+    });
+    this._client.on("disconnect", () => {
+      this.emit("disconnect", this._client);
+    });
+    this._client.on("reconnecting", (reconnectInfo) => {
+      this.emit("reconnecting", reconnectInfo);
+    });
   }
 };
 function createKeyv(connect, options) {
@@ -536,7 +634,9 @@ function createKeyv(connect, options) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   Keyv,
+  RedisErrorMessages,
   createClient,
   createCluster,
-  createKeyv
+  createKeyv,
+  defaultReconnectStrategy
 });

package/dist/index.d.cts

@@ -27,6 +27,11 @@ type KeyvRedisOptions = {
      * Defaults to `false`.
      */
     noNamespaceAffectsAll?: boolean;
+    /**
+     * Timeout for connecting to Redis in milliseconds. This is used to prevent hanging indefinitely when connecting to Redis.
+     * Defaults to `200`.
+     */
+    connectTimeout?: number;
 };
 type KeyvRedisPropertyOptions = KeyvRedisOptions & {
     /**
@@ -52,6 +57,13 @@ type KeyvRedisEntry<T> = {
      */
     ttl?: number;
 };
+declare enum RedisErrorMessages {
+    /**
+     * Error message when the Redis client is not connected.
+     */
+    RedisClientNotConnected = "Redis client is not connected or has failed to connect"
+}
+declare const defaultReconnectStrategy: (attempts: number) => number | Error;
 type RedisClientConnectionType = RedisClientType | RedisClusterType<RedisModules, RedisFunctions, RedisScripts>;
 declare class KeyvRedis<T> extends EventEmitter implements KeyvStoreAdapter {
     private _client;
@@ -60,6 +72,8 @@ declare class KeyvRedis<T> extends EventEmitter implements KeyvStoreAdapter {
     private _clearBatchSize;
     private _useUnlink;
     private _noNamespaceAffectsAll;
+    private _connectTimeout;
+    private _reconnectClient;
     /**
      * 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.
@@ -129,10 +143,20 @@ declare class KeyvRedis<T> extends EventEmitter implements KeyvStoreAdapter {
      * Set if not namespace affects all keys.
      */
     set noNamespaceAffectsAll(value: boolean);
+    /**
+     * Get the timeout for connecting to Redis in milliseconds. This is used to prevent hanging indefinitely when connecting to Redis.
+     * @default 200
+     */
+    get connectTimeout(): number;
+    /**
+     * Set the timeout for connecting to Redis in milliseconds. This is used to prevent hanging indefinitely when connecting to Redis.
+     * @default 200
+     */
+    set connectTimeout(value: number);
     /**
      * Get the Redis URL used to connect to the server. This is used to get a connected client.
      */
-    getClient(): Promise<RedisClientConnectionType>;
+    getClient(): Promise<RedisClientConnectionType | undefined>;
     /**
      * Set a key value pair in the store. TTL is in milliseconds.
      * @param {string} key - the key to set
@@ -260,4 +284,4 @@ declare class KeyvRedis<T> extends EventEmitter implements KeyvStoreAdapter {
  */
 declare function createKeyv(connect?: string | RedisClientOptions | RedisClientType, options?: KeyvRedisOptions): Keyv;
 
-export { type KeyvRedisEntry, type KeyvRedisOptions, type KeyvRedisPropertyOptions, type RedisClientConnectionType, createKeyv, KeyvRedis as default };
+export { type KeyvRedisEntry, type KeyvRedisOptions, type KeyvRedisPropertyOptions, type RedisClientConnectionType, RedisErrorMessages, createKeyv, KeyvRedis as default, defaultReconnectStrategy };

package/dist/index.d.ts

@@ -27,6 +27,11 @@ type KeyvRedisOptions = {
      * Defaults to `false`.
      */
     noNamespaceAffectsAll?: boolean;
+    /**
+     * Timeout for connecting to Redis in milliseconds. This is used to prevent hanging indefinitely when connecting to Redis.
+     * Defaults to `200`.
+     */
+    connectTimeout?: number;
 };
 type KeyvRedisPropertyOptions = KeyvRedisOptions & {
     /**
@@ -52,6 +57,13 @@ type KeyvRedisEntry<T> = {
      */
     ttl?: number;
 };
+declare enum RedisErrorMessages {
+    /**
+     * Error message when the Redis client is not connected.
+     */
+    RedisClientNotConnected = "Redis client is not connected or has failed to connect"
+}
+declare const defaultReconnectStrategy: (attempts: number) => number | Error;
 type RedisClientConnectionType = RedisClientType | RedisClusterType<RedisModules, RedisFunctions, RedisScripts>;
 declare class KeyvRedis<T> extends EventEmitter implements KeyvStoreAdapter {
     private _client;
@@ -60,6 +72,8 @@ declare class KeyvRedis<T> extends EventEmitter implements KeyvStoreAdapter {
     private _clearBatchSize;
     private _useUnlink;
     private _noNamespaceAffectsAll;
+    private _connectTimeout;
+    private _reconnectClient;
     /**
      * 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.
@@ -129,10 +143,20 @@ declare class KeyvRedis<T> extends EventEmitter implements KeyvStoreAdapter {
      * Set if not namespace affects all keys.
      */
     set noNamespaceAffectsAll(value: boolean);
+    /**
+     * Get the timeout for connecting to Redis in milliseconds. This is used to prevent hanging indefinitely when connecting to Redis.
+     * @default 200
+     */
+    get connectTimeout(): number;
+    /**
+     * Set the timeout for connecting to Redis in milliseconds. This is used to prevent hanging indefinitely when connecting to Redis.
+     * @default 200
+     */
+    set connectTimeout(value: number);
     /**
      * Get the Redis URL used to connect to the server. This is used to get a connected client.
      */
-    getClient(): Promise<RedisClientConnectionType>;
+    getClient(): Promise<RedisClientConnectionType | undefined>;
     /**
      * Set a key value pair in the store. TTL is in milliseconds.
      * @param {string} key - the key to set
@@ -260,4 +284,4 @@ declare class KeyvRedis<T> extends EventEmitter implements KeyvStoreAdapter {
  */
 declare function createKeyv(connect?: string | RedisClientOptions | RedisClientType, options?: KeyvRedisOptions): Keyv;
 
-export { type KeyvRedisEntry, type KeyvRedisOptions, type KeyvRedisPropertyOptions, type RedisClientConnectionType, createKeyv, KeyvRedis as default };
+export { type KeyvRedisEntry, type KeyvRedisOptions, type KeyvRedisPropertyOptions, type RedisClientConnectionType, RedisErrorMessages, createKeyv, KeyvRedis as default, defaultReconnectStrategy };

package/dist/index.js

@@ -13,6 +13,15 @@ import {
 import {
   Keyv as Keyv2
 } from "keyv";
+var RedisErrorMessages = /* @__PURE__ */ ((RedisErrorMessages2) => {
+  RedisErrorMessages2["RedisClientNotConnected"] = "Redis client is not connected or has failed to connect";
+  return RedisErrorMessages2;
+})(RedisErrorMessages || {});
+var defaultReconnectStrategy = (attempts) => {
+  const backoff = Math.min(2 ** attempts * 100, 2e3);
+  const jitter = (Math.random() - 0.5) * 100;
+  return backoff + jitter;
+};
 var KeyvRedis = class extends EventEmitter {
   _client = createClient();
   _namespace;
@@ -20,6 +29,10 @@ var KeyvRedis = class extends EventEmitter {
   _clearBatchSize = 1e3;
   _useUnlink = true;
   _noNamespaceAffectsAll = false;
+  _connectTimeout = 200;
+  // Timeout for connecting to Redis in milliseconds
+  _reconnectClient = false;
+  // Whether to reconnect the client
   /**
    * 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.
@@ -27,9 +40,12 @@ var KeyvRedis = class extends EventEmitter {
    */
   constructor(connect, options) {
     super();
+    const socket = {
+      reconnectStrategy: defaultReconnectStrategy
+    };
     if (connect) {
       if (typeof connect === "string") {
-        this._client = createClient({ url: connect });
+        this._client = createClient({ url: connect, socket });
       } else if (connect.connect !== void 0) {
         this._client = this.isClientCluster(connect) ? connect : connect;
       } else if (connect instanceof Object) {
@@ -150,18 +166,50 @@ var KeyvRedis = class extends EventEmitter {
   set noNamespaceAffectsAll(value) {
     this._noNamespaceAffectsAll = value;
   }
+  /**
+   * Get the timeout for connecting to Redis in milliseconds. This is used to prevent hanging indefinitely when connecting to Redis.
+   * @default 200
+   */
+  get connectTimeout() {
+    return this._connectTimeout;
+  }
+  /**
+   * Set the timeout for connecting to Redis in milliseconds. This is used to prevent hanging indefinitely when connecting to Redis.
+   * @default 200
+   */
+  set connectTimeout(value) {
+    if (value > 0) {
+      this._connectTimeout = value;
+      this._reconnectClient = true;
+    } else {
+      this.emit("error", "connectTimeout must be greater than 0");
+    }
+  }
   /**
    * Get the Redis URL used to connect to the server. This is used to get a connected client.
    */
   async getClient() {
+    if (this._client.isOpen && !this._reconnectClient) {
+      return this._client;
+    }
+    if (this._reconnectClient && this._client.isOpen) {
+      await this._client.disconnect();
+    }
     try {
-      if (!this._client.isOpen) {
-        await this._client.connect();
-      }
+      const timeoutPromise = new Promise((resolves, reject) => setTimeout(() => {
+        reject(new Error("Redis client is not connected or has failed to connect" /* RedisClientNotConnected */));
+      }, this._connectTimeout));
+      await Promise.race([
+        this._client.connect(),
+        timeoutPromise
+      ]);
+      this._reconnectClient = false;
+      this.initClient();
+      return this._client;
     } catch (error) {
       this.emit("error", error);
+      return void 0;
     }
-    return this._client;
   }
   /**
    * Set a key value pair in the store. TTL is in milliseconds.
@@ -171,6 +219,10 @@ var KeyvRedis = class extends EventEmitter {
    */
   async set(key, value, ttl) {
     const client = await this.getClient();
+    if (!client) {
+      this.emit("error", new Error("Redis client is not connected or has failed to connect" /* RedisClientNotConnected */));
+      return;
+    }
     key = this.createKeyPrefix(key, this._namespace);
     if (ttl) {
       await client.set(key, value, { PX: ttl });
@@ -184,6 +236,10 @@ var KeyvRedis = class extends EventEmitter {
    */
   async setMany(entries) {
     const client = await this.getClient();
+    if (!client) {
+      this.emit("error", new Error("Redis client is not connected or has failed to connect" /* RedisClientNotConnected */));
+      return;
+    }
     const multi = client.multi();
     for (const { key, value, ttl } of entries) {
       const prefixedKey = this.createKeyPrefix(key, this._namespace);
@@ -202,6 +258,10 @@ var KeyvRedis = class extends EventEmitter {
    */
   async has(key) {
     const client = await this.getClient();
+    if (!client) {
+      this.emit("error", new Error("Redis client is not connected or has failed to connect" /* RedisClientNotConnected */));
+      return false;
+    }
     key = this.createKeyPrefix(key, this._namespace);
     const exists = await client.exists(key);
     return exists === 1;
@@ -213,6 +273,10 @@ var KeyvRedis = class extends EventEmitter {
    */
   async hasMany(keys) {
     const client = await this.getClient();
+    if (!client) {
+      this.emit("error", new Error("Redis client is not connected or has failed to connect" /* RedisClientNotConnected */));
+      return Array.from({ length: keys.length }).fill(false);
+    }
     const multi = client.multi();
     for (const key of keys) {
       const prefixedKey = this.createKeyPrefix(key, this._namespace);
@@ -228,6 +292,10 @@ var KeyvRedis = class extends EventEmitter {
    */
   async get(key) {
     const client = await this.getClient();
+    if (!client) {
+      this.emit("error", new Error("Redis client is not connected or has failed to connect" /* RedisClientNotConnected */));
+      return void 0;
+    }
     key = this.createKeyPrefix(key, this._namespace);
     const value = await client.get(key);
     if (value === null) {
@@ -245,8 +313,13 @@ var KeyvRedis = class extends EventEmitter {
       return [];
     }
     keys = keys.map((key) => this.createKeyPrefix(key, this._namespace));
-    const values = await this.mget(keys);
-    return values;
+    try {
+      const values = await this.mget(keys);
+      return values;
+    } catch (error) {
+      this.emit("error", error);
+      return Array.from({ length: keys.length }).fill(void 0);
+    }
   }
   /**
    * Delete a key from the store.
@@ -255,6 +328,10 @@ var KeyvRedis = class extends EventEmitter {
    */
   async delete(key) {
     const client = await this.getClient();
+    if (!client) {
+      this.emit("error", new Error("Redis client is not connected or has failed to connect" /* RedisClientNotConnected */));
+      return false;
+    }
     key = this.createKeyPrefix(key, this._namespace);
     let deleted = 0;
     deleted = await (this._useUnlink ? client.unlink(key) : client.del(key));
@@ -268,6 +345,10 @@ var KeyvRedis = class extends EventEmitter {
   async deleteMany(keys) {
     let result = false;
     const client = await this.getClient();
+    if (!client) {
+      this.emit("error", new Error("Redis client is not connected or has failed to connect" /* RedisClientNotConnected */));
+      return false;
+    }
     const multi = client.multi();
     for (const key of keys) {
       const prefixedKey = this.createKeyPrefix(key, this._namespace);
@@ -438,6 +519,9 @@ var KeyvRedis = class extends EventEmitter {
    */
   async getSlotMaster(slot) {
     const connection = await this.getClient();
+    if (!connection) {
+      throw new Error("Redis client is not connected or has failed to connect" /* RedisClientNotConnected */);
+    }
     if (this.isCluster()) {
       const cluster = connection;
       const mainNode = cluster.slots[slot].master;
@@ -490,11 +574,23 @@ var KeyvRedis = class extends EventEmitter {
     if (options.noNamespaceAffectsAll !== void 0) {
       this._noNamespaceAffectsAll = options.noNamespaceAffectsAll;
     }
+    if (options.connectTimeout !== void 0 && options.connectTimeout > 0) {
+      this._connectTimeout = options.connectTimeout;
+    }
   }
   initClient() {
     this._client.on("error", (error) => {
       this.emit("error", error);
     });
+    this._client.on("connect", () => {
+      this.emit("connect", this._client);
+    });
+    this._client.on("disconnect", () => {
+      this.emit("disconnect", this._client);
+    });
+    this._client.on("reconnecting", (reconnectInfo) => {
+      this.emit("reconnecting", reconnectInfo);
+    });
   }
 };
 function createKeyv(connect, options) {
@@ -505,8 +601,10 @@ function createKeyv(connect, options) {
 }
 export {
   Keyv2 as Keyv,
+  RedisErrorMessages,
   createClient2 as createClient,
   createCluster2 as createCluster,
   createKeyv,
-  KeyvRedis as default
+  KeyvRedis as default,
+  defaultReconnectStrategy
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyv/redis",
-  "version": "4.4.1",
+  "version": "4.5.0",
   "description": "Redis storage adapter for Keyv",
   "type": "module",
   "main": "dist/index.cjs",
@@ -41,6 +41,7 @@
     "keyv": "^5.3.4"
   },
   "devDependencies": {
+    "@faker-js/faker": "^9.8.0",
     "@vitest/coverage-v8": "^3.2.3",
     "rimraf": "^6.0.1",
     "timekeeper": "^2.3.1",