fix(client): use smaller cache key

Use smaller cache key when creating clients.
`attachConfig` only cares abour certain properties, so we only need
to cache them: `unstableResp3`, `RESP`, `modules`, `functions` and `scripts`
If users provide different socket options etc, the cache should ignore them
because they are irrelevant from the perspective of `attachConfig`

Author: nkaradzhov

packages/client/lib/client/index.ts

@@ -319,8 +319,8 @@ export default class RedisClient<
     RESP extends RespVersions = 2
   >(config?: CommanderConfig<M, F, S, RESP>) {
 
-
-    let Client = RedisClient.#SingleEntryCache.get(config);
+    const cacheKey = SingleEntryCache.getCacheKey(config);
+    let Client = RedisClient.#SingleEntryCache.get(cacheKey);
     if (!Client) {
       Client = attachConfig({
         BaseClass: RedisClient,
@@ -334,7 +334,7 @@ export default class RedisClient<
 
       Client.prototype.Multi = RedisClientMultiCommand.extend(config);
 
-      RedisClient.#SingleEntryCache.set(config, Client);
+      RedisClient.#SingleEntryCache.set(cacheKey, Client);
     }
 
     return <TYPE_MAPPING extends TypeMapping = {}>(

packages/client/lib/client/pool.ts

@@ -26,20 +26,20 @@ export interface RedisPoolOptions {
   acquireTimeout: number;
   /**
    * The delay in milliseconds before a cleanup operation is performed on idle clients.
-   * 
-   * After this delay, the pool will check if there are too many idle clients and destroy 
+   *
+   * After this delay, the pool will check if there are too many idle clients and destroy
    * excess ones to maintain optimal pool size.
    */
   cleanupDelay: number;
   /**
    * Client Side Caching configuration for the pool.
-   * 
-   * Enables Redis Servers and Clients to work together to cache results from commands 
+   *
+   * Enables Redis Servers and Clients to work together to cache results from commands
    * sent to a server. The server will notify the client when cached results are no longer valid.
    * In pooled mode, the cache is shared across all clients in the pool.
-   * 
+   *
    * Note: Client Side Caching is only supported with RESP3.
-   * 
+   *
    * @example Anonymous cache configuration
    * ```
    * const client = createClientPool({RESP: 3}, {
@@ -51,7 +51,7 @@ export interface RedisPoolOptions {
    *   minimum: 5
    * });
    * ```
-   * 
+   *
    * @example Using a controllable cache
    * ```
    * const cache = new BasicPooledClientSideCache({
@@ -68,11 +68,11 @@ export interface RedisPoolOptions {
   clientSideCache?: PooledClientSideCacheProvider | ClientSideCacheConfig;
   /**
    * Enable experimental support for RESP3 module commands.
-   * 
-   * When enabled, allows the use of module commands that have been adapted 
-   * for the RESP3 protocol. This is an unstable feature and may change in 
+   *
+   * When enabled, allows the use of module commands that have been adapted
+   * for the RESP3 protocol. This is an unstable feature and may change in
    * future versions.
-   * 
+   *
    * @default false
    */
   unstableResp3Modules?: boolean;
@@ -169,7 +169,8 @@ export class RedisClientPool<
     options?: Partial<RedisPoolOptions>
   ) {
 
-    let Pool = RedisClientPool.#SingleEntryCache.get(clientOptions);
+    const cacheKey = SingleEntryCache.getCacheKey(clientOptions);
+    let Pool = RedisClientPool.#SingleEntryCache.get(cacheKey);
     if(!Pool) {
       Pool = attachConfig({
         BaseClass: RedisClientPool,
@@ -181,7 +182,7 @@ export class RedisClientPool<
         config: clientOptions
       });
       Pool.prototype.Multi = RedisClientMultiCommand.extend(clientOptions);
-      RedisClientPool.#SingleEntryCache.set(clientOptions, Pool);
+      RedisClientPool.#SingleEntryCache.set(cacheKey, Pool);
     }
 
     // returning a "proxy" to prevent the namespaces._self to leak between "proxies"
@@ -392,7 +393,7 @@ export class RedisClientPool<
 
     this._self.#returnClient(node);
   }
-  
+
   execute<T>(fn: PoolTask<M, F, S, RESP, TYPE_MAPPING, T>) {
     return new Promise<Awaited<T>>((resolve, reject) => {
       const client = this._self.#idleClients.shift(),
@@ -502,29 +503,29 @@ export class RedisClientPool<
     if (!this._self.#isOpen) return; // TODO: throw err?
 
     this._self.#isClosing = true;
-    
+
     try {
       const promises = [];
 
       for (const client of this._self.#idleClients) {
         promises.push(client.close());
       }
-  
+
       for (const client of this._self.#clientsInUse) {
         promises.push(client.close());
       }
 
       await Promise.all(promises);
 
       this.#clientSideCache?.onPoolClose();
-  
+
       this._self.#idleClients.reset();
       this._self.#clientsInUse.reset();
     } catch (err) {
-      
+
     } finally {
       this._self.#isClosing = false;
-    } 
+    }
   }
 
   destroy() {

packages/client/lib/cluster/index.ts

@@ -260,7 +260,8 @@ export default class RedisCluster<
     // POLICIES extends CommandPolicies = {}
   >(config?: ClusterCommander<M, F, S, RESP, TYPE_MAPPING/*, POLICIES*/>) {
 
-    let Cluster = RedisCluster.#SingleEntryCache.get(config);
+    const cacheKey = SingleEntryCache.getCacheKey(config);
+    let Cluster = RedisCluster.#SingleEntryCache.get(cacheKey);
     if (!Cluster) {
       Cluster = attachConfig({
         BaseClass: RedisCluster,
@@ -273,7 +274,7 @@ export default class RedisCluster<
       });
 
       Cluster.prototype.Multi = RedisClusterMultiCommand.extend(config);
-      RedisCluster.#SingleEntryCache.set(config, Cluster);
+      RedisCluster.#SingleEntryCache.set(cacheKey, Cluster);
     }
 
     return (options?: Omit<RedisClusterOptions, keyof Exclude<typeof config, undefined>>) => {

packages/client/lib/single-entry-cache.ts

@@ -1,3 +1,5 @@
+import { CommanderConfig } from "./RESP/types";
+
 export default class SingleEntryCache<K, V> {
   #cached?: V;
   #serializedKey?: string;
@@ -20,6 +22,28 @@ export default class SingleEntryCache<K, V> {
     this.#cached = obj;
     this.#serializedKey = JSON.stringify(keyObj, makeCircularReplacer());
   }
+
+  /**
+   * Generates a cache key based on the provided CommanderConfig.
+   *
+   * @param config - The CommanderConfig object to derive the cache key from.
+   * @returns An object representing the cache key.
+   *
+   * @remarks
+   * The cache key includes properties like unstableResp3, RESP, modules, functions, and scripts
+   * from the CommanderConfig.
+   */
+  static getCacheKey (config?: CommanderConfig<any, any, any, any>): object {
+    const key: Partial<CommanderConfig<any, any, any, any>> = {};
+    if(config) {
+      key.unstableResp3 = config.unstableResp3;
+      key.RESP = config.RESP;
+      key.modules = config.modules;
+      key.functions = config.functions;
+      key.scripts = config.scripts;
+    }
+    return key;
+  }
 }
 
 function makeCircularReplacer() {
@@ -34,4 +58,4 @@ function makeCircularReplacer() {
     }
     return value;
   }
-}
+}