@keyv/redis 3.0.1 → 4.0.1

package/dist/index.cjs

@@ -30,134 +30,392 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var src_exports = {};
 __export(src_exports, {
-  default: () => src_default
+  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_ioredis = __toESM(require("ioredis"), 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 {
-  ttlSupport = true;
-  namespace;
-  opts;
-  redis;
-  constructor(uri, options) {
+  _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();
-    this.opts = {};
-    this.opts.useRedisSets = true;
-    this.opts.dialect = "redis";
-    if (typeof uri !== "string" && uri.options && ("family" in uri.options || uri.isCluster)) {
-      this.redis = uri;
+    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 {
-      options = { ...typeof uri === "string" ? { uri } : uri, ...options };
-      this.redis = new import_ioredis.default(options.uri, options);
+      await client.set(key, value);
     }
-    if (options !== void 0 && options.useRedisSets === false) {
-      this.opts.useRedisSets = false;
+  }
+  /**
+   * 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);
+      }
     }
-    this.redis.on("error", (error) => this.emit("error", error));
+    await multi.exec();
   }
-  _getNamespace() {
-    return `namespace:${this.namespace}`;
+  /**
+   * 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;
   }
-  _getKeyName = (key) => {
-    if (!this.opts.useRedisSets) {
-      return `sets:${this._getNamespace()}:${key}`;
+  /**
+   * 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);
     }
-    return key;
-  };
+    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) {
-    key = this._getKeyName(key);
-    const value = await this.redis.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) {
-    keys = keys.map(this._getKeyName);
-    return this.redis.mget(keys);
-  }
-  async set(key, value, ttl) {
-    if (value === void 0) {
-      return void 0;
-    }
-    key = this._getKeyName(key);
-    const set = async (redis) => {
-      if (typeof ttl === "number") {
-        await redis.set(key, value, "PX", ttl);
-      } else {
-        await redis.set(key, value);
-      }
-    };
-    if (this.opts.useRedisSets) {
-      const trx = await this.redis.multi();
-      await set(trx);
-      await trx.sadd(this._getNamespace(), key);
-      await trx.exec();
-    } else {
-      await set(this.redis);
+    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) {
-    key = this._getKeyName(key);
-    let items = 0;
-    const unlink = async (redis) => redis.unlink(key);
-    if (this.opts.useRedisSets) {
-      const trx = this.redis.multi();
-      await unlink(trx);
-      await trx.srem(this._getNamespace(), key);
-      const r = await trx.exec();
-      items = r[0][1];
+    const client = await this.getClient();
+    key = this.createKeyPrefix(key, this._namespace);
+    let deleted = 0;
+    if (this._useUnlink) {
+      deleted = await client.unlink(key);
     } else {
-      items = await unlink(this.redis);
+      deleted = await client.del(key);
     }
-    return items > 0;
+    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) {
-    const deletePromises = keys.map(async (key) => this.delete(key));
-    const results = await Promise.allSettled(deletePromises);
-    return results.every((result) => result.value);
-  }
-  async clear() {
-    if (this.opts.useRedisSets) {
-      const keys = await this.redis.smembers(this._getNamespace());
-      if (keys.length > 0) {
-        await Promise.all([
-          this.redis.unlink([...keys]),
-          this.redis.srem(this._getNamespace(), [...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);
       }
-    } else {
-      const pattern = `sets:${this._getNamespace()}:*`;
-      const keys = await this.redis.keys(pattern);
-      if (keys.length > 0) {
-        await this.redis.unlink(keys);
+    }
+    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 scan = this.redis.scan.bind(this.redis);
-    const get = this.redis.mget.bind(this.redis);
+    const client = await this.getClient();
+    const match = namespace ? `${namespace}${this._keyPrefixSeparator}*` : "*";
     let cursor = "0";
     do {
-      const [curs, keys] = await scan(cursor, "MATCH", `${namespace}:*`);
-      cursor = curs;
+      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 get(keys);
+        const values = await client.mGet(keys);
         for (const [i] of keys.entries()) {
-          const key = keys[i];
-          const value = values[i];
+          const key = this.getKeyWithoutPrefix(keys[i], namespace);
+          const value = values ? values[i] : void 0;
           yield [key, value];
         }
       }
     } while (cursor !== "0");
   }
-  async has(key) {
-    const value = await this.redis.exists(key);
-    return value !== 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 disconnect() {
-    return this.redis.disconnect();
+  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);
+    });
   }
 };
-var src_default = KeyvRedis;
+function createKeyv(connect, options) {
+  const adapter = new KeyvRedis(connect, options);
+  const keyv = new import_keyv.Keyv({ store: adapter, namespace: options?.namespace, useKeyPrefix: false });
+  return keyv;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Keyv,
+  createClient,
+  createCluster,
+  createKeyv
+});