simplify parser, only have a single parser.

Author: sjpotter

packages/client/lib/client/parser.ts

@@ -2,22 +2,29 @@ import { RedisArgument, RespVersions } from "../..";
 import { RedisVariadicArgument } from "../commands/generic-transformers";
 
 export interface CommandParser {
-  redisArgs: Array<RedisArgument>;
+  redisArgs: ReadonlyArray<RedisArgument>;
+  keys: ReadonlyArray<RedisArgument>;
+  firstKey: RedisArgument | undefined;
   respVersion: RespVersions;
   preserve: unknown;
+  cachable: boolean;
 
   push: (arg: RedisArgument) => unknown;
   pushVariadic: (vals: RedisVariadicArgument) => unknown;
+  pushVariadicNumber: (vals: number | Array<number>) => unknown;
   pushKey: (key: RedisArgument) => unknown; // normal push of keys
   pushKeys: (keys: RedisVariadicArgument) => unknown; // push multiple keys at a time
+  pushKeysLength: (keys: RedisVariadicArgument) => unknown; // push multiple keys at a time
   setCachable: () => unknown;
   setPreserve: (val: unknown) => unknown;
 }
 
-export abstract class AbstractCommandParser implements CommandParser {
+export class BasicCommandParser implements CommandParser {
   #redisArgs: Array<RedisArgument> = [];
+  #keys: Array<RedisArgument> = []; 
   #respVersion: RespVersions;
   #preserve: unknown;
+  #cachable: boolean = false;
 
   constructor(respVersion: RespVersions = 2) {
     this.#respVersion = respVersion;
@@ -27,6 +34,14 @@ export abstract class AbstractCommandParser implements CommandParser {
     return this.#redisArgs;
   }
 
+  get keys() {
+    return this.#keys;
+  }
+
+  get firstKey() {
+    return this.#keys.length != 0 ? this.#keys[0] : undefined;
+  }
+
   get respVersion() {
     return this.#respVersion;
   }
@@ -35,9 +50,12 @@ export abstract class AbstractCommandParser implements CommandParser {
     return this.#preserve;
   }
 
+  get cachable() {
+    return this.#cachable
+  }
+
   push(arg: RedisArgument) {
     this.#redisArgs.push(arg);
-
   };
 
   pushVariadic(vals: RedisVariadicArgument) {
@@ -50,14 +68,36 @@ export abstract class AbstractCommandParser implements CommandParser {
     }
   }
 
+  pushVariadicNumber(vals: number | number[]) {
+    if (Array.isArray(vals)) {
+      for (const val of vals) {
+        this.push(val.toString());
+      }
+    } else {
+      this.push(vals.toString());
+    }
+  }
+
   pushKey(key: RedisArgument) {
+    this.#keys.push(key);
     this.#redisArgs.push(key);
   };
 
+  pushKeysLength(keys: RedisVariadicArgument) {
+    if (Array.isArray(keys)) {
+      this.#redisArgs.push(keys.length.toString());
+    } else {
+      this.#redisArgs.push('1');
+    }
+    this.pushKeys(keys);
+  }
+
   pushKeys(keys: RedisVariadicArgument) {
     if (Array.isArray(keys)) {
+      this.#keys.push(...keys);
       this.#redisArgs.push(...keys);
     } else {
+      this.#keys.push(keys);
       this.#redisArgs.push(keys);
     }
   }
@@ -66,27 +106,7 @@ export abstract class AbstractCommandParser implements CommandParser {
     this.#preserve = val;
   }
 
-  setCachable() {};
-}
-
-/* Note: I do it this way, where BasicCommandParser extends Abstract without any changes,
-   and CachedCommandParser extends Abstract with changes, to enable them to be easily 
-   distinguishable at runtime.  If Cached extended Basic, then Cached would also be a Basic,
-   thereby making them harder to distinguish.
-*/
-export class BasicCommandParser extends AbstractCommandParser {};
-
-export interface ClusterCommandParser extends CommandParser {
-  firstKey: RedisArgument | undefined;
-}
-
-export class BasicClusterCommandParser extends BasicCommandParser  implements ClusterCommandParser {
-  firstKey: RedisArgument | undefined;
-
-  override pushKey(key: RedisArgument): void {
-    if (!this.firstKey) {
-      this.firstKey = key;
-    }
-    super.pushKey(key);
-  }
+  setCachable() {
+    this.#cachable = true;
+  };
 }

packages/client/lib/cluster/index.ts

@@ -10,7 +10,8 @@ import { PubSubListener } from '../client/pub-sub';
 import { ErrorReply } from '../errors';
 import { RedisTcpSocketOptions } from '../client/socket';
 import ASKING from '../commands/ASKING';
-import { BasicClusterCommandParser, ClusterCommandParser } from '../client/parser';
+import { BasicCommandParser, CommandParser } from '../client/parser';
+;
 
 interface ClusterCommander<
   M extends RedisModules,
@@ -408,8 +409,8 @@ export default class RedisCluster<
     return this._self.#slots.isOpen;
   }
 
-  #newCommandParser(resp: RespVersions): ClusterCommandParser {
-    return new BasicClusterCommandParser(resp);
+  #newCommandParser(resp: RespVersions): CommandParser {
+    return new BasicCommandParser(resp);
   }
 
   constructor(options: RedisClusterOptions<M, F, S, RESP, TYPE_MAPPING/*, POLICIES*/>) {