implement parser conversion with firs GET command implemented

Author: sjpotter

packages/client/lib/RESP/types.ts

@@ -1,3 +1,4 @@
+import { CommandParser } from '../client/parser';
 import { BlobError, SimpleError } from '../errors';
 import { RedisScriptConfig, SHA1 } from '../lua-script';
 import { RESP_TYPES } from './decoder';
@@ -272,6 +273,7 @@ export type Command = {
    */
   IS_FORWARD_COMMAND?: boolean;
   // POLICIES?: CommandPolicies;
+  parseCommand?(this: void, parser: CommandParser, ...args: Array<any>): void;
   transformArguments(this: void, ...args: Array<any>): CommandArguments;
   TRANSFORM_LEGACY_REPLY?: boolean;
   transformReply: TransformReply | Record<RespVersions, TransformReply>;

packages/client/lib/client/index.ts

@@ -7,14 +7,15 @@ import { ClientClosedError, ClientOfflineError, DisconnectsClientError, WatchErr
 import { URL } from 'node:url';
 import { TcpSocketConnectOpts } from 'node:net';
 import { PUBSUB_TYPE, PubSubType, PubSubListener, PubSubTypeListeners, ChannelListeners } from './pub-sub';
-import { Command, CommandSignature, TypeMapping, CommanderConfig, RedisFunction, RedisFunctions, RedisModules, RedisScript, RedisScripts, ReplyUnion, RespVersions, RedisArgument, ReplyWithTypeMapping, SimpleStringReply } from '../RESP/types';
+import { Command, CommandSignature, TypeMapping, CommanderConfig, RedisFunction, RedisFunctions, RedisModules, RedisScript, RedisScripts, ReplyUnion, RespVersions, RedisArgument, ReplyWithTypeMapping, SimpleStringReply, TransformReply } from '../RESP/types';
 import RedisClientMultiCommand, { RedisClientMultiCommandType } from './multi-command';
 import { RedisMultiQueuedCommand } from '../multi-command';
 import HELLO, { HelloOptions } from '../commands/HELLO';
 import { ScanOptions, ScanCommonOptions } from '../commands/SCAN';
 import { RedisLegacyClient, RedisLegacyClientType } from './legacy-mode';
 import { RedisPoolOptions, RedisClientPool } from './pool';
 import { RedisVariadicArgument, pushVariadicArguments } from '../commands/generic-transformers';
+import { BasicCommandParser, CommandParser } from './parser';
 
 export interface RedisClientOptions<
   M extends RedisModules = RedisModules,
@@ -151,52 +152,84 @@ export default class RedisClient<
 > extends EventEmitter {
   static #createCommand(command: Command, resp: RespVersions) {
     const transformReply = getTransformReply(command, resp);
+
     return async function (this: ProxyClient, ...args: Array<unknown>) {
-      const redisArgs = command.transformArguments(...args),
-        reply = await this.sendCommand(redisArgs, this._commandOptions);
-      return transformReply ?
-        transformReply(reply, redisArgs.preserve) :
-        reply;
-    };
+      if (command.parseCommand) {
+        const parser = this._self.#newCommandParser(resp);
+        command.parseCommand(parser, ...args);
+
+        return this.executeCommand(undefined, parser, this._commandOptions, transformReply);
+      } else {
+        const redisArgs = command.transformArguments(...args),
+          reply = await this.sendCommand(redisArgs, this._commandOptions);
+        return transformReply ?
+          transformReply(reply, redisArgs.preserve) :
+          reply;
+      };
+    }
   }
 
   static #createModuleCommand(command: Command, resp: RespVersions) {
     const transformReply = getTransformReply(command, resp);
+
     return async function (this: NamespaceProxyClient, ...args: Array<unknown>) {
-      const redisArgs = command.transformArguments(...args),
-        reply = await this._self.sendCommand(redisArgs, this._self._commandOptions);
-      return transformReply ?
-        transformReply(reply, redisArgs.preserve) :
-        reply;
+      if (command.parseCommand) {
+        const parser = this._self._self.#newCommandParser(resp);
+        command.parseCommand(parser, ...args);
+
+        return this._self.executeCommand(undefined, parser, this._self._commandOptions, transformReply);
+      } else {
+        const redisArgs = command.transformArguments(...args),
+          reply = await this._self.sendCommand(redisArgs, this._self._commandOptions);
+        return transformReply ?
+          transformReply(reply, redisArgs.preserve) :
+          reply;
+      }
     };
   }
 
   static #createFunctionCommand(name: string, fn: RedisFunction, resp: RespVersions) {
-    const prefix = functionArgumentsPrefix(name, fn),
-      transformReply = getTransformReply(fn, resp);
+    const prefix = functionArgumentsPrefix(name, fn);
+    const transformReply = getTransformReply(fn, resp);
+
     return async function (this: NamespaceProxyClient, ...args: Array<unknown>) {
-      const fnArgs = fn.transformArguments(...args),
-        reply = await this._self.sendCommand(
-          prefix.concat(fnArgs),
-          this._self._commandOptions
-        );
-      return transformReply ?
-        transformReply(reply, fnArgs.preserve) :
-        reply;
+      if (fn.parseCommand) {
+        const parser = this._self._self.#newCommandParser(resp);
+        fn.parseCommand(parser, ...args);
+
+        return this._self.executeCommand(prefix, parser, this._self._commandOptions, transformReply);
+      } else {
+        const fnArgs = fn.transformArguments(...args),
+          reply = await this._self.sendCommand(
+            prefix.concat(fnArgs),
+            this._self._commandOptions
+          );
+        return transformReply ?
+          transformReply(reply, fnArgs.preserve) :
+          reply;
+      }
     };
   }
 
   static #createScriptCommand(script: RedisScript, resp: RespVersions) {
-    const prefix = scriptArgumentsPrefix(script),
-      transformReply = getTransformReply(script, resp);
+    const prefix = scriptArgumentsPrefix(script);
+    const transformReply = getTransformReply(script, resp);
+
     return async function (this: ProxyClient, ...args: Array<unknown>) {
-      const scriptArgs = script.transformArguments(...args),
-        redisArgs = prefix.concat(scriptArgs),
-        reply = await this.executeScript(script, redisArgs, this._commandOptions);
-      return transformReply ?
-        transformReply(reply, scriptArgs.preserve) :
-        reply;
-    };
+      if (script.parseCommand) {
+        const parser = this._self.#newCommandParser(resp);
+        script.parseCommand(parser, ...args);
+
+        return this.executeCommand(prefix, parser, this._commandOptions, transformReply);
+      } else {
+        const scriptArgs = script.transformArguments(...args),
+          redisArgs = prefix.concat(scriptArgs),
+          reply = await this.executeScript(script, redisArgs, this._commandOptions);
+        return transformReply ?
+          transformReply(reply, scriptArgs.preserve) :
+          reply;
+      };
+    }
   }
 
   static factory<
@@ -309,6 +342,10 @@ export default class RedisClient<
     this._self.#dirtyWatch = msg;
   }
 
+  #newCommandParser(resp: RespVersions): CommandParser {
+    return new BasicCommandParser(resp);
+  }
+
   constructor(options?: RedisClientOptions<M, F, S, RESP, TYPE_MAPPING>) {
     super();
     this.#options = this.#initiateOptions(options);
@@ -573,6 +610,24 @@ export default class RedisClient<
     return this as unknown as RedisClientType<M, F, S, RESP, TYPE_MAPPING>;
   }
 
+  async executeCommand<T = ReplyUnion>(
+    prefix: Array<string | Buffer> | undefined,
+    parser: CommandParser,
+    commandOptions: CommandOptions<TYPE_MAPPING> | undefined,
+    transformReply: TransformReply | undefined
+  ) {
+    const redisArgs = prefix ? prefix.concat(parser.redisArgs) : parser.redisArgs;
+    const fn = () => { return this.sendCommand(redisArgs, commandOptions) };
+
+    const reply = await fn();
+      
+    if (transformReply) {
+      return transformReply(reply, parser.preserve);
+    }
+
+    return reply;
+  }
+    
   sendCommand<T = ReplyUnion>(
     args: Array<RedisArgument>,
     options?: CommandOptions

packages/client/lib/client/multi-command.ts

@@ -2,6 +2,7 @@ import COMMANDS from '../commands';
 import RedisMultiCommand, { MULTI_REPLY, MultiReply, MultiReplyType, RedisMultiQueuedCommand } from '../multi-command';
 import { ReplyWithTypeMapping, CommandReply, Command, CommandArguments, CommanderConfig, RedisFunctions, RedisModules, RedisScripts, RespVersions, TransformReply, RedisScript, RedisFunction, TypeMapping } from '../RESP/types';
 import { attachConfig, functionArgumentsPrefix, getTransformReply } from '../commander';
+import { BasicCommandParser } from './parser';
 
 type CommandSignature<
   REPLIES extends Array<unknown>,
@@ -88,31 +89,64 @@ type ExecuteMulti = (commands: Array<RedisMultiQueuedCommand>, selectedDB?: numb
 export default class RedisClientMultiCommand<REPLIES = []> {
   static #createCommand(command: Command, resp: RespVersions) {
     const transformReply = getTransformReply(command, resp);
+
     return function (this: RedisClientMultiCommand, ...args: Array<unknown>) {
+      let redisArgs: CommandArguments;
+
+      if (command.parseCommand) {
+        const parser = new BasicCommandParser(resp);
+        command.parseCommand(parser, ...args);
+        redisArgs = parser.redisArgs;
+      } else {
+        redisArgs = command.transformArguments(...args);
+      }
+
       return this.addCommand(
-        command.transformArguments(...args),
+        redisArgs,
         transformReply
       );
     };
   }
 
   static #createModuleCommand(command: Command, resp: RespVersions) {
     const transformReply = getTransformReply(command, resp);
+
     return function (this: { _self: RedisClientMultiCommand }, ...args: Array<unknown>) {
+      let redisArgs: CommandArguments;
+
+      if (command.parseCommand) {
+        const parser = new BasicCommandParser(resp);
+        command.parseCommand(parser, ...args);
+        redisArgs = parser.redisArgs;
+      } else {
+        redisArgs = command.transformArguments(...args);
+      }
+
       return this._self.addCommand(
-        command.transformArguments(...args),
+        redisArgs,
         transformReply
       );
     };
   }
 
   static #createFunctionCommand(name: string, fn: RedisFunction, resp: RespVersions) {
-    const prefix = functionArgumentsPrefix(name, fn),
-      transformReply = getTransformReply(fn, resp);
+    const prefix = functionArgumentsPrefix(name, fn);
+    const transformReply = getTransformReply(fn, resp);
+
     return function (this: { _self: RedisClientMultiCommand }, ...args: Array<unknown>) {
-      const fnArgs = fn.transformArguments(...args),
-        redisArgs: CommandArguments = prefix.concat(fnArgs);
+      let fnArgs: CommandArguments;
+
+      if (fn.parseCommand) {
+        const parser = new BasicCommandParser(resp);
+        fn.parseCommand(parser, ...args);
+        fnArgs = parser.redisArgs;
+      } else {
+        fnArgs = fn.transformArguments(...args);
+      }
+
+      const redisArgs: CommandArguments = prefix.concat(fnArgs);
       redisArgs.preserve = fnArgs.preserve;
+
       return this._self.addCommand(
         redisArgs,
         transformReply
@@ -122,12 +156,24 @@ export default class RedisClientMultiCommand<REPLIES = []> {
 
   static #createScriptCommand(script: RedisScript, resp: RespVersions) {
     const transformReply = getTransformReply(script, resp);
+
     return function (this: RedisClientMultiCommand, ...args: Array<unknown>) {
+      let redisArgs: CommandArguments;
+
+      if (script.parseCommand) {
+        const parser = new BasicCommandParser(resp);
+        script.parseCommand(parser, ...args);
+        redisArgs = parser.redisArgs;
+      } else {
+        redisArgs = script.transformArguments(...args);
+      }
+
       this.#multi.addScript(
         script,
-        script.transformArguments(...args),
+        redisArgs,
         transformReply
       );
+      
       return this;
     };
   }

packages/client/lib/client/parser.ts

@@ -0,0 +1,92 @@
+import { RedisArgument, RespVersions } from "../..";
+import { RedisVariadicArgument } from "../commands/generic-transformers";
+
+export interface CommandParser {
+  redisArgs: Array<RedisArgument>;
+  respVersion: RespVersions;
+  preserve: unknown;
+  
+  push: (arg: RedisArgument) => unknown;
+  pushVariadic: (vals: RedisVariadicArgument) => unknown;
+  pushKey: (key: RedisArgument) => unknown; // normal push of keys
+  pushKeys: (keys: RedisVariadicArgument) => unknown; // push multiple keys at a time
+  setCachable: () => unknown;
+  setPreserve: (val: unknown) => unknown;
+}
+
+export abstract class AbstractCommandParser implements CommandParser {
+  #redisArgs: Array<RedisArgument> = [];
+  #respVersion: RespVersions;
+  #preserve: unknown;
+
+  constructor(respVersion: RespVersions = 2) {
+    this.#respVersion = respVersion;
+  }
+
+  get redisArgs() {
+    return this.#redisArgs;
+  }
+
+  get respVersion() {
+    return this.#respVersion;
+  }
+
+  get preserve() {
+    return this.#preserve;
+  }
+
+  push(arg: RedisArgument) {
+    this.#redisArgs.push(arg);
+
+  };
+
+  pushVariadic(vals: RedisVariadicArgument) {
+    if (Array.isArray(vals)) {
+      for (const val of vals) {
+        this.push(val);
+      }
+    } else {
+      this.push(vals);
+    }
+  }
+
+  pushKey(key: RedisArgument) {
+    this.#redisArgs.push(key);
+  };
+
+  pushKeys(keys: RedisVariadicArgument) {
+    if (Array.isArray(keys)) {
+      this.#redisArgs.push(...keys);
+    } else {
+      this.#redisArgs.push(keys);
+    }
+  }
+
+  setPreserve(val: unknown) {
+    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);
+  }
+}