Request response policies

examples/lua-multi-incr.js

@@ -7,6 +7,7 @@ const client = createClient({
   scripts: {
     mincr: defineScript({
       NUMBER_OF_KEYS: 2,
+      // TODO add RequestPolicy: , 
       SCRIPT:
         'return {' +
         'redis.pcall("INCRBY", KEYS[1], ARGV[1]),' +

packages/client/lib/client/parser.ts

@@ -44,6 +44,14 @@ export class BasicCommandParser implements CommandParser {
     return tmp.join('_');
   }
 
+  get commandName(): string | undefined {
+    let cmdName = this.#redisArgs[0];
+    if (cmdName instanceof Buffer) {
+      return cmdName.toString();
+    }
+    return cmdName;
+  }
+
   push(...arg: Array<RedisArgument>) {
     this.#redisArgs.push(...arg);
   };

packages/client/lib/cluster/index.ts

@@ -13,6 +13,7 @@ import { ClientSideCacheConfig, PooledClientSideCacheProvider } from '../client/
 import { BasicCommandParser } from '../client/parser';
 import { ASKING_CMD } from '../commands/ASKING';
 import SingleEntryCache from '../single-entry-cache'
+import { POLICIES, PolicyResolver, StaticPolicyResolver } from './request-response-policies';
 interface ClusterCommander<
   M extends RedisModules,
   F extends RedisFunctions,
@@ -192,6 +193,7 @@ export default class RedisCluster<
         parser.firstKey,
         command.IS_READ_ONLY,
         this._commandOptions,
+        parser.commandName!,
         (client, opts) => client._executeCommand(command, parser, opts, transformReply)
       );
     };
@@ -208,6 +210,7 @@ export default class RedisCluster<
         parser.firstKey,
         command.IS_READ_ONLY,
         this._self._commandOptions,
+        parser.commandName!,
         (client, opts) => client._executeCommand(command, parser, opts, transformReply)
       );
     };
@@ -226,6 +229,7 @@ export default class RedisCluster<
         parser.firstKey,
         fn.IS_READ_ONLY,
         this._self._commandOptions,
+        parser.commandName!,
         (client, opts) => client._executeCommand(fn, parser, opts, transformReply)
       );
     };
@@ -244,6 +248,7 @@ export default class RedisCluster<
         parser.firstKey,
         script.IS_READ_ONLY,
         this._commandOptions,
+        parser.commandName!,
         (client, opts) => client._executeScript(script, parser, opts, transformReply)
       );
     };
@@ -299,6 +304,7 @@ export default class RedisCluster<
 
   private _self = this;
   private _commandOptions?: ClusterCommandOptions<TYPE_MAPPING/*, POLICIES*/>;
+  private _policyResolver: PolicyResolver;
 
   /**
    * An array of the cluster slots, each slot contain its `master` and `replicas`.
@@ -356,6 +362,8 @@ export default class RedisCluster<
     if (options?.commandOptions) {
       this._commandOptions = options.commandOptions;
     }
+
+    this._policyResolver = new StaticPolicyResolver(POLICIES);
   }
 
   duplicate<
@@ -454,9 +462,19 @@ export default class RedisCluster<
     firstKey: RedisArgument | undefined,
     isReadonly: boolean | undefined,
     options: ClusterCommandOptions | undefined,
+    commandName: string,
     fn: (client: RedisClientType<M, F, S, RESP, TYPE_MAPPING>, opts?: ClusterCommandOptions) => Promise<T>
   ): Promise<T> {
+
     const maxCommandRedirections = this._options.maxCommandRedirections ?? 16;
+    const policyResult = this._policyResolver.resolvePolicy(commandName)
+
+    if(policyResult.ok) {
+      //TODO
+    } else {
+      //TODO
+    }
+
     let client = await this._slots.getClient(firstKey, isReadonly);
     let i = 0;
 
@@ -512,6 +530,7 @@ export default class RedisCluster<
       firstKey,
       isReadonly,
       options,
+      args[0] instanceof Buffer ? args[0].toString() : args[0],
       (client, opts) => client.sendCommand(args, opts)
     );
   }

packages/client/lib/cluster/request-response-policies/command-router.ts

@@ -0,0 +1,15 @@
+// import { RedisFunctions, RedisModules, RedisScripts, RespVersions, TypeMapping } from "../../RESP/types";
+// import { ShardNode } from "../cluster-slots";
+// import type { Either } from './types';
+
+// export interface CommandRouter<
+// M extends RedisModules,
+// F extends RedisFunctions,
+// S extends RedisScripts,
+// RESP extends RespVersions,
+// TYPE_MAPPING extends TypeMapping> {
+//   routeCommand(
+//     command: string,
+//     policy: RequestPolicy,
+//   ): Either<ShardNode<M, F, S, RESP, TYPE_MAPPING>, 'no-available-nodes' | 'routing-failed'>;
+// }

packages/client/lib/cluster/request-response-policies/dynamic-policy-resolver-factory.ts

@@ -0,0 +1,124 @@
+import type { CommandReply } from '../../commands/generic-transformers';
+import type { CommandPolicies } from './policies-constants';
+import { REQUEST_POLICIES_WITH_DEFAULTS, RESPONSE_POLICIES_WITH_DEFAULTS } from './policies-constants';
+import type { PolicyResolver, ModulePolicyRecords } from './types';
+import { StaticPolicyResolver } from './static-policy-resolver';
+
+/**
+ * Function type that returns command information from Redis
+ */
+export type CommandFetcher = () => Promise<Array<CommandReply>>;
+
+/**
+ * A factory for creating policy resolvers that dynamically build policies based on the Redis server's COMMAND response.
+ *
+ * This factory fetches command information from Redis and analyzes the response to determine
+ * appropriate routing policies for each command, returning a StaticPolicyResolver with the built policies.
+ */
+export class DynamicPolicyResolverFactory {
+  /**
+   * Creates a StaticPolicyResolver by fetching command information from Redis
+   * and building appropriate policies based on the command characteristics.
+   *
+   * @param commandFetcher Function to fetch command information from Redis
+   * @param fallbackResolver Optional fallback resolver to use when policies are not found
+   * @returns A new StaticPolicyResolver with the fetched policies
+   */
+  static async create(
+    commandFetcher: CommandFetcher,
+    fallbackResolver?: PolicyResolver
+  ): Promise<PolicyResolver> {
+    const commands = await commandFetcher();
+    const policies: ModulePolicyRecords = {};
+
+    for (const command of commands) {
+      const parsed = DynamicPolicyResolverFactory.#parseCommandName(command.name);
+
+      // Skip commands with invalid format (more than one dot)
+      if (!parsed) {
+        continue;
+      }
+
+      const { moduleName, commandName } = parsed;
+
+      // Initialize module if it doesn't exist
+      if (!policies[moduleName]) {
+        policies[moduleName] = {};
+      }
+
+      // Determine policies for this command
+      const commandPolicies = DynamicPolicyResolverFactory.#buildCommandPolicies(command);
+      policies[moduleName][commandName] = commandPolicies;
+    }
+
+    return new StaticPolicyResolver(policies, fallbackResolver);
+  }
+
+  /**
+   * Parses a command name to extract module and command components.
+   *
+   * Redis commands can be in format:
+   * - "ping" -> module: "std", command: "ping"
+   * - "ft.search" -> module: "ft", command: "search"
+   *
+   * Commands with more than one dot are invalid.
+   */
+  static #parseCommandName(fullCommandName: string): { moduleName: string; commandName: string } | null {
+    const parts = fullCommandName.split('.');
+
+    if (parts.length === 1) {
+      return { moduleName: 'std', commandName: fullCommandName };
+    }
+
+    if (parts.length === 2) {
+      return { moduleName: parts[0], commandName: parts[1] };
+    }
+
+    // Commands with more than one dot are invalid in Redis
+    return null;
+  }
+
+  /**
+   * Builds CommandPolicies for a command based on its characteristics.
+   *
+   * Priority order:
+   * 1. Use explicit policies from the command if available
+   * 2. Classify as DEFAULT_KEYLESS if keySpecification is empty
+   * 3. Classify as DEFAULT_KEYED if keySpecification is not empty
+   */
+  static #buildCommandPolicies(command: CommandReply): CommandPolicies {
+    // Determine if command is keyless based on keySpecification
+    const isKeyless = command.isKeyless
+
+    // Determine default policies based on key specification
+    const defaultRequest = isKeyless
+      ? REQUEST_POLICIES_WITH_DEFAULTS.DEFAULT_KEYLESS
+      : REQUEST_POLICIES_WITH_DEFAULTS.DEFAULT_KEYED;
+    const defaultResponse = isKeyless
+      ? RESPONSE_POLICIES_WITH_DEFAULTS.DEFAULT_KEYLESS
+      : RESPONSE_POLICIES_WITH_DEFAULTS.DEFAULT_KEYED;
+
+    let subcommands: Record<string, CommandPolicies> | undefined;
+    if(command.subcommands.length > 0) {
+      subcommands = {};
+      for (const subcommand of command.subcommands) {
+
+        // Subcommands are in format "parentCommand|subcommand"
+        const parts = subcommand.name.split("\|")
+        if(parts.length !== 2) {
+          throw new Error(`Invalid subcommand name: ${subcommand.name}`);
+        }
+        const subcommandName = parts[1];
+
+        subcommands[subcommandName] = DynamicPolicyResolverFactory.#buildCommandPolicies(subcommand);
+      }
+    }
+
+    return {
+      request: command.policies.request ?? defaultRequest,
+      response: command.policies.response ?? defaultResponse,
+      isKeyless,
+      subcommands
+    };
+  }
+}