@keyv/redis 4.5.0 → 5.0.0

package/dist/index.cjs

@@ -35,18 +35,19 @@ __export(index_exports, {
   createClient: () => import_client2.createClient,
   createCluster: () => import_client2.createCluster,
   createKeyv: () => createKeyv,
+  createKeyvNonBlocking: () => createKeyvNonBlocking,
   default: () => KeyvRedis,
   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 +55,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;
+  _throwOnErrors = 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 +74,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 +117,10 @@ var KeyvRedis = class extends import_node_events.default {
       keyPrefixSeparator: this._keyPrefixSeparator,
       clearBatchSize: this._clearBatchSize,
       noNamespaceAffectsAll: this._noNamespaceAffectsAll,
+      useUnlink: this._useUnlink,
+      throwOnConnectError: this._throwOnConnectError,
+      throwOnErrors: this._throwOnErrors,
+      connectionTimeout: this._connectionTimeout,
       dialect: "redis",
       url
     };
@@ -199,49 +204,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 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 throwOnErrors() {
+    return this._throwOnErrors;
+  }
+  /**
+   * 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 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.
+   * @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;
+      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 */);
+      }
     }
+    this.initClient();
+    return this._client;
   }
   /**
    * Set a key value pair in the store. TTL is in milliseconds.
@@ -251,15 +289,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._throwOnErrors) {
+        throw error;
+      }
     }
   }
   /**
@@ -268,20 +309,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._throwOnErrors) {
+        throw error;
       }
     }
-    await multi.exec();
   }
   /**
    * Check if a key exists in the store.
@@ -290,13 +334,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._throwOnErrors) {
+        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 +353,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) => typeof result === "number" && result === 1);
+    } catch (error) {
+      this.emit("error", error);
+      if (this._throwOnErrors) {
+        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 +376,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._throwOnErrors) {
+        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 +406,9 @@ var KeyvRedis = class extends import_node_events.default {
       return values;
     } catch (error) {
       this.emit("error", error);
+      if (this._throwOnErrors) {
+        throw error;
+      }
       return Array.from({ length: keys.length }).fill(void 0);
     }
   }
@@ -360,14 +419,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._throwOnErrors) {
+        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 +440,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._throwOnErrors) {
+        throw error;
       }
     }
     return result;
@@ -406,7 +472,7 @@ var KeyvRedis = class extends import_node_events.default {
    */
   async disconnect(force) {
     if (this._client.isOpen) {
-      await (force ? this._client.disconnect() : this._client.quit());
+      await (force ? this._client.destroy() : this._client.close());
     }
   }
   /**
@@ -448,7 +514,8 @@ var KeyvRedis = class extends import_node_events.default {
   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()];
   }
@@ -463,7 +530,7 @@ var KeyvRedis = class extends import_node_events.default {
       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) {
@@ -500,7 +567,7 @@ var KeyvRedis = class extends import_node_events.default {
         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) {
@@ -551,9 +618,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;
@@ -582,10 +646,7 @@ var KeyvRedis = class extends import_node_events.default {
     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) {
@@ -606,14 +667,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.throwOnErrors !== void 0) {
+      this._throwOnErrors = options.throwOnErrors;
+    }
+    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,11 +688,55 @@ 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";
   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:
@@ -638,5 +746,6 @@ function createKeyv(connect, options) {
   createClient,
   createCluster,
   createKeyv,
+  createKeyvNonBlocking,
   defaultReconnectStrategy
 });