Update client-side cache and improve documentation

Author: bobymicroby

package-lock.json

@@ -11,16 +11,19 @@ Note: Client Side Caching is only supported with RESP3.
 ### Anonymous Cache
 
 ```javascript
-const client = createClient({RESP: 3, clientSideCache: {ttl: 0, maxEntries: 0, lru: false}})
+const client = createClient({RESP: 3, clientSideCache: {ttl: 0, maxEntries: 0, evictPolicy: "FIFO"}})
 ```
 
 In this instance, the cache is opaque to the user, and they have no control over it.
 
 ### Controllable Cache
 
 ```javascript
-const ttl = 0, maxEntries = 0, lru = false;
-const cache = new BasicClientSideCache(ttl, maxEntries, lru);
+const cache = new BasicClientSideCache({
+  ttl: 0, 
+  maxEntries: 0, 
+  evictPolicy: "FIFO"
+});
 const client = createClient({RESP: 3, clientSideCache: cache});
 ```
 

packages/client/lib/client/README-cache.md

@@ -8,10 +8,31 @@ type CmdFunc = () => Promise<ReplyUnion>;
 
 type EvictionPolicy = "LRU" | "FIFO"
 
+/**
+ * Configuration options for Client Side Cache
+ */
 export interface ClientSideCacheConfig {
+  /**
+   * Time-to-live in milliseconds for cached entries.
+   * Use 0 for no expiration.
+   * @default 0
+   */
   ttl?: number;
+  
+  /**
+   * Maximum number of entries to store in the cache.
+   * Use 0 for unlimited entries.
+   * @default 0
+   */
   maxEntries?: number;
-  evictPolocy?: EvictionPolicy;
+  
+  /**
+   * Eviction policy to use when the cache reaches its capacity.
+   * - "LRU" (Least Recently Used): Evicts least recently accessed entries first
+   * - "FIFO" (First In First Out): Evicts oldest entries first
+   * @default "LRU"
+   */
+  evictPolicy?: EvictionPolicy;
 }
 
 type CacheCreator = {
@@ -109,7 +130,7 @@ export class BasicClientSideCache extends ClientSideCacheProvider {
     this.#keyToCacheKeySetMap = new Map<string, Set<string>>();
     this.ttl = config?.ttl ?? 0;
     this.maxEntries = config?.maxEntries ?? 0;
-    this.lru = config?.evictPolocy !== "FIFO"
+    this.lru = config?.evictPolicy !== "FIFO"
   }
 
   /* logic of how caching works:

packages/client/lib/client/cache.ts

@@ -78,11 +78,60 @@ export interface RedisClientOptions<
    */
   pingInterval?: number;
   /**
-   * TODO
+   * Default command options to be applied to all commands executed through this client.
+   * 
+   * These options can be overridden on a per-command basis when calling specific commands.
+   * 
+   * @property {symbol} [chainId] - Identifier for chaining commands together
+   * @property {boolean} [asap] - When true, the command is executed as soon as possible
+   * @property {AbortSignal} [abortSignal] - AbortSignal to cancel the command
+   * @property {TypeMapping} [typeMapping] - Custom type mappings between RESP and JavaScript types
+   * 
+   * @example Setting default command options
+   * ```
+   * const client = createClient({
+   *   commandOptions: {
+   *     asap: true,
+   *     typeMapping: {
+   *       // Custom type mapping configuration
+   *     }
+   *   }
+   * });
+   * ```
    */
   commandOptions?: CommandOptions<TYPE_MAPPING>;
   /**
-   * TODO
+   * Client Side Caching configuration.
+   * 
+   * 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.
+   * 
+   * Note: Client Side Caching is only supported with RESP3.
+   * 
+   * @example Anonymous cache configuration
+   * ```
+   * const client = createClient({
+   *   RESP: 3, 
+   *   clientSideCache: {
+   *     ttl: 0,
+   *     maxEntries: 0,
+   *     evictPolicy: "LRU" 
+   *   }
+   * });
+   * ```
+   * 
+   * @example Using a controllable cache
+   * ```
+   * const cache = new BasicClientSideCache({ 
+   *   ttl: 0, 
+   *   maxEntries: 0, 
+   *   evictPolicy: "LRU" 
+   * });
+   * const client = createClient({
+   *   RESP: 3, 
+   *   clientSideCache: cache
+   * });
+   * ```
    */
   clientSideCache?: ClientSideCacheProvider | ClientSideCacheConfig;
 }

packages/client/lib/client/index.ts

@@ -24,15 +24,55 @@ export interface RedisPoolOptions {
    */
   acquireTimeout: number;
   /**
-   * TODO
+   * 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 
+   * excess ones to maintain optimal pool size.
    */
   cleanupDelay: number;
   /**
-   * TODO
+   * Client Side Caching configuration for the pool.
+   * 
+   * 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}, {
+   *   clientSideCache: {
+   *     ttl: 0,
+   *     maxEntries: 0,
+   *     evictPolicy: "LRU"
+   *   },
+   *   minimum: 5
+   * });
+   * ```
+   * 
+   * @example Using a controllable cache
+   * ```
+   * const cache = new BasicPooledClientSideCache({
+   *   ttl: 0,
+   *   maxEntries: 0,
+   *   evictPolicy: "LRU"
+   * });
+   * const client = createClientPool({RESP: 3}, {
+   *   clientSideCache: cache,
+   *   minimum: 5
+   * });
+   * ```
    */
   clientSideCache?: PooledClientSideCacheProvider | ClientSideCacheConfig;
   /**
-   * TODO
+   * 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 
+   * future versions.
+   * 
+   * @default false
    */
   unstableResp3Modules?: boolean;
 }