@keyv/redis 3.0.1 → 4.0.1

package/dist/index.js

@@ -1,132 +1,388 @@
 // src/index.ts
 import EventEmitter from "events";
-import Redis from "ioredis";
+import { createClient } from "redis";
+import { Keyv } from "keyv";
+import {
+  createClient as createClient2,
+  createCluster
+} from "redis";
+import {
+  Keyv as Keyv2
+} from "keyv";
 var KeyvRedis = class extends EventEmitter {
-  ttlSupport = true;
-  namespace;
-  opts;
-  redis;
-  constructor(uri, options) {
+  _client = 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 = createClient({ url: connect });
+      } else if (connect.connect !== void 0) {
+        this._client = connect;
+      } else if (connect instanceof Object) {
+        this._client = 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 Redis(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 Keyv({ store: adapter, namespace: options?.namespace, useKeyPrefix: false });
+  return keyv;
+}
 export {
-  src_default as default
+  Keyv2 as Keyv,
+  createClient2 as createClient,
+  createCluster,
+  createKeyv,
+  KeyvRedis as default
 };

package/package.json

@@ -1,80 +1,80 @@
 {
-	"name": "@keyv/redis",
-	"version": "3.0.1",
-	"description": "Redis storage adapter for Keyv",
-	"type": "module",
-	"main": "dist/index.cjs",
-	"module": "dist/index.js",
-	"types": "dist/index.d.ts",
-	"exports": {
-		".": {
-			"require": "./dist/index.cjs",
-			"import": "./dist/index.js"
-		}
-	},
-	"scripts": {
-		"build": "rm -rf dist && tsup src/index.ts --format cjs,esm --dts --clean",
-		"prepare": "yarn build",
-		"test": "xo --fix && vitest run --coverage",
-		"test:ci": "xo && vitest --run --sequence.setupFiles=list",
-		"clean": "rm -rf node_modules && rm -rf ./coverage"
-	},
-	"xo": {
-		"rules": {
-			"import/no-named-as-default": "off",
-			"unicorn/prefer-module": "off",
-			"unicorn/prefer-event-target": "off",
-			"unicorn/prefer-node-protocol": "off",
-			"unicorn/no-typeof-undefined": "off",
-			"import/extensions": "off",
-			"@typescript-eslint/no-unsafe-call": "off",
-			"@typescript-eslint/no-unsafe-assignment": "off",
-			"@typescript-eslint/no-unsafe-return": "off",
-			"unicorn/prefer-ternary": "off",
-			"unicorn/no-array-callback-reference": "off",
-			"import/no-extraneous-dependencies": "off",
-			"@typescript-eslint/no-confusing-void-expression": "off"
-		}
-	},
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/jaredwray/keyv.git"
-	},
-	"keywords": [
-		"redis",
-		"keyv",
-		"storage",
-		"adapter",
-		"key",
-		"value",
-		"store",
-		"cache",
-		"ttl"
-	],
-	"author": "Jared Wray <me@jaredwray.com> (http://jaredwray.com)",
-	"license": "MIT",
-	"bugs": {
-		"url": "https://github.com/jaredwray/keyv/issues"
-	},
-	"homepage": "https://github.com/jaredwray/keyv",
-	"dependencies": {
-		"ioredis": "^5.4.1"
-	},
-	"devDependencies": {
-		"@keyv/test-suite": "*",
-		"keyv": "^5.0.0",
-		"timekeeper": "^2.3.1",
-		"tsd": "^0.31.1",
-		"xo": "^0.59.3"
-	},
-	"tsd": {
-		"directory": "test"
-	},
-	"engines": {
-		"node": ">= 18"
-	},
-	"files": [
-		"dist",
-		"LICENSE"
-	]
-}
+  "name": "@keyv/redis",
+  "version": "4.0.1",
+  "description": "Redis storage adapter for Keyv",
+  "type": "module",
+  "main": "dist/index.cjs",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "require": "./dist/index.cjs",
+      "import": "./dist/index.js"
+    }
+  },
+  "xo": {
+    "rules": {
+      "import/no-named-as-default": "off",
+      "unicorn/prefer-module": "off",
+      "unicorn/prefer-event-target": "off",
+      "unicorn/prefer-node-protocol": "off",
+      "unicorn/no-typeof-undefined": "off",
+      "import/extensions": "off",
+      "@typescript-eslint/no-unsafe-call": "off",
+      "@typescript-eslint/no-unsafe-assignment": "off",
+      "@typescript-eslint/no-unsafe-return": "off",
+      "unicorn/prefer-ternary": "off",
+      "unicorn/no-array-callback-reference": "off",
+      "import/no-extraneous-dependencies": "off",
+      "@typescript-eslint/no-confusing-void-expression": "off"
+    }
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jaredwray/keyv.git"
+  },
+  "keywords": [
+    "redis",
+    "keyv",
+    "storage",
+    "adapter",
+    "key",
+    "value",
+    "store",
+    "cache",
+    "ttl"
+  ],
+  "author": "Jared Wray <me@jaredwray.com> (http://jaredwray.com)",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/jaredwray/keyv/issues"
+  },
+  "homepage": "https://github.com/jaredwray/keyv",
+  "dependencies": {
+    "redis": "^4.7.0",
+    "keyv": "*"
+  },
+  "devDependencies": {
+    "@keyv/test-suite": "*",
+    "rimraf": "^6.0.1",
+    "timekeeper": "^2.3.1",
+    "tsd": "^0.31.2",
+    "xo": "^0.59.3"
+  },
+  "tsd": {
+    "directory": "test"
+  },
+  "engines": {
+    "node": ">= 18"
+  },
+  "files": [
+    "dist",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "rimraf ./dist && tsup src/index.ts --format cjs,esm --dts --clean",
+    "test": "xo --fix && vitest run --coverage",
+    "test:ci": "xo && vitest --run --sequence.setupFiles=list",
+    "clean": "rimraf ./node_modules ./coverage ./dist"
+  }
+}