@keyv/redis 3.0.0 → 4.0.0

package/dist/index.js

@@ -0,0 +1,388 @@
+// src/index.ts
+import EventEmitter from "events";
+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 {
+  _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();
+    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 {
+      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 Keyv({ store: adapter, namespace: options?.namespace });
+  return keyv;
+}
+export {
+  Keyv2 as Keyv,
+  createClient2 as createClient,
+  createCluster,
+  createKeyv,
+  KeyvRedis as default
+};

package/package.json

@@ -1,78 +1,80 @@
 {
-	"name": "@keyv/redis",
-	"version": "3.0.0",
-	"description": "Redis storage adapter for Keyv",
-	"main": "dist/cjs/index.js",
-	"module": "dist/esm/index.js",
-	"types": "dist/esm/index.d.ts",
-	"exports": {
-		".": {
-			"require": "./dist/cjs/index.js",
-			"import": "./dist/esm/index.js"
-		}
-	},
-	"scripts": {
-		"build": "rm -rf dist && tsc --project tsconfig.cjs.json && tsc --project tsconfig.esm.json",
-		"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": {
-			"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.0",
+  "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"
+  }
+}

package/dist/cjs/index.d.ts

@@ -1,22 +0,0 @@
-import EventEmitter from 'events';
-import { type KeyvStoreAdapter, type StoredData } from 'keyv';
-import { type KeyvRedisOptions, type KeyvUriOptions } from './types.js';
-declare class KeyvRedis extends EventEmitter implements KeyvStoreAdapter {
-    ttlSupport: boolean;
-    namespace?: string;
-    opts: Record<string, unknown>;
-    redis: any;
-    constructor(uri: KeyvRedisOptions | KeyvUriOptions, options?: KeyvRedisOptions);
-    _getNamespace(): string;
-    _getKeyName: (key: string) => string;
-    get<Value>(key: string): Promise<StoredData<Value> | undefined>;
-    getMany<Value>(keys: string[]): Promise<Array<StoredData<Value | undefined>>>;
-    set(key: string, value: any, ttl?: number): Promise<undefined>;
-    delete(key: string): Promise<boolean>;
-    deleteMany(keys: string[]): Promise<boolean>;
-    clear(): Promise<void>;
-    iterator(namespace?: string): AsyncGenerator<any[], void, unknown>;
-    has(key: string): Promise<boolean>;
-    disconnect(): Promise<any>;
-}
-export default KeyvRedis;