@keyv/redis 3.0.0 → 4.0.0

package/README.md

@@ -9,93 +9,230 @@
 
 Redis storage adapter for [Keyv](https://github.com/jaredwray/keyv).
 
-TTL functionality is handled directly by Redis so no timestamps are stored and expired keys are cleaned up internally.
+# Features
+* Built on top of [redis](https://npmjs.com/package/redis).
+* TTL is handled directly by Redis.
+* Supports Redis Clusters.
+* Url connection string support or pass in your Redis Options
+* Easily add in your own Redis client.
+* Namespace support for key management.
+* Unlink as default delete method for performance.
+* Access to the Redis client for advanced use cases.
+* Keyv and Redis Libraries are exported for advanced use cases.
+* `createKeyv` function for easy creation of Keyv instances.
+* jsDoc comments for easy documentation.
+* CJS / ESM and TypeScript supported out of the box.
+
+# Table of Contents
+* [Usage](#usage)
+* [Namespaces](#namespaces)
+* [Performance Considerations](#performance-considerations)
+* [High Memory Usage on Redis Server](#high-memory-usage-on-redis-server)
+* [Using Cacheable with Redis](#using-cacheable-with-redis)
+* [Clustering and TLS Support](#clustering-and-tls-support)
+* [API](#api)
+* [Migrating from v3 to v4](#migrating-from-v3-to-v4)
+* [About Redis Sets and its Support in v4](#about-redis-sets-and-its-support-in-v4)
+* [License](#license)
+
+# Usage
+
+Here is a standard use case where we implement `Keyv` and `@keyv/redis`:
 
-## Install
+```js
+import Keyv from 'keyv';
+import KeyvRedis from '@keyv/redis';
 
-```shell
-npm install --save keyv @keyv/redis
+const keyv = new Keyv(new KeyvRedis('redis://user:pass@localhost:6379'));
+keyv.on('error', handleConnectionError);
 ```
 
-## Usage
+Here you can pass in the Redis options directly:
 
 ```js
 import Keyv from 'keyv';
 import KeyvRedis from '@keyv/redis';
 
-const keyv = new Keyv(new KeyvRedis('redis://user:pass@localhost:6379'));
-keyv.on('error', handleConnectionError);
-```
+const redisOptions = {
+  url: 'redis://localhost:6379', // The Redis server URL (use 'rediss' for TLS)
+  password: 'your_password', // Optional password if Redis has authentication enabled
 
-Any valid [`Redis`](https://github.com/luin/ioredis#connect-to-redis) options will be passed directly through.
+  socket: {
+    host: 'localhost', // Hostname of the Redis server
+    port: 6379,        // Port number
+    reconnectStrategy: (retries) => Math.min(retries * 50, 2000), // Custom reconnect logic
 
-e.g:
+    tls: false, // Enable TLS if you need to connect over SSL
+    keepAlive: 30000, // Keep-alive timeout (in milliseconds)
+  }
+};
 
-```js
-const keyv = new Keyv(new KeyvRedis('redis://user:pass@localhost:6379', { disable_resubscribing: true }));
+const keyv = new Keyv(new KeyvRedis(redisOptions));
 ```
 
-Or you can manually create a storage adapter instance and pass it to Keyv:
+Or you can create a new Redis instance and pass it in with `KeyvOptions`:
 
 ```js
 import Keyv from 'keyv';
-import KeyvRedis from '@keyv/redis';
+import KeyvRedis, { createClient } from '@keyv/redis';
 
-const keyvRedis = new KeyvRedis('redis://user:pass@localhost:6379');
+const redis = createClient('redis://user:pass@localhost:6379', { namespace: 'my-namespace'});
+const keyvRedis = new KeyvRedis(redis);
 const keyv = new Keyv({ store: keyvRedis });
 ```
 
-Or reuse a previous Redis instance:
+Here is the same example but with the `Keyv` instance created with the `createKeyv` function:
 
 ```js
-import Keyv from 'keyv';
-import Redis from 'ioredis';
-import KeyvRedis from '@keyv/redis';
+import { createKeyv } from '@keyv/redis';
 
-const redis = new Redis('redis://user:pass@localhost:6379');
-const keyvRedis = new KeyvRedis(redis);
-const keyv = new Keyv({ store: keyvRedis });
+const keyv = createKeyv('redis://user:pass@localhost:6379', { namespace: 'my-namespace' });
 ```
 
-Or reuse a previous Redis cluster:
+You only have to import the `@keyv/redis` library if you are using the `createKeyv` function. 🎉 Otherwise, you can import `Keyv` and `@keyv/redis` independently.
+
+# Namspaces
+
+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:
 
 ```js
 import Keyv from 'keyv';
-import Redis from 'ioredis';
 import KeyvRedis from '@keyv/redis';
 
-const redis = new Redis.Cluster('redis://user:pass@localhost:6379');
-const keyvRedis = new KeyvRedis(redis);
-const keyv = new Keyv({ store: keyvRedis });
+const keyv = new Keyv(new KeyvRedis('redis://user:pass@localhost:6379', { namespace: 'my-namespace' }));
 ```
-## Options
 
-### useRedisSets
+This will prefix all keys with `my-namespace:`. You can also set the namespace after the fact:
+
+```js
+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.
+
+# Performance Considerations
+
+With namespaces being prefix based it is critical to understand some of the performance considerations we have made:
+* `clear()` - We use the `SCAN` command to iterate over keys. This is a non-blocking command that is more efficient than `KEYS`. In addition we are using `UNLINK` by default instead of `DEL`. Even with that if you are iterating over a large dataset it can still be slow. It is highly recommended to use the `namespace` option to limit the keys that are being cleared and if possible to not use the `clear()` method in high performance environments.
 
-The `useRedisSets` option lets you decide whether to use Redis sets for key management. By default, this option is set to `true`.
+* `delete()` - By default we are now using `UNLINK` instead of `DEL` for deleting keys. This is a non-blocking command that is more efficient than `DEL`. If you are deleting a large number of keys it is recommended to use the `deleteMany()` method instead of `delete()`.
 
-When `useRedisSets` is enabled (`true`):
+* `clearBatchSize` - The `clearBatchSize` option is set to `1000` by default. This is because Redis has a limit of 1000 keys that can be deleted in a single batch. 
 
-- A namespace for the Redis sets is created, and all created keys are added to this. This allows for group management of keys.
-- When a key is deleted, it's removed not only from the main storage but also from the Redis set.
-- When clearing all keys (using the `clear` function), all keys in the Redis set are looked up for deletion. The set itself is also deleted.
+* `useUnlink` - This option is set to `true` by default. This is because `UNLINK` is a non-blocking command that is more efficient than `DEL`. If you are not using `UNLINK` and are doing a lot of deletes it is recommended to set this option to `true`.
 
-**Note**: In high-performance scenarios, enabling `useRedisSets` might lead to memory leaks. If you're running a high-performance application or service, it is recommended to set `useRedisSets` to `false`.
+* `setMany`, `getMany`, `deleteMany` - These methods are more efficient than their singular counterparts. If you are doing multiple operations it is recommended to use these methods.
 
-If you decide to set `useRedisSets` as `false`, keys will be handled individually and Redis sets won't be utilized.
+If you want to see even better performance please see the [Using Cacheable with Redis](#using-cacheable-with-redis) section as it has non-blocking and in-memory primary caching that goes along well with this library and Keyv.
 
-However, please note that setting `useRedisSets` to `false` could lead to performance issues in production when using the `clear` function, as it will need to iterate over all keys to delete them.
+# High Memory Usage on Redis Server
 
-#### Example
+This is because we are using `UNLINK` by default instead of `DEL`. This is a non-blocking command that is more efficient than `DEL` but will slowly remove the memory allocation. 
 
-Here's how you can use the `useRedisSets` option:
+If you are deleting or clearing a large number of keys you can disable this by setting the `useUnlink` option to `false`. This will use `DEL` instead of `UNLINK` and should reduce the memory usage.
+
+```js
+const keyv = new Keyv(new KeyvRedis('redis://user:pass@localhost:6379', { useUnlink: false }));
+// Or
+keyv.useUnlink = false;
+```
+
+# 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:
+
+```js
+import KeyvRedis from '@keyv/redis';
+import Cacheable from 'cacheable';
+
+const secondary = new KeyvRedis('redis://user:pass@localhost:6379');
+
+const cache = new Cacheable( { secondary } );
+```
+
+For even higher performance you can set the `nonBlocking` option to `true`:
+
+```js
+const cache = new Cacheable( { secondary, nonBlocking: true } );
+```
+
+This will make it so that the secondary does not block the primary cache and will be very fast. 🚀
+
+# Clustering and TLS Support
+
+If you are using a Redis Cluster or need to use TLS, you can pass in the `redisOptions` directly. Here is an example of how to do that:
 
 ```js
 import Keyv from 'keyv';
+import KeyvRedis, { createCluster } from '@keyv/redis';
+
+const cluster = createCluster({
+    rootNodes: [
+      {
+        url: 'redis://127.0.0.1:7000',
+      },
+      {
+        url: 'redis://127.0.0.1:7001',
+      },
+      {
+        url: 'redis://127.0.0.1:7002',
+      },
+    ],
+});
+
+const keyv = new Keyv({ store: new KeyvRedis(cluster) });
+```
+
+Here is an example of how to use TLS:
+
+```js
+import Keyv from 'keyv';
+import KeyvRedis from '@keyv/redis';
 
-const keyv = new Keyv(new KeyvRedis('redis://user:pass@localhost:6379', { useRedisSets: false }));
+const tlsOptions = {
+    socket: {
+      host: 'localhost',
+      port: 6379,
+      tls: true,  // Enable TLS connection
+      rejectUnauthorized: false,  // Ignore self-signed certificate errors (for testing)
+      
+      // Alternatively, provide CA, key, and cert for mutual authentication
+      ca: fs.readFileSync('/path/to/ca-cert.pem'),
+      cert: fs.readFileSync('/path/to/client-cert.pem'),  // Optional for client auth
+      key: fs.readFileSync('/path/to/client-key.pem'),    // Optional for client auth
+    }
+};
+
+const keyv = new Keyv({ store: new KeyvRedis(tlsOptions) });
 ```
 
-## License
+# API
+* **constructor([connection], [options])**
+* **namespace** - The namespace to use for the keys.
+* **client** - The Redis client instance.
+* **keyPrefixSeparator** - The separator to use between the namespace and key.
+* **clearBatchSize** - The number of keys to delete in a single batch.
+* **useUnlink** - Use the `UNLINK` command for deleting keys isntead of `DEL`.
+* **set** - Set a key.
+* **setMany** - Set multiple keys.
+* **get** - Get a key.
+* **getMany** - Get multiple keys.
+* **has** - Check if a key exists.
+* **hasMany** - Check if multiple keys exist.
+* **delete** - Delete a key.
+* **deleteMany** - Delete multiple keys.
+* **clear** - Clear all keys. If the `namespace` is set it will only clear keys with that namespace.
+* **disconnect** - Disconnect from the Redis server.
+* **iterator** - Create a new iterator for the keys.
+
+# Migrating from v3 to v4
+
+The main change in v4 is the removal of the `ioredis` library in favor of the `@keyv/redis` library. This was done to provide a more consistent experience across all Keyv storage adapters. The `@keyv/redis` library is a wrapper around the `redis` library and provides a more consistent experience across all Keyv storage adapters. The only other change is that we no longer do redis sets as they caused performance issues.
+
+# About Redis Sets and its Support in v4
+
+We no longer support redis sets. This is due to the fact that it caused significant performance issues and was not a good fit for the library.
+
+# License
 
 [MIT © Jared Wray](LISCENCE)

package/dist/index.cjs

@@ -0,0 +1,421 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Keyv: () => import_keyv2.Keyv,
+  createClient: () => import_redis2.createClient,
+  createCluster: () => import_redis2.createCluster,
+  createKeyv: () => createKeyv,
+  default: () => KeyvRedis
+});
+module.exports = __toCommonJS(src_exports);
+var import_events = __toESM(require("events"), 1);
+var import_redis = require("redis");
+var import_keyv = require("keyv");
+var import_redis2 = require("redis");
+var import_keyv2 = require("keyv");
+var KeyvRedis = class extends import_events.default {
+  _client = (0, import_redis.createClient)();
+  _namespace;
+  _keyPrefixSeparator = "::";
+  _clearBatchSize = 1e3;
+  _useUnlink = true;
+  /**
+   * KeyvRedis constructor.
+   * @param {string | RedisClientOptions | RedisClientType} [connect] How to connect to the Redis server. If string pass in the url, if object pass in the options, if RedisClient pass in the client.
+   * @param {KeyvRedisOptions} [options] Options for the adapter such as namespace, keyPrefixSeparator, and clearBatchSize.
+   */
+  constructor(connect, options) {
+    super();
+    if (connect) {
+      if (typeof connect === "string") {
+        this._client = (0, import_redis.createClient)({ url: connect });
+      } else if (connect.connect !== void 0) {
+        this._client = connect;
+      } else if (connect instanceof Object) {
+        this._client = (0, import_redis.createClient)(connect);
+      }
+    }
+    this.setOptions(options);
+    this.initClient();
+  }
+  /**
+   * Get the Redis client.
+   */
+  get client() {
+    return this._client;
+  }
+  /**
+   * Set the Redis client.
+   */
+  set client(value) {
+    this._client = value;
+    this.initClient();
+  }
+  /**
+   * Get the options for the adapter.
+   */
+  get opts() {
+    return {
+      namespace: this._namespace,
+      keyPrefixSeparator: this._keyPrefixSeparator,
+      clearBatchSize: this._clearBatchSize,
+      dialect: "redis",
+      url: this._client?.options?.url ?? "redis://localhost:6379"
+    };
+  }
+  /**
+   * Set the options for the adapter.
+   */
+  set opts(options) {
+    this.setOptions(options);
+  }
+  /**
+   * Get the namespace for the adapter. If undefined, it will not use a namespace including keyPrefixing.
+   * @default undefined
+   */
+  get namespace() {
+    return this._namespace;
+  }
+  /**
+   * Set the namespace for the adapter. If undefined, it will not use a namespace including keyPrefixing.
+   */
+  set namespace(value) {
+    this._namespace = value;
+  }
+  /**
+   * Get the separator between the namespace and key.
+   * @default '::'
+   */
+  get keyPrefixSeparator() {
+    return this._keyPrefixSeparator;
+  }
+  /**
+   * Set the separator between the namespace and key.
+   */
+  set keyPrefixSeparator(value) {
+    this._keyPrefixSeparator = value;
+  }
+  /**
+   * Get the number of keys to delete in a single batch.
+   * @default 1000
+   */
+  get clearBatchSize() {
+    return this._clearBatchSize;
+  }
+  /**
+   * Set the number of keys to delete in a single batch.
+   */
+  set clearBatchSize(value) {
+    this._clearBatchSize = value;
+  }
+  /**
+   * Get if Unlink is used instead of Del for clearing keys. This is more performant but may not be supported by all Redis versions.
+   * @default true
+   */
+  get useUnlink() {
+    return this._useUnlink;
+  }
+  /**
+   * Set if Unlink is used instead of Del for clearing keys. This is more performant but may not be supported by all Redis versions.
+   */
+  set useUnlink(value) {
+    this._useUnlink = 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) {
+      await this._client.connect();
+    }
+    return this._client;
+  }
+  /**
+   * Set a key value pair in the store. TTL is in milliseconds.
+   * @param {string} key - the key to set
+   * @param {string} value - the value to set
+   * @param {number} [ttl] - the time to live in milliseconds
+   */
+  async set(key, value, ttl) {
+    const client = await this.getClient();
+    key = this.createKeyPrefix(key, this._namespace);
+    if (ttl) {
+      await client.set(key, value, { PX: ttl });
+    } else {
+      await client.set(key, value);
+    }
+  }
+  /**
+   * Will set many key value pairs in the store. TTL is in milliseconds. This will be done as a single transaction.
+   * @param {Array<KeyvRedisEntry<string>>} entries - the key value pairs to set with optional ttl
+   */
+  async setMany(entries) {
+    const client = await this.getClient();
+    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();
+  }
+  /**
+   * Check if a key exists in the store.
+   * @param {string} key - the key to check
+   * @returns {Promise<boolean>} - true if the key exists, false if not
+   */
+  async has(key) {
+    const client = await this.getClient();
+    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.
+   * @param {Array<string>} keys - the keys to check
+   * @returns {Promise<Array<boolean>>} - array of booleans for each key if it exists
+   */
+  async hasMany(keys) {
+    const client = await this.getClient();
+    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.
+   * @param {string} key - the key to get
+   * @returns {Promise<string | undefined>} - the value or undefined if the key does not exist
+   */
+  async get(key) {
+    const client = await this.getClient();
+    key = this.createKeyPrefix(key, this._namespace);
+    const value = await client.get(key);
+    if (value === null) {
+      return void 0;
+    }
+    return value;
+  }
+  /**
+   * Get many values from the store. If a key does not exist, it will return undefined.
+   * @param {Array<string>} keys - the keys to get
+   * @returns {Promise<Array<string | undefined>>} - array of values or undefined if the key does not exist
+   */
+  async getMany(keys) {
+    const client = await this.getClient();
+    const multi = client.multi();
+    for (const key of keys) {
+      const prefixedKey = this.createKeyPrefix(key, this._namespace);
+      multi.get(prefixedKey);
+    }
+    const values = await multi.exec();
+    return values.map((value) => value === null ? void 0 : value);
+  }
+  /**
+   * Delete a key from the store.
+   * @param {string} key - the key to delete
+   * @returns {Promise<boolean>} - true if the key was deleted, false if not
+   */
+  async delete(key) {
+    const client = await this.getClient();
+    key = this.createKeyPrefix(key, this._namespace);
+    let deleted = 0;
+    if (this._useUnlink) {
+      deleted = await client.unlink(key);
+    } else {
+      deleted = await client.del(key);
+    }
+    return deleted > 0;
+  }
+  /**
+   * Delete many keys from the store. This will be done as a single transaction.
+   * @param {Array<string>} keys - the keys to delete
+   * @returns {Promise<boolean>} - true if any key was deleted, false if not
+   */
+  async deleteMany(keys) {
+    let result = false;
+    const client = await this.getClient();
+    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;
+      }
+    }
+    return result;
+  }
+  /**
+   * Disconnect from the Redis server.
+   * @returns {Promise<void>}
+   */
+  async disconnect() {
+    if (this._client.isOpen) {
+      await this._client.disconnect();
+    }
+  }
+  /**
+   * Helper function to create a key with a namespace.
+   * @param {string} key - the key to prefix
+   * @param {string} namespace - the namespace to prefix the key with
+   * @returns {string} - the key with the namespace such as 'namespace::key'
+   */
+  createKeyPrefix(key, namespace) {
+    if (namespace) {
+      return `${namespace}${this._keyPrefixSeparator}${key}`;
+    }
+    return key;
+  }
+  /**
+   * Helper function to get a key without the namespace.
+   * @param {string} key - the key to remove the namespace from
+   * @param {string} namespace - the namespace to remove from the key
+   * @returns {string} - the key without the namespace such as 'key'
+   */
+  getKeyWithoutPrefix(key, namespace) {
+    if (namespace) {
+      return key.replace(`${namespace}${this._keyPrefixSeparator}`, "");
+    }
+    return key;
+  }
+  /**
+   * Get an async iterator for the keys and values in the store. If a namespace is provided, it will only iterate over keys with that namespace.
+   * @param {string} [namespace] - the namespace to iterate over
+   * @returns {AsyncGenerator<[string, T | undefined], void, unknown>} - async iterator with key value pairs
+   */
+  async *iterator(namespace) {
+    const client = await this.getClient();
+    const match = namespace ? `${namespace}${this._keyPrefixSeparator}*` : "*";
+    let cursor = "0";
+    do {
+      const result = await client.scan(Number.parseInt(cursor, 10), { MATCH: match, TYPE: "string" });
+      cursor = result.cursor.toString();
+      let { keys } = result;
+      if (!namespace) {
+        keys = keys.filter((key) => !key.includes(this._keyPrefixSeparator));
+      }
+      if (keys.length > 0) {
+        const values = await client.mGet(keys);
+        for (const [i] of keys.entries()) {
+          const key = this.getKeyWithoutPrefix(keys[i], namespace);
+          const value = values ? values[i] : void 0;
+          yield [key, value];
+        }
+      }
+    } while (cursor !== "0");
+  }
+  /**
+   * Clear all keys in the store.
+   * IMPORTANT: this can cause performance issues if there are a large number of keys in the store. Use with caution as not recommended for production.
+   * If a namespace is not set it will clear all keys with no prefix.
+   * If a namespace is set it will clear all keys with that namespace.
+   * @returns {Promise<void>}
+   */
+  async clear() {
+    await this.clearNamespace(this._namespace);
+  }
+  async clearNamespace(namespace) {
+    try {
+      let cursor = "0";
+      const batchSize = this._clearBatchSize;
+      const match = namespace ? `${namespace}${this._keyPrefixSeparator}*` : "*";
+      const client = await this.getClient();
+      do {
+        const result = await client.scan(Number.parseInt(cursor, 10), { MATCH: match, COUNT: batchSize, TYPE: "string" });
+        cursor = result.cursor.toString();
+        let { keys } = result;
+        if (keys.length === 0) {
+          continue;
+        }
+        if (!namespace) {
+          keys = keys.filter((key) => !key.includes(this._keyPrefixSeparator));
+        }
+        if (keys.length > 0) {
+          if (this._useUnlink) {
+            await client.unlink(keys);
+          } else {
+            await client.del(keys);
+          }
+        }
+      } while (cursor !== "0");
+    } catch (error) {
+      this.emit("error", error);
+    }
+  }
+  setOptions(options) {
+    if (!options) {
+      return;
+    }
+    if (options.namespace) {
+      this._namespace = options.namespace;
+    }
+    if (options.keyPrefixSeparator) {
+      this._keyPrefixSeparator = options.keyPrefixSeparator;
+    }
+    if (options.clearBatchSize) {
+      this._clearBatchSize = options.clearBatchSize;
+    }
+    if (options.useUnlink !== void 0) {
+      this._useUnlink = options.useUnlink;
+    }
+  }
+  initClient() {
+    this._client.on("error", (error) => {
+      this.emit("error", error);
+    });
+  }
+};
+function createKeyv(connect, options) {
+  const adapter = new KeyvRedis(connect, options);
+  const keyv = new import_keyv.Keyv({ store: adapter, namespace: options?.namespace });
+  return keyv;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Keyv,
+  createClient,
+  createCluster,
+  createKeyv
+});