valkey-glide-rb 0.9.0 → 0.9.2

data/lib/valkey/commands/generic_commands.rb

@@ -9,6 +9,11 @@ class Valkey
     module GenericCommands
       # Scan the keyspace
       #
+      # @note Standalone mode only. glide-core has no defined default route for
+      #   SCAN in cluster mode, so each call may land on a different node with
+      #   no cursor continuity between them — results are undefined (missed or
+      #   duplicated keys) rather than merely partial.
+      #
       # @example Retrieve the first batch of keys
       #   valkey.scan(0)
       #     # => ["4", ["key:21", "key:47", "key:42"]]
@@ -33,6 +38,9 @@ class Valkey
 
       # Scan the keyspace
       #
+      # @note Standalone mode only. Built on {#scan}, which has undefined
+      #   routing behavior in cluster mode (see its note).
+      #
       # @example Retrieve all of the keys (with possible duplicates)
       #   valkey.scan_each.to_a
       #     # => ["key:21", "key:47", "key:42"]
@@ -52,16 +60,16 @@ class Valkey
       #
       # @return [Enumerator] an enumerator for all found keys
       #
-      # def scan_each(**options, &block)
-      #   return to_enum(:scan_each, **options) unless block_given?
-      #
-      #   cursor = 0
-      #   loop do
-      #     cursor, keys = scan(cursor, **options)
-      #     keys.each(&block)
-      #     break if cursor == "0"
-      #   end
-      # end
+      def scan_each(**options, &block)
+        return to_enum(:scan_each, **options) unless block_given?
+
+        cursor = 0
+        loop do
+          cursor, keys = scan(cursor, **options)
+          keys.each(&block)
+          break if cursor == "0"
+        end
+      end
 
       # Remove the expiration from a key.
       #
@@ -386,9 +394,10 @@ class Valkey
 
       # Return a random key from the keyspace.
       #
-      # @return [String]
-      def randomkey
-        send_command(RequestType::RANDOM_KEY)
+      # @param route [Valkey::Route, nil] cluster routing. When routed, may return a Hash of node => value.
+      # @return [String, nil]
+      def randomkey(route: nil)
+        send_command(RequestType::RANDOM_KEY, [], route: route)
       end
 
       # Rename a key. If the new key already exists it is overwritten.
@@ -520,6 +529,100 @@ class Valkey
 
         send_command(command, args, &block)
       end
+
+      # Send any command as plain arguments and get the raw reply back, with no
+      # per-command method needed. Escape hatch for commands without a dedicated
+      # method yet, matching `redis-client`'s `#call`.
+      #
+      # @example Basic dispatch
+      #   valkey.call("SET", "mykey", "value")
+      #     # => "OK"
+      # @example Integers/Floats auto-stringify
+      #   valkey.call("SET", "mykey", 42)
+      #     # equivalent to call("SET", "mykey", "42")
+      # @example Arrays flatten
+      #   valkey.call("LPUSH", "list", [1, 2, 3])
+      #     # equivalent to call("LPUSH", "list", "1", "2", "3")
+      # @example Hashes flatten to alternating key/value
+      #   valkey.call("HMSET", "hash", { "foo" => "1" })
+      #     # equivalent to call("HMSET", "hash", "foo", "1")
+      # @example Keyword args become command flags; falsy/nil flags are dropped
+      #   valkey.call("SET", "k", "v", nx: true, ex: 60)
+      #     # equivalent to call("SET", "k", "v", "NX", "EX", "60")
+      #
+      # @param [Array<String, Integer, Float, Array, Hash>] argv command name and its arguments
+      # @param [Hash] kwargs trailing command flags; truthy values emit the upcased flag name,
+      #   non-boolean values also emit the stringified value; falsy/nil values are dropped
+      # @param route [Valkey::Route, nil] cluster routing. When routed, may return a Hash of node => value.
+      # @return [Object] the raw reply, with no type-casting based on the command name
+      #
+      # @see https://valkey.io/commands/
+      def call(*argv, route: nil, **kwargs)
+        send_command(RequestType::CUSTOM_COMMAND, flatten_call_args(argv).concat(call_flags(kwargs)), route: route)
+      end
+
+      # Send any command as a single Array of arguments and get the raw reply back.
+      # Same as {#call} but takes the whole command as one Array instead of splatted
+      # args, useful when the command is built dynamically. Matches `redis-client`'s
+      # `#call_v` — no keyword flags.
+      #
+      # @example
+      #   valkey.call_v(["MGET"] + keys)
+      #
+      # @param [Array<String, Integer, Float, Array, Hash>] argv command name and its arguments
+      # @param route [Valkey::Route, nil] cluster routing. When routed, may return a Hash of node => value.
+      # @return [Object] the raw reply, with no type-casting based on the command name
+      #
+      # @see https://valkey.io/commands/
+      def call_v(argv, route: nil)
+        send_command(RequestType::CUSTOM_COMMAND, flatten_call_args(argv), route: route)
+      end
+
+      private
+
+      # Flattens Arrays and Hashes (to alternating key/value) and stringifies
+      # Integers/Floats, matching `redis-client`'s documented `#call`/`#call_v` behavior.
+      #
+      # @example
+      #   flatten_call_args(["CMD", [1, [2, 3]], { "a" => 1, "b" => [2, 3] }])
+      #   # => ["CMD", "1", "2", "3", "a", "1", "b", "2", "3"]
+      def flatten_call_args(args)
+        acc = []
+        # Ruby doesn't have a built in queue, so we use a reversed stack instead
+        # Insertions into the stack needs to be reversed to maintain the Queue LIFO
+        # ordering
+        stack = args.reverse
+
+        until stack.empty?
+          arg = stack.pop
+          case arg
+          when Array
+            stack.concat(arg.reverse)
+          when Hash
+            arg.to_a.reverse_each { |pair| stack.concat(pair.reverse) }
+          else
+            acc << arg.to_s
+          end
+        end
+
+        acc
+      end
+
+      # Converts `call`'s **kwargs into trailing command flags: a truthy value emits
+      # the upcased flag name, and a non-boolean truthy value also emits the
+      # stringified value. Falsy/nil values are dropped entirely, not stringified.
+      #
+      # @example
+      #   call_flags(nx: true, ex: 60, cond: false, ttl: nil)
+      #   # => ["NX", "EX", "60"]
+      def call_flags(kwargs)
+        kwargs.each_with_object([]) do |(name, value), flags|
+          next unless value
+
+          flags << name.to_s.upcase
+          flags << value.to_s unless value == true
+        end
+      end
     end
   end
 end

data/lib/valkey/commands/scripting_commands.rb

@@ -108,8 +108,12 @@ class Valkey
 
         result = Bindings.store_script(buf, script.bytesize)
 
-        hash_buffer = Bindings::ScriptHashBuffer.new(result)
-        hash_buffer[:ptr].read_string(hash_buffer[:len])
+        begin
+          hash_buffer = Bindings::ScriptHashBuffer.new(result)
+          hash_buffer[:ptr].read_string(hash_buffer[:len])
+        ensure
+          Bindings.free_script_hash_buffer(result) if result && !result.null?
+        end
       end
 
       # Execute a Lua script on the server.
@@ -133,13 +137,22 @@ class Valkey
       # @example Execute script that returns different data types
       #   valkey.eval("return {1, 'hello', true, nil}")
       #     # => [1, "hello", true, nil]
+      # @example Positional form, matching redis-rb's eval(script, keys, argv)
+      #   valkey.eval("return KEYS[1] .. ARGV[1]", ["mykey"], ["myarg"])
+      #     # => "mykeynyarg"
       # Since the eval is not available in the rust backend
       # using the load and invoke script
-      def eval(script, keys: [], args: [])
+      def eval(script, *rest, keys: nil, args: nil)
         # Validate script parameter
         raise ArgumentError, "script must be a string" unless script.is_a?(String)
         raise ArgumentError, "script cannot be empty" if script.empty?
 
+        # Accept redis-rb's flexible positional form - eval(script, keys, argv)
+        # - in addition to the keyword form, mirroring the same treatment
+        # applied to evalsha (see that method for the full rationale).
+        keys ||= rest[0] || []
+        args ||= rest[1] || []
+
         # Validate and convert keys and args to strings
         begin
           keys = Array(keys).map(&:to_s)
@@ -177,13 +190,22 @@ class Valkey
       #   rescue Valkey::CommandError => e
       #     puts "Script not found: #{e.message}"
       #   end
+      # @example Positional form, matching redis-rb's evalsha(sha, keys, argv)
+      #   valkey.evalsha(sha, ["user"], ["123"])
+      #     # => "user:123"
       # Since evalsha is not available in rust backend
       # using invoke script
-      def evalsha(sha, keys: [], args: [])
+      def evalsha(sha, *rest, keys: nil, args: nil)
         # Validate SHA1 hash parameter
         raise ArgumentError, "sha1 hash must be a string" unless sha.is_a?(String)
         raise ArgumentError, "sha1 hash must be a 40-character hexadecimal string" unless valid_sha1?(sha)
 
+        # Accept redis-rb's flexible positional form - evalsha(sha, keys, argv)
+        # - in addition to the keyword form, so code written against redis-rb's
+        # API (e.g. redis_display_id) doesn't need to special-case this client.
+        keys ||= rest[0] || []
+        args ||= rest[1] || []
+
         # Validate and convert keys and args to strings
         begin
           keys = Array(keys).map(&:to_s)
@@ -258,22 +280,26 @@ class Valkey
         # Use from_string to ensure proper null termination
         sha = FFI::MemoryPointer.from_string(script)
 
-        res = Bindings.invoke_script(
-          @connection,
-          0,
-          sha,
-          keys.size,
-          keys_ptrs,
-          keys_lens,
-          args.size,
-          arg_ptrs,
-          arg_lens,
-          route_buf,
-          route.bytesize,
-          0 # span_ptr for OpenTelemetry (0 = no span)
-        )
-
-        convert_response(res)
+        begin
+          res = Bindings.invoke_script(
+            @connection,
+            0,
+            sha,
+            keys.size,
+            keys_ptrs,
+            keys_lens,
+            args.size,
+            arg_ptrs,
+            arg_lens,
+            route_buf,
+            route.bytesize,
+            0 # span_ptr for OpenTelemetry (0 = no span)
+          )
+
+          convert_response(res)
+        ensure
+          Bindings.free_command_result(res) if res && !res.null?
+        end
       end
 
       private

data/lib/valkey/commands/server_commands.rb

@@ -9,16 +9,18 @@ class Valkey
     module ServerCommands
       # Asynchronously rewrite the append-only file.
       #
-      # @return [String] `OK`
-      def bgrewriteaof
-        send_command(RequestType::BG_REWRITE_AOF)
+      # @param route [Valkey::Route, nil] cluster routing. When routed, may return a Hash of node => value.
+      # @return [String]
+      def bgrewriteaof(route: nil)
+        send_command(RequestType::BG_REWRITE_AOF, [], route: route)
       end
 
       # Asynchronously save the dataset to disk.
       #
-      # @return [String] `OK`
-      def bgsave
-        send_command(RequestType::BG_SAVE)
+      # @param route [Valkey::Route, nil] cluster routing. When routed, may return a Hash of node => value.
+      # @return [String]
+      def bgsave(route: nil)
+        send_command(RequestType::BG_SAVE, [], route: route)
       end
 
       # Get or set server configuration parameters.
@@ -35,18 +37,16 @@ class Valkey
       # Sends the CONFIG GET command with the given arguments.
       #
       # @param [Array<String>] args Configuration parameters to get
-      # @return [Hash, String] Returns a Hash if multiple parameters are requested,
-      #   otherwise returns a String with the value.
+      # @param route [Valkey::Route, nil] cluster routing. When routed, may return a Hash of node => value.
+      # @return [Hash, String]
       #
       # @example Get all configuration parameters
       #   config_get('*')
       #
       # @example Get a specific parameter
       #   config_get('maxmemory')
-      #
-      # @note Returns a Hash with parameter names as keys and values as values when multiple params requested.
-      def config_get(*args)
-        send_command(RequestType::CONFIG_GET, args) do |reply|
+      def config_get(*args, route: nil)
+        send_command(RequestType::CONFIG_GET, args, route: route) do |reply|
           if reply.is_a?(Array)
             Hash[*reply]
           else
@@ -60,55 +60,60 @@ class Valkey
       # Sends the CONFIG SET command with the given key-value pairs.
       #
       # @param [Array<String>] args Key-value pairs to set configuration
+      # @param route [Valkey::Route, nil] cluster routing.
       # @return [String] Returns "OK" if successful
       #
       # @example Set maxmemory to 100mb
       #   config_set('maxmemory', '100mb')
-      def config_set(*args)
-        send_command(RequestType::CONFIG_SET, args)
+      def config_set(*args, route: nil)
+        send_command(RequestType::CONFIG_SET, args, route: route)
       end
 
       # Reset the server's statistics.
       #
       # Sends the CONFIG RESETSTAT command.
       #
+      # @param route [Valkey::Route, nil] cluster routing.
       # @return [String] Returns "OK" if successful
       #
       # @example
       #   config_resetstat
-      def config_resetstat
-        send_command(RequestType::CONFIG_RESET_STAT)
+      def config_resetstat(route: nil)
+        send_command(RequestType::CONFIG_RESET_STAT, [], route: route)
       end
 
       # Rewrite the server configuration file.
       #
       # Sends the CONFIG REWRITE command.
       #
+      # @param route [Valkey::Route, nil] cluster routing.
       # @return [String] Returns "OK" if successful
       #
       # @example
       #   config_rewrite
-      def config_rewrite
-        send_command(RequestType::CONFIG_REWRITE)
+      def config_rewrite(route: nil)
+        send_command(RequestType::CONFIG_REWRITE, [], route: route)
       end
 
       # Return the number of keys in the selected database.
       #
+      # @param route [Valkey::Route, nil] cluster routing. When routed, may return a Hash of node => value.
       # @return [Integer]
-      def dbsize
-        send_command(RequestType::DB_SIZE)
+      def dbsize(route: nil)
+        send_command(RequestType::DB_SIZE, [], route: route)
       end
 
       # Remove all keys from all databases.
       #
       # @param [Hash] options
       #   - `:async => Boolean`: async flush (default: false)
+      # @param route [Valkey::Route, nil] cluster routing.
       # @return [String] `OK`
-      def flushall(options = nil)
+      def flushall(options = nil, route: nil)
         if options && options[:async]
-          send_command(RequestType::FLUSH_ALL, ["async"])
+          send_command(RequestType::FLUSH_ALL, ["async"], route: route)
         else
-          send_command(RequestType::FLUSH_ALL)
+          send_command(RequestType::FLUSH_ALL, [], route: route)
         end
       end
 
@@ -116,42 +121,56 @@ class Valkey
       #
       # @param [Hash] options
       #   - `:async => Boolean`: async flush (default: false)
+      # @param route [Valkey::Route, nil] cluster routing.
       # @return [String] `OK`
-      def flushdb(options = nil)
+      def flushdb(options = nil, route: nil)
         if options && options[:async]
-          send_command(RequestType::FLUSH_DB, ["async"])
+          send_command(RequestType::FLUSH_DB, ["async"], route: route)
         else
-          send_command(RequestType::FLUSH_DB)
+          send_command(RequestType::FLUSH_DB, [], route: route)
         end
       end
 
       # Get information and statistics about the server.
       #
-      # @param [String, Symbol] cmd e.g. "commandstats"
-      # @return [Hash<String, String>]
-      def info(cmd = nil)
-        send_command(RequestType::INFO, [cmd].compact) do |reply|
-          if reply.is_a?(String)
-            reply = Utils::HashifyInfo.call(reply)
-
-            if cmd && cmd.to_s == "commandstats"
-              # Extract nested hashes for INFO COMMANDSTATS
-              reply = reply.to_h do |k, v|
-                v = v.split(",").map { |e| e.split("=") }
-                [k[/^cmdstat_(.*)$/, 1], v.to_h]
-              end
-            end
+      # @param cmd [String, Symbol, nil] section name (e.g. "commandstats")
+      # @param route [Valkey::Route, nil] cluster routing. When routed, may return a Hash of node => value.
+      # @return [Hash]
+      def info(cmd = nil, route: nil)
+        send_command(RequestType::INFO, [cmd].compact, route: route) do |reply|
+          if reply.is_a?(Hash)
+            reply.transform_values { |v| parse_info_reply(v, cmd) }
+          elsif reply.is_a?(String)
+            parse_info_reply(reply, cmd)
+          else
+            reply
           end
+        end
+      end
+
+      private
 
-          reply
+      def parse_info_reply(reply, cmd)
+        reply = Utils::HashifyInfo.call(reply)
+
+        if cmd && cmd.to_s == "commandstats"
+          reply = reply.to_h do |k, v|
+            v = v.split(",").map { |e| e.split("=") }
+            [k[/^cmdstat_(.*)$/, 1], v.to_h]
+          end
         end
+
+        reply
       end
 
+      public
+
       # Get the UNIX time stamp of the last successful save to disk.
       #
+      # @param route [Valkey::Route, nil] cluster routing. When routed, may return a Hash of node => value.
       # @return [Integer]
-      def lastsave
-        send_command(RequestType::LAST_SAVE)
+      def lastsave(route: nil)
+        send_command(RequestType::LAST_SAVE, [], route: route)
       end
 
       # Listen for all requests received by the server in real time.
@@ -172,9 +191,10 @@ class Valkey
 
       # Synchronously save the dataset to disk.
       #
+      # @param route [Valkey::Route, nil] cluster routing.
       # @return [String]
-      def save
-        send_command(RequestType::SAVE)
+      def save(route: nil)
+        send_command(RequestType::SAVE, [], route: route)
       end
 
       # Synchronously save the dataset to disk and then shut down the server.
@@ -215,10 +235,11 @@ class Valkey
       # @example
       #   r.time # => [ 1333093196, 606806 ]
       #
+      # @param route [Valkey::Route, nil] cluster routing. When routed, may return a Hash of node => value.
       # @return [Array<Integer>] tuple of seconds since UNIX epoch and
       #   microseconds in the current second
-      def time
-        send_command(RequestType::TIME)
+      def time(route: nil)
+        send_command(RequestType::TIME, [], route: route)
       end
 
       # RequestType::DEBUG not exist
@@ -499,19 +520,26 @@ class Valkey
       # @see https://valkey.io/commands/failover/
       def failover(to: nil, force: false, abort: false, timeout: nil)
         args = []
-        if to
-          host, port = to.split
-          args << "TO" << host << port
+        if abort
+          # ABORT is mutually exclusive: cancels an ongoing failover and
+          # ignores any other arguments (matches the core GLIDE clients).
+          args << "ABORT"
+        else
+          if to
+            host, port = to.split
+            args << "TO" << host << port
+            # FORCE is only valid in combination with TO.
+            args << "FORCE" if force
+          end
+          args << "TIMEOUT" << timeout.to_s if timeout
         end
-        args << "FORCE" if force
-        args << "ABORT" if abort
-        args << "TIMEOUT" << timeout.to_s if timeout
         send_command(RequestType::FAIL_OVER, args)
       end
 
       # Display some computer art and the Valkey version.
       #
-      # @param [Integer] version optional version number for different art
+      # @param version [Integer, nil] optional version number for different art
+      # @param route [Valkey::Route, nil] cluster routing. When routed, may return a Hash of node => value.
       # @return [String] ASCII art and version information
       #
       # @example
@@ -522,9 +550,9 @@ class Valkey
       #     # => "Valkey ver. 7.0.0\n..."
       #
       # @see https://valkey.io/commands/lolwut/
-      def lolwut(version = nil)
+      def lolwut(version = nil, route: nil)
         args = version ? ["VERSION", version.to_s] : []
-        send_command(RequestType::LOLWUT, args)
+        send_command(RequestType::LOLWUT, args, route: route)
       end
 
       # Internal command used for replication (partial resynchronization).

data/lib/valkey/commands/string_commands.rb

@@ -129,7 +129,14 @@ class Valkey
       # @param [String] value
       # @return [Boolean] whether the key was set or not
       def setnx(key, value)
-        send_command(RequestType::SET_NX, [key, value])
+        # &Utils::Boolify (not glide-core's generic Boolean-coercion table) is
+        # deliberately used here: glide-core's per-command coercion is keyed by
+        # command name alone, so it can't distinguish this dedicated SETNX
+        # RequestType from a raw `customCommand(["SETNX", ...])` call, which
+        # other GLIDE bindings' existing contracts expect to keep returning a
+        # plain 0/1 integer. Doing the conversion here keeps it scoped to this
+        # one Ruby-level method - see hexists/hsetnx for the same pattern.
+        send_command(RequestType::SET_NX, [key, value], &Utils::Boolify)
       end
 
       # Set one or more values.

data/lib/valkey/commands/transaction_commands.rb

@@ -16,8 +16,12 @@ class Valkey
       #   end # => ["OK", 6]
       #
       # @yield [multi] the commands that are called inside this block are cached
-      #   and written to the server upon returning from it
-      # @yieldparam [Valkey] multi `self`
+      #   locally (no server round-trip per command) and sent to the server as a
+      #   single atomic batch once the block returns - GLIDE wraps them in a real
+      #   MULTI/EXEC transaction internally. If the block raises, nothing has been
+      #   sent to the server yet, so the exception simply propagates - there is no
+      #   transaction to discard.
+      # @yieldparam [Valkey::Pipeline] multi collects the block's commands
       #
       # @return [Array<...>]
       #   - an array with replies
@@ -26,17 +30,12 @@ class Valkey
       # @see #unwatch
       def multi
         if block_given?
-          begin
-            @in_multi_block = true
-            start_multi
-            yield(self)
-            exec
-          rescue StandardError
-            discard
-            raise
-          ensure
-            @in_multi_block = false
-          end
+          pipeline = Pipeline.new
+          yield pipeline
+
+          return [] if pipeline.commands.empty?
+
+          send_batch_commands(pipeline.commands, exception: true, is_atomic: true)
         else
           start_multi
           self
@@ -114,11 +113,12 @@ class Valkey
       # @see #discard
       def exec
         if @in_multi
+          queued_commands = @queued_commands
           begin
             begin
               result = send_command(RequestType::EXEC)
               # If EXEC returns an error object (from array), it's already handled
-              result
+              result.is_a?(Array) ? reconvert_queued_replies(result, queued_commands) : result
             rescue CommandError => e
               # If EXEC itself raises an error (like when transaction is aborted),
               # return an array with the error to match expected behavior in tests
@@ -157,8 +157,59 @@ class Valkey
         @queued_commands = []
       end
 
+      # Commands whose reply is boolean when run standalone (via native return-type
+      # coercion server-side), but arrives as a raw 0/1 integer inside an EXEC array,
+      # since that coercion is keyed by the single command actually being run - which,
+      # for a queued command, is EXEC itself, not the original command.
+      #
+      # This list mirrors glide-core's own Boolean-coercion table in
+      # `value_conversion.rs::expected_type_for_cmd` (HEXISTS, HSETNX, EXPIRE, EXPIREAT,
+      # PEXPIRE, PEXPIREAT, SISMEMBER, PERSIST, SMOVE, PFADD, RENAMENX, MOVE, COPY,
+      # MSETNX, XGROUP DESTROY, XGROUP CREATECONSUMER) MINUS the commands whose Ruby
+      # method already passes its own explicit conversion block (`hexists`/`hsetnx`
+      # use `&Utils::Boolify`; `xgroup_destroy`/`xgroup_createconsumer` use a custom
+      # bool->int block). Those are already handled correctly by the `if block`
+      # branch below, before this list is even consulted - listing them here too
+      # would be redundant, not wrong. Every RequestType below calls `send_command`
+      # with NO block at all, so this static list is the only place their boolean-ness
+      # is recorded.
+      #
+      # NOTE: SETNX is deliberately NOT in glide-core's coercion table (and so isn't
+      # here as a "no block" entry either) - it's `redis-rb`-style boolean-ness only,
+      # not something the server/`glide-core` treats as boolean, since coercion there
+      # is keyed by command name alone and can't distinguish this dedicated RequestType
+      # from a raw `customCommand(["SETNX", ...])` call, which other bindings' existing
+      # contracts expect to keep returning a plain integer. `setnx`'s own Ruby method
+      # passes `&Utils::Boolify` directly instead - see string_commands.rb - so it's
+      # already covered by the `if block` branch, same as hexists/hsetnx.
+      BOOLEAN_REQUEST_TYPES = [
+        RequestType::EXPIRE, RequestType::EXPIRE_AT, RequestType::PEXPIRE, RequestType::PEXPIRE_AT,
+        RequestType::PERSIST, RequestType::SISMEMBER, RequestType::S_MOVE, RequestType::PFADD,
+        RequestType::RENAME_NX, RequestType::MOVE, RequestType::COPY, RequestType::MSET_NX
+      ].freeze
+
       private
 
+      # Re-applies each queued command's own reply conversion (e.g. `&Utils::Boolify`)
+      # to EXEC's raw array, since redis-rb's Future-based design does the equivalent
+      # (a Future remembers its conversion and re-applies it once EXEC resolves), but
+      # queued commands here go through the plain single-command path with no such
+      # memory - see BOOLEAN_REQUEST_TYPES above for the case with no explicit block.
+      def reconvert_queued_replies(result, queued_commands)
+        return result unless result.size == queued_commands.size
+
+        result.each_with_index.map do |value, i|
+          command_type, _args, block = queued_commands[i]
+          if block
+            block.call(value)
+          elsif BOOLEAN_REQUEST_TYPES.include?(command_type)
+            Utils::Boolify.call(value)
+          else
+            value
+          end
+        end
+      end
+
       # Start a MULTI block if one isn't already active.
       #
       # This mirrors the behaviour of popular Valkey/Redis clients where