@keyv/redis 4.5.0 → 4.6.0

package/README.md

@@ -29,7 +29,7 @@ Redis storage adapter for [Keyv](https://github.com/jaredwray/keyv).
 * [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)
+* [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)
 * [API](#api)
@@ -131,10 +131,26 @@ export type KeyvRedisOptions = {
 	noNamespaceAffectsAll?: boolean;
 
 	/**
-	 * Timeout for connecting to Redis in milliseconds. This is used to prevent hanging indefinitely when connecting to Redis.
-	 * Defaults to `200`.
+	 * This is used to throw an error if the client is not connected when trying to connect. By default, this is
+	 * set to true so that it throws an error when trying to connect to the Redis server fails.
 	 */
-	connectTimeout?: number;
+	throwOnConnectError?: boolean;
+
+	/**
+	 * This is used to throw an error if at any point there is a failure. Use this if you want to
+	 * ensure that all operations are successful and you want to handle errors. By default, this is
+	 * set to false so that it does not throw an error on every operation and instead emits an error event
+	 * and returns no-op responses.
+	 * @default false
+	 */
+	throwErrors?: boolean;
+
+	/**
+	 * Timeout in milliseconds for the connection. Default is undefined, which uses the default timeout of the Redis client.
+	 * If set, it will throw an error if the connection does not succeed within the specified time.
+   * @default undefined
+	 */
+	connectionTimeout?: number;
 };
 ```
 You can pass these options when creating a new `KeyvRedis` instance:
@@ -241,7 +257,7 @@ const keyv = new Keyv(new KeyvRedis('redis://user:pass@localhost:6379', { useUnl
 keyv.useUnlink = false;
 ```
 
-# Gracefully Handling Connection Errors, Retries, and Timeouts
+# Gracefully Handling Errors 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:
 
@@ -254,11 +270,13 @@ keyv.on('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.
+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:
+
+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.
 
-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 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 pass in just a `uri` connection string we will automatically create a Redis client for you with the following reconnect strategy:
+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:
 
 ```typescript
 export const defaultReconnectStrategy = (attempts: number): number | Error => {

package/dist/index.cjs

@@ -39,14 +39,14 @@ __export(index_exports, {
   defaultReconnectStrategy: () => defaultReconnectStrategy
 });
 module.exports = __toCommonJS(index_exports);
-var import_node_events = __toESM(require("events"), 1);
 var import_client = require("@redis/client");
+var import_hookified = require("hookified");
 var import_keyv = require("keyv");
 var import_cluster_key_slot = __toESM(require("cluster-key-slot"), 1);
 var import_client2 = require("@redis/client");
 var import_keyv2 = require("keyv");
 var RedisErrorMessages = /* @__PURE__ */ ((RedisErrorMessages2) => {
-  RedisErrorMessages2["RedisClientNotConnected"] = "Redis client is not connected or has failed to connect";
+  RedisErrorMessages2["RedisClientNotConnectedThrown"] = "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.";
   return RedisErrorMessages2;
 })(RedisErrorMessages || {});
 var defaultReconnectStrategy = (attempts) => {
@@ -54,17 +54,16 @@ var defaultReconnectStrategy = (attempts) => {
   const jitter = (Math.random() - 0.5) * 100;
   return backoff + jitter;
 };
-var KeyvRedis = class extends import_node_events.default {
+var KeyvRedis = class extends import_hookified.Hookified {
   _client = (0, import_client.createClient)();
   _namespace;
   _keyPrefixSeparator = "::";
   _clearBatchSize = 1e3;
   _useUnlink = true;
   _noNamespaceAffectsAll = false;
-  _connectTimeout = 200;
-  // Timeout for connecting to Redis in milliseconds
-  _reconnectClient = false;
-  // Whether to reconnect the client
+  _throwOnConnectError = true;
+  _throwErrors = false;
+  _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.
@@ -74,6 +73,7 @@ var KeyvRedis = class extends import_node_events.default {
     super();
     const socket = {
       reconnectStrategy: defaultReconnectStrategy
+      // Default timeout for the connection
     };
     if (connect) {
       if (typeof connect === "string") {
@@ -116,6 +116,10 @@ var KeyvRedis = class extends import_node_events.default {
       keyPrefixSeparator: this._keyPrefixSeparator,
       clearBatchSize: this._clearBatchSize,
       noNamespaceAffectsAll: this._noNamespaceAffectsAll,
+      useUnlink: this._useUnlink,
+      throwOnConnectError: this._throwOnConnectError,
+      throwErrors: this._throwErrors,
+      connectionTimeout: this._connectionTimeout,
       dialect: "redis",
       url
     };
@@ -199,49 +203,82 @@ var KeyvRedis = class extends import_node_events.default {
     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 if throwOnConnectError is set to true.
+   * This is used to throw an error if the client is not connected when trying to connect. By default, this is
+   * set to true so that it throws an error when trying to connect to the Redis server fails.
+   * @default true
    */
-  get connectTimeout() {
-    return this._connectTimeout;
+  get throwOnConnectError() {
+    return this._throwOnConnectError;
   }
   /**
-   * Set the timeout for connecting to Redis in milliseconds. This is used to prevent hanging indefinitely when connecting to Redis.
-   * @default 200
+   * Set if throwOnConnectError is set to true.
+   * This is used to throw an error if the client is not connected when trying to connect. By default, this is
+   * set to true so that it throws an error when trying to connect to the Redis server fails.
    */
-  set connectTimeout(value) {
-    if (value > 0) {
-      this._connectTimeout = value;
-      this._reconnectClient = true;
-    } else {
-      this.emit("error", "connectTimeout must be greater than 0");
-    }
+  set throwOnConnectError(value) {
+    this._throwOnConnectError = value;
+  }
+  /**
+   * Get if throwErrors 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;
+  }
+  /**
+   * Set if throwErrors 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;
+  }
+  /**
+   * Get the connection timeout in milliseconds such as 5000 (5 seconds). Default is undefined. If undefined, it will use the default.
+   * @default undefined
+   */
+  get connectionTimeout() {
+    return this._connectionTimeout;
+  }
+  /**
+   * Set the connection timeout in milliseconds such as 5000 (5 seconds). Default is undefined. If undefined, it will use the default.
+   * @default undefined
+   */
+  set connectionTimeout(value) {
+    this._connectionTimeout = value;
   }
   /**
    * 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) {
+    if (this._client.isOpen) {
       return this._client;
     }
-    if (this._reconnectClient && this._client.isOpen) {
-      await this._client.disconnect();
-    }
     try {
-      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;
+      if (this._connectionTimeout === void 0) {
+        await this._client.connect();
+      } else {
+        await Promise.race([
+          this._client.connect(),
+          this.createTimeoutPromise(this._connectionTimeout)
+        ]);
+      }
     } catch (error) {
       this.emit("error", error);
-      return void 0;
+      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;
   }
   /**
    * Set a key value pair in the store. TTL is in milliseconds.
@@ -251,15 +288,18 @@ 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 });
-    } else {
-      await client.set(key, value);
+    try {
+      key = this.createKeyPrefix(key, this._namespace);
+      if (ttl) {
+        await client.set(key, value, { PX: ttl });
+      } else {
+        await client.set(key, value);
+      }
+    } catch (error) {
+      this.emit("error", error);
+      if (this._throwErrors) {
+        throw error;
+      }
     }
   }
   /**
@@ -268,20 +308,23 @@ 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);
-      if (ttl) {
-        multi.set(prefixedKey, value, { PX: ttl });
-      } else {
-        multi.set(prefixedKey, value);
+    try {
+      const multi = client.multi();
+      for (const { key, value, ttl } of entries) {
+        const prefixedKey = this.createKeyPrefix(key, this._namespace);
+        if (ttl) {
+          multi.set(prefixedKey, value, { PX: ttl });
+        } else {
+          multi.set(prefixedKey, value);
+        }
+      }
+      await multi.exec();
+    } catch (error) {
+      this.emit("error", error);
+      if (this._throwErrors) {
+        throw error;
       }
     }
-    await multi.exec();
   }
   /**
    * Check if a key exists in the store.
@@ -290,13 +333,17 @@ 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 */));
+    try {
+      key = this.createKeyPrefix(key, this._namespace);
+      const exists = await client.exists(key);
+      return exists === 1;
+    } catch (error) {
+      this.emit("error", error);
+      if (this._throwErrors) {
+        throw error;
+      }
       return false;
     }
-    key = this.createKeyPrefix(key, this._namespace);
-    const exists = await client.exists(key);
-    return exists === 1;
   }
   /**
    * Check if many keys exist in the store. This will be done as a single transaction.
@@ -305,17 +352,21 @@ 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 */));
+    try {
+      const multi = client.multi();
+      for (const key of keys) {
+        const prefixedKey = this.createKeyPrefix(key, this._namespace);
+        multi.exists(prefixedKey);
+      }
+      const results = await multi.exec();
+      return results.map((result) => result === 1);
+    } catch (error) {
+      this.emit("error", error);
+      if (this._throwErrors) {
+        throw error;
+      }
       return Array.from({ length: keys.length }).fill(false);
     }
-    const multi = client.multi();
-    for (const key of keys) {
-      const prefixedKey = this.createKeyPrefix(key, this._namespace);
-      multi.exists(prefixedKey);
-    }
-    const results = await multi.exec();
-    return results.map((result) => result === 1);
   }
   /**
    * Get a value from the store. If the key does not exist, it will return undefined.
@@ -324,16 +375,20 @@ 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) {
+    try {
+      key = this.createKeyPrefix(key, this._namespace);
+      const value = await client.get(key);
+      if (value === null) {
+        return void 0;
+      }
+      return value;
+    } catch (error) {
+      this.emit("error", error);
+      if (this._throwErrors) {
+        throw error;
+      }
       return void 0;
     }
-    return value;
   }
   /**
    * Get many values from the store. If a key does not exist, it will return undefined.
@@ -350,6 +405,9 @@ var KeyvRedis = class extends import_node_events.default {
       return values;
     } catch (error) {
       this.emit("error", error);
+      if (this._throwErrors) {
+        throw error;
+      }
       return Array.from({ length: keys.length }).fill(void 0);
     }
   }
@@ -360,14 +418,18 @@ 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 */));
+    try {
+      key = this.createKeyPrefix(key, this._namespace);
+      let deleted = 0;
+      deleted = await (this._useUnlink ? client.unlink(key) : client.del(key));
+      return deleted > 0;
+    } catch (error) {
+      this.emit("error", error);
+      if (this._throwErrors) {
+        throw error;
+      }
       return false;
     }
-    key = this.createKeyPrefix(key, this._namespace);
-    let deleted = 0;
-    deleted = await (this._useUnlink ? client.unlink(key) : client.del(key));
-    return deleted > 0;
   }
   /**
    * Delete many keys from the store. This will be done as a single transaction.
@@ -377,23 +439,26 @@ 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);
-      if (this._useUnlink) {
-        multi.unlink(prefixedKey);
-      } else {
-        multi.del(prefixedKey);
+    try {
+      const multi = client.multi();
+      for (const key of keys) {
+        const prefixedKey = this.createKeyPrefix(key, this._namespace);
+        if (this._useUnlink) {
+          multi.unlink(prefixedKey);
+        } else {
+          multi.del(prefixedKey);
+        }
       }
-    }
-    const results = await multi.exec();
-    for (const deleted of results) {
-      if (typeof deleted === "number" && deleted > 0) {
-        result = true;
+      const results = await multi.exec();
+      for (const deleted of results) {
+        if (typeof deleted === "number" && deleted > 0) {
+          result = true;
+        }
+      }
+    } catch (error) {
+      this.emit("error", error);
+      if (this._throwErrors) {
+        throw error;
       }
     }
     return result;
@@ -551,9 +616,6 @@ 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;
@@ -606,14 +668,17 @@ 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;
+    if (options.throwOnConnectError !== void 0) {
+      this._throwOnConnectError = options.throwOnConnectError;
+    }
+    if (options.throwErrors !== void 0) {
+      this._throwErrors = options.throwErrors;
+    }
+    if (options.connectionTimeout !== void 0) {
+      this._connectionTimeout = options.connectionTimeout;
     }
   }
   initClient() {
-    this._client.on("error", (error) => {
-      this.emit("error", error);
-    });
     this._client.on("connect", () => {
       this.emit("connect", this._client);
     });
@@ -624,6 +689,17 @@ var KeyvRedis = class extends import_node_events.default {
       this.emit("reconnecting", reconnectInfo);
     });
   }
+  async createTimeoutPromise(timeoutMs) {
+    return new Promise((_, reject) => (
+      // eslint-disable-next-line no-promise-executor-return
+      setTimeout(
+        () => {
+          reject(new Error(`Redis timed out after ${timeoutMs}ms`));
+        },
+        timeoutMs
+      )
+    ));
+  }
 };
 function createKeyv(connect, options) {
   connect ??= "redis://localhost:6379";

package/dist/index.d.cts

@@ -1,6 +1,6 @@
-import EventEmitter from 'node:events';
 import { RedisClientOptions, RedisClusterOptions, RedisClientType, RedisClusterType, RedisModules, RedisFunctions, RedisScripts } from '@redis/client';
 export { RedisClientOptions, RedisClientType, RedisClusterOptions, RedisClusterType, createClient, createCluster } from '@redis/client';
+import { Hookified } from 'hookified';
 import { KeyvStoreAdapter, KeyvEntry, Keyv } from 'keyv';
 export { Keyv } from 'keyv';
 
@@ -28,10 +28,24 @@ type KeyvRedisOptions = {
      */
     noNamespaceAffectsAll?: boolean;
     /**
-     * Timeout for connecting to Redis in milliseconds. This is used to prevent hanging indefinitely when connecting to Redis.
-     * Defaults to `200`.
+     * This is used to throw an error if the client is not connected when trying to connect. By default, this is
+     * set to true so that it throws an error when trying to connect to the Redis server fails.
      */
-    connectTimeout?: number;
+    throwOnConnectError?: boolean;
+    /**
+     * This is used to throw an error if at any point there is a failure. Use this if you want to
+     * ensure that all operations are successful and you want to handle errors. By default, this is
+     * set to false so that it does not throw an error on every operation and instead emits an error event
+     * and returns no-op responses.
+     * @default false
+     */
+    throwErrors?: boolean;
+    /**
+     * Timeout in milliseconds for the connection. Default is undefined, which uses the default timeout of the Redis client.
+     * If set, it will throw an error if the connection does not succeed within the specified time.
+     * @default undefined
+     */
+    connectionTimeout?: number;
 };
 type KeyvRedisPropertyOptions = KeyvRedisOptions & {
     /**
@@ -59,21 +73,22 @@ type KeyvRedisEntry<T> = {
 };
 declare enum RedisErrorMessages {
     /**
-     * Error message when the Redis client is not connected.
+     * Error message when the Redis client is not connected and throwOnConnectError is set to true.
      */
-    RedisClientNotConnected = "Redis client is not connected or has failed to connect"
+    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>;
-declare class KeyvRedis<T> extends EventEmitter implements KeyvStoreAdapter {
+declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
     private _client;
     private _namespace;
     private _keyPrefixSeparator;
     private _clearBatchSize;
     private _useUnlink;
     private _noNamespaceAffectsAll;
-    private _connectTimeout;
-    private _reconnectClient;
+    private _throwOnConnectError;
+    private _throwErrors;
+    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.
@@ -144,19 +159,49 @@ declare class KeyvRedis<T> extends EventEmitter implements KeyvStoreAdapter {
      */
     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 if throwOnConnectError is set to true.
+     * This is used to throw an error if the client is not connected when trying to connect. By default, this is
+     * set to true so that it throws an error when trying to connect to the Redis server fails.
+     * @default true
+     */
+    get throwOnConnectError(): boolean;
+    /**
+     * Set if throwOnConnectError is set to true.
+     * This is used to throw an error if the client is not connected when trying to connect. By default, this is
+     * set to true so that it throws an error when trying to connect to the Redis server fails.
      */
-    get connectTimeout(): number;
+    set throwOnConnectError(value: boolean);
     /**
-     * Set the timeout for connecting to Redis in milliseconds. This is used to prevent hanging indefinitely when connecting to Redis.
-     * @default 200
+     * Get if throwErrors 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;
+    /**
+     * Set if throwErrors 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);
+    /**
+     * Get the connection timeout in milliseconds such as 5000 (5 seconds). Default is undefined. If undefined, it will use the default.
+     * @default undefined
+     */
+    get connectionTimeout(): number | undefined;
+    /**
+     * Set the connection timeout in milliseconds such as 5000 (5 seconds). Default is undefined. If undefined, it will use the default.
+     * @default undefined
      */
-    set connectTimeout(value: number);
+    set connectionTimeout(value: number | undefined);
     /**
      * Get the Redis URL used to connect to the server. This is used to get a connected client.
      */
-    getClient(): Promise<RedisClientConnectionType | undefined>;
+    getClient(): Promise<RedisClientConnectionType>;
     /**
      * Set a key value pair in the store. TTL is in milliseconds.
      * @param {string} key - the key to set
@@ -275,6 +320,7 @@ declare class KeyvRedis<T> extends EventEmitter implements KeyvStoreAdapter {
     private isClientCluster;
     private setOptions;
     private initClient;
+    private createTimeoutPromise;
 }
 /**
  * Will create a Keyv instance with the Redis adapter. This will also set the namespace and useKeyPrefix to false.

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-import EventEmitter from 'node:events';
 import { RedisClientOptions, RedisClusterOptions, RedisClientType, RedisClusterType, RedisModules, RedisFunctions, RedisScripts } from '@redis/client';
 export { RedisClientOptions, RedisClientType, RedisClusterOptions, RedisClusterType, createClient, createCluster } from '@redis/client';
+import { Hookified } from 'hookified';
 import { KeyvStoreAdapter, KeyvEntry, Keyv } from 'keyv';
 export { Keyv } from 'keyv';
 
@@ -28,10 +28,24 @@ type KeyvRedisOptions = {
      */
     noNamespaceAffectsAll?: boolean;
     /**
-     * Timeout for connecting to Redis in milliseconds. This is used to prevent hanging indefinitely when connecting to Redis.
-     * Defaults to `200`.
+     * This is used to throw an error if the client is not connected when trying to connect. By default, this is
+     * set to true so that it throws an error when trying to connect to the Redis server fails.
      */
-    connectTimeout?: number;
+    throwOnConnectError?: boolean;
+    /**
+     * This is used to throw an error if at any point there is a failure. Use this if you want to
+     * ensure that all operations are successful and you want to handle errors. By default, this is
+     * set to false so that it does not throw an error on every operation and instead emits an error event
+     * and returns no-op responses.
+     * @default false
+     */
+    throwErrors?: boolean;
+    /**
+     * Timeout in milliseconds for the connection. Default is undefined, which uses the default timeout of the Redis client.
+     * If set, it will throw an error if the connection does not succeed within the specified time.
+     * @default undefined
+     */
+    connectionTimeout?: number;
 };
 type KeyvRedisPropertyOptions = KeyvRedisOptions & {
     /**
@@ -59,21 +73,22 @@ type KeyvRedisEntry<T> = {
 };
 declare enum RedisErrorMessages {
     /**
-     * Error message when the Redis client is not connected.
+     * Error message when the Redis client is not connected and throwOnConnectError is set to true.
      */
-    RedisClientNotConnected = "Redis client is not connected or has failed to connect"
+    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>;
-declare class KeyvRedis<T> extends EventEmitter implements KeyvStoreAdapter {
+declare class KeyvRedis<T> extends Hookified implements KeyvStoreAdapter {
     private _client;
     private _namespace;
     private _keyPrefixSeparator;
     private _clearBatchSize;
     private _useUnlink;
     private _noNamespaceAffectsAll;
-    private _connectTimeout;
-    private _reconnectClient;
+    private _throwOnConnectError;
+    private _throwErrors;
+    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.
@@ -144,19 +159,49 @@ declare class KeyvRedis<T> extends EventEmitter implements KeyvStoreAdapter {
      */
     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 if throwOnConnectError is set to true.
+     * This is used to throw an error if the client is not connected when trying to connect. By default, this is
+     * set to true so that it throws an error when trying to connect to the Redis server fails.
+     * @default true
+     */
+    get throwOnConnectError(): boolean;
+    /**
+     * Set if throwOnConnectError is set to true.
+     * This is used to throw an error if the client is not connected when trying to connect. By default, this is
+     * set to true so that it throws an error when trying to connect to the Redis server fails.
      */
-    get connectTimeout(): number;
+    set throwOnConnectError(value: boolean);
     /**
-     * Set the timeout for connecting to Redis in milliseconds. This is used to prevent hanging indefinitely when connecting to Redis.
-     * @default 200
+     * Get if throwErrors 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;
+    /**
+     * Set if throwErrors 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);
+    /**
+     * Get the connection timeout in milliseconds such as 5000 (5 seconds). Default is undefined. If undefined, it will use the default.
+     * @default undefined
+     */
+    get connectionTimeout(): number | undefined;
+    /**
+     * Set the connection timeout in milliseconds such as 5000 (5 seconds). Default is undefined. If undefined, it will use the default.
+     * @default undefined
      */
-    set connectTimeout(value: number);
+    set connectionTimeout(value: number | undefined);
     /**
      * Get the Redis URL used to connect to the server. This is used to get a connected client.
      */
-    getClient(): Promise<RedisClientConnectionType | undefined>;
+    getClient(): Promise<RedisClientConnectionType>;
     /**
      * Set a key value pair in the store. TTL is in milliseconds.
      * @param {string} key - the key to set
@@ -275,6 +320,7 @@ declare class KeyvRedis<T> extends EventEmitter implements KeyvStoreAdapter {
     private isClientCluster;
     private setOptions;
     private initClient;
+    private createTimeoutPromise;
 }
 /**
  * Will create a Keyv instance with the Redis adapter. This will also set the namespace and useKeyPrefix to false.

package/dist/index.js

@@ -1,9 +1,9 @@
 // src/index.ts
-import EventEmitter from "events";
 import {
   createClient,
   createCluster
 } from "@redis/client";
+import { Hookified } from "hookified";
 import { Keyv } from "keyv";
 import calculateSlot from "cluster-key-slot";
 import {
@@ -14,7 +14,7 @@ import {
   Keyv as Keyv2
 } from "keyv";
 var RedisErrorMessages = /* @__PURE__ */ ((RedisErrorMessages2) => {
-  RedisErrorMessages2["RedisClientNotConnected"] = "Redis client is not connected or has failed to connect";
+  RedisErrorMessages2["RedisClientNotConnectedThrown"] = "Redis client is not connected or has failed to connect. This is thrown because throwOnConnectError is set to true.";
   return RedisErrorMessages2;
 })(RedisErrorMessages || {});
 var defaultReconnectStrategy = (attempts) => {
@@ -22,17 +22,16 @@ var defaultReconnectStrategy = (attempts) => {
   const jitter = (Math.random() - 0.5) * 100;
   return backoff + jitter;
 };
-var KeyvRedis = class extends EventEmitter {
+var KeyvRedis = class extends Hookified {
   _client = createClient();
   _namespace;
   _keyPrefixSeparator = "::";
   _clearBatchSize = 1e3;
   _useUnlink = true;
   _noNamespaceAffectsAll = false;
-  _connectTimeout = 200;
-  // Timeout for connecting to Redis in milliseconds
-  _reconnectClient = false;
-  // Whether to reconnect the client
+  _throwOnConnectError = true;
+  _throwErrors = false;
+  _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.
@@ -42,6 +41,7 @@ var KeyvRedis = class extends EventEmitter {
     super();
     const socket = {
       reconnectStrategy: defaultReconnectStrategy
+      // Default timeout for the connection
     };
     if (connect) {
       if (typeof connect === "string") {
@@ -84,6 +84,10 @@ var KeyvRedis = class extends EventEmitter {
       keyPrefixSeparator: this._keyPrefixSeparator,
       clearBatchSize: this._clearBatchSize,
       noNamespaceAffectsAll: this._noNamespaceAffectsAll,
+      useUnlink: this._useUnlink,
+      throwOnConnectError: this._throwOnConnectError,
+      throwErrors: this._throwErrors,
+      connectionTimeout: this._connectionTimeout,
       dialect: "redis",
       url
     };
@@ -167,49 +171,82 @@ var KeyvRedis = class extends EventEmitter {
     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 if throwOnConnectError is set to true.
+   * This is used to throw an error if the client is not connected when trying to connect. By default, this is
+   * set to true so that it throws an error when trying to connect to the Redis server fails.
+   * @default true
    */
-  get connectTimeout() {
-    return this._connectTimeout;
+  get throwOnConnectError() {
+    return this._throwOnConnectError;
   }
   /**
-   * Set the timeout for connecting to Redis in milliseconds. This is used to prevent hanging indefinitely when connecting to Redis.
-   * @default 200
+   * Set if throwOnConnectError is set to true.
+   * This is used to throw an error if the client is not connected when trying to connect. By default, this is
+   * set to true so that it throws an error when trying to connect to the Redis server fails.
    */
-  set connectTimeout(value) {
-    if (value > 0) {
-      this._connectTimeout = value;
-      this._reconnectClient = true;
-    } else {
-      this.emit("error", "connectTimeout must be greater than 0");
-    }
+  set throwOnConnectError(value) {
+    this._throwOnConnectError = value;
+  }
+  /**
+   * Get if throwErrors 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;
+  }
+  /**
+   * Set if throwErrors 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;
+  }
+  /**
+   * Get the connection timeout in milliseconds such as 5000 (5 seconds). Default is undefined. If undefined, it will use the default.
+   * @default undefined
+   */
+  get connectionTimeout() {
+    return this._connectionTimeout;
+  }
+  /**
+   * Set the connection timeout in milliseconds such as 5000 (5 seconds). Default is undefined. If undefined, it will use the default.
+   * @default undefined
+   */
+  set connectionTimeout(value) {
+    this._connectionTimeout = value;
   }
   /**
    * 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) {
+    if (this._client.isOpen) {
       return this._client;
     }
-    if (this._reconnectClient && this._client.isOpen) {
-      await this._client.disconnect();
-    }
     try {
-      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;
+      if (this._connectionTimeout === void 0) {
+        await this._client.connect();
+      } else {
+        await Promise.race([
+          this._client.connect(),
+          this.createTimeoutPromise(this._connectionTimeout)
+        ]);
+      }
     } catch (error) {
       this.emit("error", error);
-      return void 0;
+      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;
   }
   /**
    * Set a key value pair in the store. TTL is in milliseconds.
@@ -219,15 +256,18 @@ 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 });
-    } else {
-      await client.set(key, value);
+    try {
+      key = this.createKeyPrefix(key, this._namespace);
+      if (ttl) {
+        await client.set(key, value, { PX: ttl });
+      } else {
+        await client.set(key, value);
+      }
+    } catch (error) {
+      this.emit("error", error);
+      if (this._throwErrors) {
+        throw error;
+      }
     }
   }
   /**
@@ -236,20 +276,23 @@ 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);
-      if (ttl) {
-        multi.set(prefixedKey, value, { PX: ttl });
-      } else {
-        multi.set(prefixedKey, value);
+    try {
+      const multi = client.multi();
+      for (const { key, value, ttl } of entries) {
+        const prefixedKey = this.createKeyPrefix(key, this._namespace);
+        if (ttl) {
+          multi.set(prefixedKey, value, { PX: ttl });
+        } else {
+          multi.set(prefixedKey, value);
+        }
+      }
+      await multi.exec();
+    } catch (error) {
+      this.emit("error", error);
+      if (this._throwErrors) {
+        throw error;
       }
     }
-    await multi.exec();
   }
   /**
    * Check if a key exists in the store.
@@ -258,13 +301,17 @@ 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 */));
+    try {
+      key = this.createKeyPrefix(key, this._namespace);
+      const exists = await client.exists(key);
+      return exists === 1;
+    } catch (error) {
+      this.emit("error", error);
+      if (this._throwErrors) {
+        throw error;
+      }
       return false;
     }
-    key = this.createKeyPrefix(key, this._namespace);
-    const exists = await client.exists(key);
-    return exists === 1;
   }
   /**
    * Check if many keys exist in the store. This will be done as a single transaction.
@@ -273,17 +320,21 @@ 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 */));
+    try {
+      const multi = client.multi();
+      for (const key of keys) {
+        const prefixedKey = this.createKeyPrefix(key, this._namespace);
+        multi.exists(prefixedKey);
+      }
+      const results = await multi.exec();
+      return results.map((result) => result === 1);
+    } catch (error) {
+      this.emit("error", error);
+      if (this._throwErrors) {
+        throw error;
+      }
       return Array.from({ length: keys.length }).fill(false);
     }
-    const multi = client.multi();
-    for (const key of keys) {
-      const prefixedKey = this.createKeyPrefix(key, this._namespace);
-      multi.exists(prefixedKey);
-    }
-    const results = await multi.exec();
-    return results.map((result) => result === 1);
   }
   /**
    * Get a value from the store. If the key does not exist, it will return undefined.
@@ -292,16 +343,20 @@ 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) {
+    try {
+      key = this.createKeyPrefix(key, this._namespace);
+      const value = await client.get(key);
+      if (value === null) {
+        return void 0;
+      }
+      return value;
+    } catch (error) {
+      this.emit("error", error);
+      if (this._throwErrors) {
+        throw error;
+      }
       return void 0;
     }
-    return value;
   }
   /**
    * Get many values from the store. If a key does not exist, it will return undefined.
@@ -318,6 +373,9 @@ var KeyvRedis = class extends EventEmitter {
       return values;
     } catch (error) {
       this.emit("error", error);
+      if (this._throwErrors) {
+        throw error;
+      }
       return Array.from({ length: keys.length }).fill(void 0);
     }
   }
@@ -328,14 +386,18 @@ 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 */));
+    try {
+      key = this.createKeyPrefix(key, this._namespace);
+      let deleted = 0;
+      deleted = await (this._useUnlink ? client.unlink(key) : client.del(key));
+      return deleted > 0;
+    } catch (error) {
+      this.emit("error", error);
+      if (this._throwErrors) {
+        throw error;
+      }
       return false;
     }
-    key = this.createKeyPrefix(key, this._namespace);
-    let deleted = 0;
-    deleted = await (this._useUnlink ? client.unlink(key) : client.del(key));
-    return deleted > 0;
   }
   /**
    * Delete many keys from the store. This will be done as a single transaction.
@@ -345,23 +407,26 @@ 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);
-      if (this._useUnlink) {
-        multi.unlink(prefixedKey);
-      } else {
-        multi.del(prefixedKey);
+    try {
+      const multi = client.multi();
+      for (const key of keys) {
+        const prefixedKey = this.createKeyPrefix(key, this._namespace);
+        if (this._useUnlink) {
+          multi.unlink(prefixedKey);
+        } else {
+          multi.del(prefixedKey);
+        }
       }
-    }
-    const results = await multi.exec();
-    for (const deleted of results) {
-      if (typeof deleted === "number" && deleted > 0) {
-        result = true;
+      const results = await multi.exec();
+      for (const deleted of results) {
+        if (typeof deleted === "number" && deleted > 0) {
+          result = true;
+        }
+      }
+    } catch (error) {
+      this.emit("error", error);
+      if (this._throwErrors) {
+        throw error;
       }
     }
     return result;
@@ -519,9 +584,6 @@ 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;
@@ -574,14 +636,17 @@ 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;
+    if (options.throwOnConnectError !== void 0) {
+      this._throwOnConnectError = options.throwOnConnectError;
+    }
+    if (options.throwErrors !== void 0) {
+      this._throwErrors = options.throwErrors;
+    }
+    if (options.connectionTimeout !== void 0) {
+      this._connectionTimeout = options.connectionTimeout;
     }
   }
   initClient() {
-    this._client.on("error", (error) => {
-      this.emit("error", error);
-    });
     this._client.on("connect", () => {
       this.emit("connect", this._client);
     });
@@ -592,6 +657,17 @@ var KeyvRedis = class extends EventEmitter {
       this.emit("reconnecting", reconnectInfo);
     });
   }
+  async createTimeoutPromise(timeoutMs) {
+    return new Promise((_, reject) => (
+      // eslint-disable-next-line no-promise-executor-return
+      setTimeout(
+        () => {
+          reject(new Error(`Redis timed out after ${timeoutMs}ms`));
+        },
+        timeoutMs
+      )
+    ));
+  }
 };
 function createKeyv(connect, options) {
   connect ??= "redis://localhost:6379";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyv/redis",
-  "version": "4.5.0",
+  "version": "4.6.0",
   "description": "Redis storage adapter for Keyv",
   "type": "module",
   "main": "dist/index.cjs",
@@ -35,19 +35,20 @@
   "homepage": "https://github.com/jaredwray/keyv",
   "dependencies": {
     "@redis/client": "^1.6.0",
-    "cluster-key-slot": "^1.1.2"
+    "cluster-key-slot": "^1.1.2",
+    "hookified": "^1.10.0"
   },
   "peerDependencies": {
     "keyv": "^5.3.4"
   },
   "devDependencies": {
-    "@faker-js/faker": "^9.8.0",
-    "@vitest/coverage-v8": "^3.2.3",
+    "@faker-js/faker": "^9.9.0",
+    "@vitest/coverage-v8": "^3.2.4",
     "rimraf": "^6.0.1",
     "timekeeper": "^2.3.1",
     "tsd": "^0.32.0",
-    "vitest": "^3.2.3",
-    "xo": "^1.1.0",
+    "vitest": "^3.2.4",
+    "xo": "^1.1.1",
     "@keyv/test-suite": "^2.0.8"
   },
   "tsd": {