cachimbo 0.0.1 → 0.0.3

package/README.md

@@ -1,23 +1,28 @@
-<img align="right" src="./docs/assets/cachimbo.png" alt="Cachimbo" width="150" height="150">
+<p align="center">
+  <img width="200" src="https://raw.githubusercontent.com/Guichaguri/cachimbo/main/docs/assets/cachimbo.png">
+</p>
 
-# cachimbo
+<h1 align="center">Cachimbo</h1>
 
-Cachimbo is a caching library that allows you to layer different strategies in order to maximize the performance.
+Cachimbo is an advanced caching library that allows you to layer different strategies in order to maximize the performance.
 
 ## Features
 
 - Supports external cache stores
   - Redis
+  - Valkey
   - Memcached
   - Cloudflare Workers KV
+  - Keyv
 - Supports in-memory cache stores
-  - Least Recently Used (LRU)
-  - Time To Live (TTL)
-  - Map-based
+  - Least Recently Used (LRU) eviction
+  - Time-based (TTL) eviction
+  - FIFO eviction
 - Supports intermediary cache strategies
   - Request coalescing (deduplication)
   - Multi-layer caching (tiered cache)
   - Stale-While-Revalidate
+  - TTL jittering
 - Metrics collection
 - Easily extendable
 
@@ -65,25 +70,25 @@ In-memory caches offer extremely low latency since data is stored directly in th
 
 External caches (like Redis, Memcached, etc) provide fast, scalable, shared storage that can be accessed across multiple application instances. They offer high throughput, larger memory capacity, and centralized cache management beyond what in-memory caches can reliably provide.
 
-- [In-memory](./docs/stores/in-memory.md)
-- [Redis](docs/stores/redis-valkey.md) (and Valkey)
-- [Memcached](./docs/stores/memcached.md)
-- [Cloudflare Workers KV](./docs/stores/cloudflare-workers-kv.md)
-- [Keyv](./stores/keyv.md)
+- [In-memory](/docs/stores/in-memory.md)
+- [Redis](/docs/stores/redis-valkey.md) (and Valkey)
+- [Memcached](/docs/stores/memcached.md)
+- [Cloudflare Workers KV](/docs/stores/cloudflare-workers-kv.md)
+- [Keyv](/docs/stores/keyv.md)
 
 ## Cache Layers
 
 These layers work just like "middlewares" but for caches, they customize how a cache is handled.
 
-- [Request Coalescing](./docs/layers/request-coalescing.md) (deduplication)
-- [Tiered Caching](./docs/layers/tiered.md) (multi-layer caching)
-- [Stale-While-Revalidate](./docs/layers/stale-while-revalidate.md)
-- [TTL Jittering](./docs/layers/jittering.md)
-- [Async/Lazy Initialization](./docs/layers/async-lazy.md)
-- [Key Transformation](./docs/layers/key-transformation.md)
-- [Metrics Collection](./docs/layers/metrics-collection.md)
+- [Request Coalescing](/docs/layers/request-coalescing.md) (deduplication)
+- [Tiered Caching](/docs/layers/tiered.md) (multi-layer caching)
+- [Stale-While-Revalidate](/docs/layers/stale-while-revalidate.md)
+- [TTL Jittering](/docs/layers/jittering.md)
+- [Async/Lazy Initialization](/docs/layers/async-lazy.md)
+- [Key Transformation](/docs/layers/key-transformation.md)
+- [Metrics Collection](/docs/layers/metrics-collection.md)
 
 ## Guides
-- [Choosing the right combination of layers](./docs/guides/choosing-layers.md)
-- [Disabling cache](./docs/guides/disabling.md)
-- [Extending](./docs/guides/extending.md)
+- [Choosing the right combination of layers](/docs/guides/choosing-layers.md)
+- [Disabling cache](/docs/guides/disabling.md)
+- [Extending](/docs/guides/extending.md)

package/dist/index.cjs

@@ -40,6 +40,67 @@ var BaseCache = class {
 	}
 };
 
+//#endregion
+//#region src/base/local.ts
+var BaseLocalCache = class extends BaseCache {
+	disposeListeners = [];
+	/**
+	* Reads cached resources by their keys. (synchronous version)
+	* @protected
+	*/
+	_getMany(keys) {
+		return Object.fromEntries(keys.map((key) => [key, this._get(key)]));
+	}
+	/**
+	* Writes resources into cache. (synchronous version)
+	* @protected
+	*/
+	_setMany(data, options) {
+		for (const [key, value] of Object.entries(data)) this._set(key, value, options);
+	}
+	/**
+	* Deletes many cached resources by their keys. (synchronous version)
+	* @protected
+	*/
+	_deleteMany(keys) {
+		for (const key of keys) this._delete(key);
+	}
+	/**
+	* Adds a listener that will be called when a cached item is disposed.
+	*
+	* @param listener The listener function to add.
+	* @protected
+	*/
+	_addDisposeListener(listener) {
+		this.disposeListeners.push(listener);
+	}
+	get(key) {
+		return Promise.resolve(this._get(key));
+	}
+	set(key, value, options) {
+		this._set(key, value, options);
+		return Promise.resolve();
+	}
+	delete(key) {
+		this._delete(key);
+		return Promise.resolve();
+	}
+	getMany(keys) {
+		return Promise.resolve(this._getMany(keys));
+	}
+	setMany(data, options) {
+		this._setMany(data, options);
+		return Promise.resolve();
+	}
+	deleteMany(keys) {
+		this._deleteMany(keys);
+		return Promise.resolve();
+	}
+	onDispose(key, value, reason) {
+		for (const listener of this.disposeListeners) listener(key, value, reason);
+	}
+};
+
 //#endregion
 //#region src/local/lru/index.ts
 /**
@@ -49,7 +110,7 @@ var BaseCache = class {
 *
 * Once the limit of items is reached, the least recently used items will be purged.
 */
-var LocalLRUCache = class extends BaseCache {
+var LocalLRUCache = class extends BaseLocalCache {
 	cache;
 	shouldUseFetch;
 	constructor(options = {}) {
@@ -62,16 +123,29 @@ var LocalLRUCache = class extends BaseCache {
 				ttl: options.ttl ? options.ttl * 1e3 : void 0,
 				max: options.max || 1e4,
 				ttlAutopurge: false,
-				fetchMethod: (_key, _staleValue, options$1) => options$1.context()
+				fetchMethod: (_key, _staleValue, options$1) => options$1.context(),
+				disposeAfter: (value, key, reason) => this.onDispose(key, value, reason)
 			});
 			this.shouldUseFetch = true;
 		}
 	}
-	async get(key) {
+	/** @internal */
+	_get(key) {
 		this.logger?.debug(this.name, "[get]", "key =", key);
 		const data = this.cache.get(key);
 		return data === void 0 ? null : data;
 	}
+	/** @internal */
+	_set(key, value, options) {
+		this.logger?.debug(this.name, "[set]", "key =", key);
+		const ttl = options?.ttl;
+		this.cache.set(key, value, { ttl: ttl ? ttl * 1e3 : void 0 });
+	}
+	/** @internal */
+	_delete(key) {
+		this.logger?.debug(this.name, "[delete]", "key =", key);
+		this.cache.delete(key);
+	}
 	getOrLoad(key, load, options) {
 		if (!this.shouldUseFetch) return super.getOrLoad(key, load, options);
 		this.logger?.debug(this.name, "[getOrLoad] Running LRUCache's fetch...", "key =", key);
@@ -81,15 +155,6 @@ var LocalLRUCache = class extends BaseCache {
 			ttl: ttl ? ttl * 1e3 : void 0
 		});
 	}
-	async set(key, value, options) {
-		this.logger?.debug(this.name, "[set]", "key =", key);
-		const ttl = options?.ttl;
-		this.cache.set(key, value, { ttl: ttl ? ttl * 1e3 : void 0 });
-	}
-	async delete(key) {
-		this.logger?.debug(this.name, "[delete]", "key =", key);
-		this.cache.delete(key);
-	}
 };
 
 //#endregion
@@ -99,27 +164,31 @@ var LocalLRUCache = class extends BaseCache {
 *
 * Once the limit of items is reached, the soonest expiring items will be purged.
 */
-var LocalTTLCache = class extends BaseCache {
+var LocalTTLCache = class extends BaseLocalCache {
 	cache;
 	constructor(options = {}) {
 		super(options);
 		if ("cache" in options) this.cache = options.cache;
 		else this.cache = new __isaacs_ttlcache.TTLCache({
 			max: options.max,
-			ttl: options.ttl ? options.ttl * 1e3 : void 0
+			ttl: options.ttl ? options.ttl * 1e3 : void 0,
+			dispose: (value, key, reason) => this.onDispose(key, value, reason)
 		});
 	}
-	async get(key) {
+	/** @internal */
+	_get(key) {
 		this.logger?.debug(this.name, "[get]", "key =", key);
 		const data = this.cache.get(key);
 		return data === void 0 ? null : data;
 	}
-	async set(key, value, options) {
+	/** @internal */
+	_set(key, value, options) {
 		this.logger?.debug(this.name, "[set]", "key =", key);
 		const ttl = options?.ttl;
 		this.cache.set(key, value, { ttl: ttl ? ttl * 1e3 : void 0 });
 	}
-	async delete(key) {
+	/** @internal */
+	_delete(key) {
 		this.logger?.debug(this.name, "[delete]", "key =", key);
 		this.cache.delete(key);
 	}
@@ -132,9 +201,10 @@ var LocalTTLCache = class extends BaseCache {
 *
 * It ignores expiration times, but a limit of cached items can be set.
 *
+* It implements a simple FIFO eviction policy:
 * Once the limit of items is reached, the first inserted keys will be purged.
 */
-var LocalMapCache = class extends BaseCache {
+var LocalMapCache = class extends BaseLocalCache {
 	cache;
 	max;
 	constructor(options = {}) {
@@ -142,38 +212,55 @@ var LocalMapCache = class extends BaseCache {
 		this.cache = options.cache ?? /* @__PURE__ */ new Map();
 		this.max = options.max ?? Infinity;
 	}
-	async get(key) {
+	/** @internal */
+	_get(key) {
 		this.logger?.debug(this.name, "[get]", "key =", key);
 		const data = this.cache.get(key);
 		return data === void 0 ? null : data;
 	}
-	async set(key, value, options) {
+	/** @internal */
+	_set(key, value, options) {
 		this.logger?.debug(this.name, "[set]", "key =", key);
-		if (this.cache.size >= this.max && !this.cache.has(key)) this.evict(1);
+		const previousValue = this.cache.get(key);
+		if (this.cache.size >= this.max && previousValue === void 0) this.evict(1);
 		this.cache.set(key, value);
+		this.onDispose(key, previousValue, "set");
 	}
-	async delete(key) {
+	/** @internal */
+	_delete(key) {
 		this.logger?.debug(this.name, "[delete]", "key =", key);
+		const previousValue = this.cache.get(key);
 		this.cache.delete(key);
+		this.onDispose(key, previousValue, "delete");
 	}
 	async setMany(data, options) {
 		this.logger?.debug(this.name, "[setMany]", "data =", data);
 		const entries = Object.entries(data);
 		const newEntries = entries.filter(([key]) => !this.cache.has(key)).length;
 		if (this.cache.size + newEntries > this.max) this.evict(this.cache.size + newEntries - this.max);
-		for (const [key, value] of entries) this.cache.set(key, value);
+		for (const [key, value] of entries) {
+			const previousValue = this.cache.get(key);
+			this.cache.set(key, value);
+			this.onDispose(key, previousValue, "set");
+		}
 	}
 	clear() {
 		this.logger?.debug(this.name, "[clear]");
+		for (const key of this.cache.keys()) this.onDispose(key, this.cache.get(key), "delete");
 		this.cache.clear();
 	}
+	onDispose(key, value, reason) {
+		if (value !== void 0) super.onDispose(key, value, reason);
+	}
 	evict(length) {
 		const keys = this.cache.keys();
 		for (let i = 0; i < length; i++) {
 			const key = keys.next();
 			if (key.done) break;
 			this.logger?.debug(this.name, "[evict]", "key = ", key);
+			const previousValue = this.cache.get(key.value);
 			this.cache.delete(key.value);
+			this.onDispose(key.value, previousValue, "evict");
 		}
 	}
 };
@@ -182,7 +269,7 @@ var LocalMapCache = class extends BaseCache {
 //#region src/local/noop/index.ts
 /**
 * A cache implementation that does nothing.
-* It's useful for disabling cache.
+* It's useful for disabling cache and unit testing.
 *
 * @example
 * ```ts
@@ -214,12 +301,14 @@ var NoOpCache = class {
 var IORedisCache = class extends BaseCache {
 	client;
 	defaultTTL;
+	isUNLINKSupported;
 	isMSETEXSupported;
 	constructor(options) {
 		super(options);
 		this.client = options.client;
 		this.defaultTTL = options.defaultTTL;
-		this.isMSETEXSupported = options.isMSETEXSupported;
+		this.isUNLINKSupported = options.isUNLINKSupported ?? true;
+		this.isMSETEXSupported = options.isMSETEXSupported ?? false;
 	}
 	async get(key) {
 		this.logger?.debug(this.name, "[get] Running \"GET\" command...", "key =", key);
@@ -234,8 +323,13 @@ var IORedisCache = class extends BaseCache {
 		else await this.client.set(key, raw);
 	}
 	async delete(key) {
-		this.logger?.debug(this.name, "[delete] Running \"DEL\" command...", "key =", key);
-		await this.client.del(key);
+		if (this.isUNLINKSupported) {
+			this.logger?.debug(this.name, "[delete] Running \"UNLINK\" command...", "key =", key);
+			await this.client.unlink(key);
+		} else {
+			this.logger?.debug(this.name, "[delete] Running \"DEL\" command...", "key =", key);
+			await this.client.del(key);
+		}
 	}
 	async getMany(keys) {
 		this.logger?.debug(this.name, "[getMany] Running \"MGET\" command...", "keys =", keys);
@@ -256,8 +350,13 @@ var IORedisCache = class extends BaseCache {
 		await this.client.call("MSETEX", entries.length, ...raw, ...ttl ? ["EX", ttl] : []);
 	}
 	async deleteMany(keys) {
-		this.logger?.debug(this.name, "[deleteMany] Running \"DEL\" command...", "keys =", keys);
-		await this.client.del(keys);
+		if (this.isUNLINKSupported) {
+			this.logger?.debug(this.name, "[deleteMany] Running \"UNLINK\" command...", "keys =", keys);
+			await this.client.unlink(keys);
+		} else {
+			this.logger?.debug(this.name, "[deleteMany] Running \"DEL\" command...", "keys =", keys);
+			await this.client.del(keys);
+		}
 	}
 };
 
@@ -269,12 +368,14 @@ var IORedisCache = class extends BaseCache {
 var RedisCache = class extends BaseCache {
 	client;
 	defaultTTL;
+	isUNLINKSupported;
 	isMSETEXSupported;
 	constructor(options) {
 		super(options);
 		this.client = options.client;
 		this.defaultTTL = options.defaultTTL;
-		this.isMSETEXSupported = options.isMSETEXSupported;
+		this.isUNLINKSupported = options.isUNLINKSupported ?? true;
+		this.isMSETEXSupported = options.isMSETEXSupported ?? false;
 	}
 	async get(key) {
 		this.logger?.debug(this.name, "[get] Running \"GET\" command...", "key =", key);
@@ -290,8 +391,13 @@ var RedisCache = class extends BaseCache {
 		} : void 0 });
 	}
 	async delete(key) {
-		this.logger?.debug(this.name, "[delete] Running \"DEL\" command...", "key =", key);
-		await this.client.del(key);
+		if (this.isUNLINKSupported) {
+			this.logger?.debug(this.name, "[delete] Running \"UNLINK\" command...", "key =", key);
+			await this.client.unlink(key);
+		} else {
+			this.logger?.debug(this.name, "[delete] Running \"DEL\" command...", "key =", key);
+			await this.client.del(key);
+		}
 	}
 	async getMany(keys) {
 		this.logger?.debug(this.name, "[getMany] Running \"MGET\" command...", "keys =", keys);
@@ -315,8 +421,13 @@ var RedisCache = class extends BaseCache {
 		} : void 0 });
 	}
 	async deleteMany(keys) {
-		this.logger?.debug(this.name, "[deleteMany] Running \"DEL\" command...", "keys =", keys);
-		await this.client.del(keys);
+		if (this.isUNLINKSupported) {
+			this.logger?.debug(this.name, "[deleteMany] Running \"UNLINK\" command...", "keys =", keys);
+			await this.client.unlink(keys);
+		} else {
+			this.logger?.debug(this.name, "[deleteMany] Running \"DEL\" command...", "keys =", keys);
+			await this.client.del(keys);
+		}
 	}
 };
 
@@ -347,8 +458,8 @@ var ValkeyGlideCache = class extends BaseCache {
 		} : void 0 });
 	}
 	async delete(key) {
-		this.logger?.debug(this.name, "[delete] Running \"DEL\" command...", "key =", key);
-		await this.client.del([key]);
+		this.logger?.debug(this.name, "[delete] Running \"UNLINK\" command...", "key =", key);
+		await this.client.unlink([key]);
 	}
 	async getMany(keys) {
 		this.logger?.debug(this.name, "[getMany] Running \"MGET\" command...", "keys =", keys);
@@ -361,8 +472,8 @@ var ValkeyGlideCache = class extends BaseCache {
 		return data;
 	}
 	async deleteMany(keys) {
-		this.logger?.debug(this.name, "[deleteMany] Running \"DEL\" command...", "keys =", keys);
-		await this.client.del(keys);
+		this.logger?.debug(this.name, "[deleteMany] Running \"UNLINK\" command...", "keys =", keys);
+		await this.client.unlink(keys);
 	}
 };
 

package/dist/index.d.cts

@@ -119,6 +119,56 @@ declare abstract class BaseCache implements ICache {
   deleteMany(keys: string[]): Promise<void>;
 }
 //#endregion
+//#region src/base/local.d.ts
+type LocalCacheDisposeListener<T = any> = (key: string, value: T, reason?: string) => void;
+declare abstract class BaseLocalCache extends BaseCache {
+  protected disposeListeners: LocalCacheDisposeListener[];
+  /**
+   * Reads the cached resource from a key (synchronous version)
+   * @protected
+   */
+  abstract _get<T>(key: string): T | null;
+  /**
+   * Writes a resource into cache (synchronous version)
+   * @protected
+   */
+  abstract _set<T>(key: string, value: T, options?: SetCacheOptions): void;
+  /**
+   * Deletes a cached resource by a key. (synchronous version)
+   * @protected
+   */
+  abstract _delete(key: string): void;
+  /**
+   * Reads cached resources by their keys. (synchronous version)
+   * @protected
+   */
+  _getMany<T>(keys: string[]): Record<string, T | null>;
+  /**
+   * Writes resources into cache. (synchronous version)
+   * @protected
+   */
+  _setMany<T>(data: Record<string, T>, options?: SetCacheOptions): void;
+  /**
+   * Deletes many cached resources by their keys. (synchronous version)
+   * @protected
+   */
+  _deleteMany(keys: string[]): void;
+  /**
+   * Adds a listener that will be called when a cached item is disposed.
+   *
+   * @param listener The listener function to add.
+   * @protected
+   */
+  _addDisposeListener(listener: LocalCacheDisposeListener): void;
+  get<T>(key: string): Promise<T | null>;
+  set<T>(key: string, value: T, options?: SetCacheOptions): Promise<void>;
+  delete(key: string): Promise<void>;
+  getMany<T>(keys: string[]): Promise<Record<string, T | null>>;
+  setMany<T>(data: Record<string, T>, options?: SetCacheOptions): Promise<void>;
+  deleteMany(keys: string[]): Promise<void>;
+  protected onDispose(key: string, value: any, reason?: string): void;
+}
+//#endregion
 //#region src/local/lru/index.d.ts
 interface ExistingLRUCacheOptions extends BaseCacheOptions {
   /**
@@ -154,14 +204,11 @@ interface LocalLRUCacheOptions extends BaseCacheOptions {
  *
  * Once the limit of items is reached, the least recently used items will be purged.
  */
-declare class LocalLRUCache extends BaseCache {
+declare class LocalLRUCache extends BaseLocalCache {
   protected readonly cache: LRUCache<string, any, () => Promise<any>>;
   protected shouldUseFetch?: boolean;
   constructor(options?: LocalLRUCacheOptions | ExistingLRUCacheOptions);
-  get<T>(key: string): Promise<T | null>;
   getOrLoad<T>(key: string, load: () => Promise<T>, options?: SetCacheOptions): Promise<T>;
-  set<T>(key: string, value: T, options?: SetCacheOptions): Promise<void>;
-  delete(key: string): Promise<void>;
 }
 //#endregion
 //#region src/local/ttl/index.d.ts
@@ -186,12 +233,9 @@ interface LocalTTLCacheOptions extends BaseCacheOptions {
  *
  * Once the limit of items is reached, the soonest expiring items will be purged.
  */
-declare class LocalTTLCache extends BaseCache {
+declare class LocalTTLCache extends BaseLocalCache {
   protected readonly cache: TTLCache<string, any>;
   constructor(options?: LocalTTLCacheOptions | ExistingTTLCacheOptions);
-  get<T>(key: string): Promise<T | null>;
-  set<T>(key: string, value: T, options?: SetCacheOptions): Promise<void>;
-  delete(key: string): Promise<void>;
 }
 //#endregion
 //#region src/local/map/index.d.ts
@@ -220,24 +264,23 @@ interface MapLike<K, V> {
  *
  * It ignores expiration times, but a limit of cached items can be set.
  *
+ * It implements a simple FIFO eviction policy:
  * Once the limit of items is reached, the first inserted keys will be purged.
  */
-declare class LocalMapCache extends BaseCache {
+declare class LocalMapCache extends BaseLocalCache {
   protected readonly cache: MapLike<string, any>;
   protected max: number;
   constructor(options?: LocalMapCacheOptions);
-  get<T>(key: string): Promise<T | null>;
-  set<T>(key: string, value: T, options?: SetCacheOptions): Promise<void>;
-  delete(key: string): Promise<void>;
   setMany(data: Record<string, any>, options?: SetCacheOptions): Promise<void>;
   clear(): void;
+  protected onDispose(key: string, value: any, reason?: string): void;
   protected evict(length: number): void;
 }
 //#endregion
 //#region src/local/noop/index.d.ts
 /**
  * A cache implementation that does nothing.
- * It's useful for disabling cache.
+ * It's useful for disabling cache and unit testing.
  *
  * @example
  * ```ts
@@ -265,6 +308,17 @@ interface IORedisCacheOptions extends BaseCacheOptions {
    * The default Time To Live in seconds
    */
   defaultTTL?: number;
+  /**
+   * Indicates whether the Redis server supports the UNLINK command.
+   *
+   * {@link IORedisCache#delete} and {@link IORedisCache#deleteMany} will use UNLINK instead of DEL if this
+   * option is set to `true`. This is recommended to improve the deletion performance.
+   *
+   * This option should be set to `true` if the server runs Redis OSS 4.0.0 or above.
+   *
+   * @defaultValue true
+   */
+  isUNLINKSupported?: boolean;
   /**
    * Indicates whether the Redis server supports the MSETEX command.
    *
@@ -272,6 +326,8 @@ interface IORedisCacheOptions extends BaseCacheOptions {
    *
    * This option should be set to `true` if the server runs Redis OSS 8.4.0 or above.
    * Valkey does not support this yet. (see https://github.com/valkey-io/valkey/issues/2592)
+   *
+   * @defaultValue false
    */
   isMSETEXSupported?: boolean;
 }
@@ -281,7 +337,8 @@ interface IORedisCacheOptions extends BaseCacheOptions {
 declare class IORedisCache extends BaseCache {
   protected readonly client: Redis | Redis$1;
   protected defaultTTL?: number;
-  protected isMSETEXSupported?: boolean;
+  protected isUNLINKSupported: boolean;
+  protected isMSETEXSupported: boolean;
   constructor(options: IORedisCacheOptions);
   get<T>(key: string): Promise<T | null>;
   set<T>(key: string, value: T, options?: SetCacheOptions): Promise<void>;
@@ -303,12 +360,26 @@ interface RedisCacheOptions extends BaseCacheOptions {
    */
   defaultTTL?: number;
   /**
-   * Indicates whether the Redis server supports MSETEX command.
+   * Indicates whether the Redis server supports the UNLINK command.
+   *
+   * {@link RedisCache#delete} and {@link RedisCache#deleteMany} will use UNLINK instead of DEL if this
+   * option is set to `true`. This is recommended to improve the deletion performance.
+   *
+   * This option should be set to `true` if the server runs Redis OSS 4.0.0 or above.
+   *
+   * @defaultValue true
+   */
+  isUNLINKSupported?: boolean;
+  /**
+   * Indicates whether the Redis server supports the MSETEX command.
    *
    * {@link RedisCache#setMany} will use MSETEX if this option is set to `true`.
+   * This is recommended to improve the performance of setting multiple items.
    *
    * This option should be set to `true` if the server runs Redis OSS 8.4.0 or above.
    * Valkey does not support this yet. (see https://github.com/valkey-io/valkey/issues/2592)
+   *
+   * @defaultValue false
    */
   isMSETEXSupported?: boolean;
 }
@@ -318,7 +389,8 @@ interface RedisCacheOptions extends BaseCacheOptions {
 declare class RedisCache extends BaseCache {
   protected readonly client: Redis$2;
   protected defaultTTL?: number;
-  protected isMSETEXSupported?: boolean;
+  protected isUNLINKSupported: boolean;
+  protected isMSETEXSupported: boolean;
   constructor(options: RedisCacheOptions);
   get<T>(key: string): Promise<T | null>;
   set<T>(key: string, value: T, options?: SetCacheOptions): Promise<void>;