Add client side caching RESP3 validation

Author: bobymicroby

packages/client/index.ts

@@ -35,6 +35,5 @@ export { SetOptions } from './lib/commands/SET';
 
 export { REDIS_FLUSH_MODES } from './lib/commands/FLUSHALL';
 
-import { BasicClientSideCache, BasicPooledClientSideCache } from './lib/client/cache';
-export { BasicClientSideCache, BasicPooledClientSideCache };
+export { BasicClientSideCache, BasicPooledClientSideCache } from './lib/client/cache';
 

packages/client/lib/client/index.spec.ts

@@ -24,10 +24,44 @@ export const SQUARE_SCRIPT = defineScript({
 });
 
 describe('Client', () => {
+  describe('initialization', () => {
+    describe('clientSideCache validation', () => {
+      const clientSideCacheConfig = { ttl: 0, maxEntries: 0 };
+
+      it('should throw error when clientSideCache is enabled with RESP 2', () => {
+        assert.throws(
+          () => new RedisClient({
+            clientSideCache: clientSideCacheConfig,
+            RESP: 2,
+          }),
+          new Error('Client Side Caching is only supported with RESP3')
+        );
+      });
+
+      it('should throw error when clientSideCache is enabled with RESP undefined', () => {
+        assert.throws(
+          () => new RedisClient({
+            clientSideCache: clientSideCacheConfig,
+          }),
+          new Error('Client Side Caching is only supported with RESP3')
+        );
+      });
+
+      it('should not throw when clientSideCache is enabled with RESP 3', () => {
+        assert.doesNotThrow(() =>
+          new RedisClient({
+            clientSideCache: clientSideCacheConfig,
+            RESP: 3,
+          })
+        );
+      });
+    });
+  });
+
   describe('parseURL', () => {
     it('redis://user:secret@localhost:6379/0', async () => {
       const result = RedisClient.parseURL('redis://user:secret@localhost:6379/0');
-      const expected : RedisClientOptions = {
+      const expected: RedisClientOptions = {
         socket: {
           host: 'localhost',
           port: 6379
@@ -51,8 +85,8 @@ describe('Client', () => {
       // Compare non-function properties
       assert.deepEqual(resultRest, expectedRest);
 
-      if(result.credentialsProvider.type === 'async-credentials-provider'
-        && expected.credentialsProvider.type === 'async-credentials-provider') {
+      if (result?.credentialsProvider?.type === 'async-credentials-provider'
+        && expected?.credentialsProvider?.type === 'async-credentials-provider') {
 
         // Compare the actual output of the credentials functions
         const resultCreds = await result.credentialsProvider.credentials();
@@ -91,10 +125,10 @@ describe('Client', () => {
 
       // Compare non-function properties
       assert.deepEqual(resultRest, expectedRest);
-      assert.equal(resultCredProvider.type, expectedCredProvider.type);
+      assert.equal(resultCredProvider?.type, expectedCredProvider?.type);
 
-      if (result.credentialsProvider.type === 'async-credentials-provider' &&
-        expected.credentialsProvider.type === 'async-credentials-provider') {
+      if (result?.credentialsProvider?.type === 'async-credentials-provider' &&
+        expected?.credentialsProvider?.type === 'async-credentials-provider') {
 
         // Compare the actual output of the credentials functions
         const resultCreds = await result.credentialsProvider.credentials();
@@ -150,11 +184,11 @@ describe('Client', () => {
 
     testUtils.testWithClient('Client can authenticate using the streaming credentials provider for initial token acquisition',
       async client => {
-      assert.equal(
-        await client.ping(),
-        'PONG'
-      );
-    }, GLOBAL.SERVERS.STREAMING_AUTH);
+        assert.equal(
+          await client.ping(),
+          'PONG'
+        );
+      }, GLOBAL.SERVERS.STREAMING_AUTH);
 
     testUtils.testWithClient('should execute AUTH before SELECT', async client => {
       assert.equal(
@@ -408,7 +442,7 @@ describe('Client', () => {
   });
 
   testUtils.testWithClient('functions', async client => {
-    const [,, reply] = await Promise.all([
+    const [, , reply] = await Promise.all([
       loadMathFunction(client),
       client.set('key', '2'),
       client.math.square('key')
@@ -522,8 +556,8 @@ describe('Client', () => {
     const hash: Record<string, string> = {};
     const expectedFields: Array<string> = [];
     for (let i = 0; i < 100; i++) {
-       hash[i.toString()] = i.toString();
-       expectedFields.push(i.toString());
+      hash[i.toString()] = i.toString();
+      expectedFields.push(i.toString());
     }
 
     await client.hSet('key', hash);
@@ -842,7 +876,7 @@ describe('Client', () => {
 
     testUtils.testWithClient('should be able to go back to "normal mode"', async client => {
       await Promise.all([
-        client.monitor(() => {}),
+        client.monitor(() => { }),
         client.reset()
       ]);
       await assert.doesNotReject(client.ping());

packages/client/lib/client/index.ts

@@ -80,14 +80,14 @@ export interface RedisClientOptions<
   pingInterval?: number;
   /**
    * 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({
@@ -103,33 +103,33 @@ export interface RedisClientOptions<
   commandOptions?: CommandOptions<TYPE_MAPPING>;
   /**
    * Client Side Caching configuration.
-   * 
-   * 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.
-   * 
+   *
    * Note: Client Side Caching is only supported with RESP3.
-   * 
+   *
    * @example Anonymous cache configuration
    * ```
    * const client = createClient({
-   *   RESP: 3, 
+   *   RESP: 3,
    *   clientSideCache: {
    *     ttl: 0,
    *     maxEntries: 0,
-   *     evictPolicy: "LRU" 
+   *     evictPolicy: "LRU"
    *   }
    * });
    * ```
-   * 
+   *
    * @example Using a controllable cache
    * ```
-   * const cache = new BasicClientSideCache({ 
-   *   ttl: 0, 
-   *   maxEntries: 0, 
-   *   evictPolicy: "LRU" 
+   * const cache = new BasicClientSideCache({
+   *   ttl: 0,
+   *   maxEntries: 0,
+   *   evictPolicy: "LRU"
    * });
    * const client = createClient({
-   *   RESP: 3, 
+   *   RESP: 3,
    *   clientSideCache: cache
    * });
    * ```
@@ -141,36 +141,36 @@ type WithCommands<
   RESP extends RespVersions,
   TYPE_MAPPING extends TypeMapping
 > = {
-  [P in keyof typeof COMMANDS]: CommandSignature<(typeof COMMANDS)[P], RESP, TYPE_MAPPING>;
-};
+    [P in keyof typeof COMMANDS]: CommandSignature<(typeof COMMANDS)[P], RESP, TYPE_MAPPING>;
+  };
 
 type WithModules<
   M extends RedisModules,
   RESP extends RespVersions,
   TYPE_MAPPING extends TypeMapping
 > = {
-  [P in keyof M]: {
-    [C in keyof M[P]]: CommandSignature<M[P][C], RESP, TYPE_MAPPING>;
+    [P in keyof M]: {
+      [C in keyof M[P]]: CommandSignature<M[P][C], RESP, TYPE_MAPPING>;
+    };
   };
-};
 
 type WithFunctions<
   F extends RedisFunctions,
   RESP extends RespVersions,
   TYPE_MAPPING extends TypeMapping
 > = {
-  [L in keyof F]: {
-    [C in keyof F[L]]: CommandSignature<F[L][C], RESP, TYPE_MAPPING>;
+    [L in keyof F]: {
+      [C in keyof F[L]]: CommandSignature<F[L][C], RESP, TYPE_MAPPING>;
+    };
   };
-};
 
 type WithScripts<
   S extends RedisScripts,
   RESP extends RespVersions,
   TYPE_MAPPING extends TypeMapping
 > = {
-  [P in keyof S]: CommandSignature<S[P], RESP, TYPE_MAPPING>;
-};
+    [P in keyof S]: CommandSignature<S[P], RESP, TYPE_MAPPING>;
+  };
 
 export type RedisClientExtensions<
   M extends RedisModules = {},
@@ -179,11 +179,11 @@ export type RedisClientExtensions<
   RESP extends RespVersions = 2,
   TYPE_MAPPING extends TypeMapping = {}
 > = (
-  WithCommands<RESP, TYPE_MAPPING> &
-  WithModules<M, RESP, TYPE_MAPPING> &
-  WithFunctions<F, RESP, TYPE_MAPPING> &
-  WithScripts<S, RESP, TYPE_MAPPING>
-);
+    WithCommands<RESP, TYPE_MAPPING> &
+    WithModules<M, RESP, TYPE_MAPPING> &
+    WithFunctions<F, RESP, TYPE_MAPPING> &
+    WithScripts<S, RESP, TYPE_MAPPING>
+  );
 
 export type RedisClientType<
   M extends RedisModules = {},
@@ -192,9 +192,9 @@ export type RedisClientType<
   RESP extends RespVersions = 2,
   TYPE_MAPPING extends TypeMapping = {}
 > = (
-  RedisClient<M, F, S, RESP, TYPE_MAPPING> &
-  RedisClientExtensions<M, F, S, RESP, TYPE_MAPPING>
-);
+    RedisClient<M, F, S, RESP, TYPE_MAPPING> &
+    RedisClientExtensions<M, F, S, RESP, TYPE_MAPPING>
+  );
 
 type ProxyClient = RedisClient<any, any, any, any, any>;
 
@@ -363,8 +363,8 @@ export default class RedisClient<
   #monitorCallback?: MonitorCallback<TYPE_MAPPING>;
   private _self = this;
   private _commandOptions?: CommandOptions<TYPE_MAPPING>;
-  // flag used to annotate that the client 
-  // was in a watch transaction when 
+  // flag used to annotate that the client
+  // was in a watch transaction when
   // a topology change occured
   #dirtyWatch?: string;
   #watchEpoch?: number;
@@ -419,7 +419,7 @@ export default class RedisClient<
 
   constructor(options?: RedisClientOptions<M, F, S, RESP, TYPE_MAPPING>) {
     super();
-
+    this.#validateOptions(options)
     this.#options = this.#initiateOptions(options);
     this.#queue = this.#initiateQueue();
     this.#socket = this.#initiateSocket();
@@ -435,6 +435,12 @@ export default class RedisClient<
     }
   }
 
+  #validateOptions(options?: RedisClientOptions<M, F, S, RESP, TYPE_MAPPING>) {
+    if (options?.clientSideCache && options?.RESP !== 3) {
+      throw new Error('Client Side Caching is only supported with RESP3');
+    }
+
+  }
   #initiateOptions(options?: RedisClientOptions<M, F, S, RESP, TYPE_MAPPING>): RedisClientOptions<M, F, S, RESP, TYPE_MAPPING> | undefined {
 
     // Convert username/password to credentialsProvider if no credentialsProvider is already in place
@@ -492,7 +498,7 @@ export default class RedisClient<
     }
   }
 
-   #subscribeForStreamingCredentials(cp: StreamingCredentialsProvider): Promise<[BasicAuth, Disposable]> {
+  #subscribeForStreamingCredentials(cp: StreamingCredentialsProvider): Promise<[BasicAuth, Disposable]> {
     return cp.subscribe({
       onNext: credentials => {
         this.reAuthenticate(credentials).catch(error => {
@@ -527,7 +533,7 @@ export default class RedisClient<
 
       if (cp && cp.type === 'streaming-credentials-provider') {
 
-        const [credentials, disposable]  = await this.#subscribeForStreamingCredentials(cp)
+        const [credentials, disposable] = await this.#subscribeForStreamingCredentials(cp)
         this.#credentialsSubscription = disposable;
 
         if (credentials.password) {
@@ -563,7 +569,7 @@ export default class RedisClient<
 
       if (cp && cp.type === 'streaming-credentials-provider') {
 
-        const [credentials, disposable]  = await this.#subscribeForStreamingCredentials(cp)
+        const [credentials, disposable] = await this.#subscribeForStreamingCredentials(cp)
         this.#credentialsSubscription = disposable;
 
         if (credentials.username || credentials.password) {
@@ -1024,7 +1030,7 @@ export default class RedisClient<
    * @internal
    */
   async _executePipeline(
-    commands: Array<RedisMultiQueuedCommand>,  
+    commands: Array<RedisMultiQueuedCommand>,
     selectedDB?: number
   ) {
     if (!this._self.#socket.isOpen) {
@@ -1075,8 +1081,8 @@ export default class RedisClient<
     const typeMapping = this._commandOptions?.typeMapping;
     const chainId = Symbol('MULTI Chain');
     const promises = [
-        this._self.#queue.addCommand(['MULTI'], { chainId }),
-      ];
+      this._self.#queue.addCommand(['MULTI'], { chainId }),
+    ];
 
     for (const { args } of commands) {
       promises.push(

packages/client/lib/cluster/cluster-slots.spec.ts

@@ -0,0 +1,48 @@
+import { strict as assert } from 'node:assert';
+import { EventEmitter } from 'node:events';
+import { RedisClusterOptions, RedisClusterClientOptions } from './index';
+import RedisClusterSlots from './cluster-slots';
+
+describe('RedisClusterSlots', () => {
+  describe('initialization', () => {
+
+    describe('clientSideCache validation', () => {
+      const mockEmit = ((_event: string | symbol, ..._args: any[]): boolean => true) as EventEmitter['emit'];
+      const clientSideCacheConfig = { ttl: 0, maxEntries: 0 };
+      const rootNodes: Array<RedisClusterClientOptions> = [
+        { socket: { host: 'localhost', port: 30001 } }
+      ];
+
+      it('should throw error when clientSideCache is enabled with RESP 2', () => {
+        assert.throws(
+          () => new RedisClusterSlots({
+            rootNodes,
+            clientSideCache: clientSideCacheConfig,
+            RESP: 2 as const,
+          }, mockEmit),
+          new Error('Client Side Caching is only supported with RESP3')
+        );
+      });
+
+      it('should throw error when clientSideCache is enabled with RESP undefined', () => {
+        assert.throws(
+          () => new RedisClusterSlots({
+            rootNodes,
+            clientSideCache: clientSideCacheConfig,
+          }, mockEmit),
+          new Error('Client Side Caching is only supported with RESP3')
+        );
+      });
+
+      it('should not throw when clientSideCache is enabled with RESP 3', () => {
+        assert.doesNotThrow(() =>
+          new RedisClusterSlots({
+            rootNodes,
+            clientSideCache: clientSideCacheConfig,
+            RESP: 3 as const,
+          }, mockEmit)
+        );
+      });
+    });
+  });
+});