Receiving a request with a binary body

[ellispritchard]

👋 Is there any way of retrieving the original request body as a binary (ArrayBuffer et al) using the rest handler?

The TypeScript definitions seem to imply that this is supported in some way, but I can't work out how to actually get it to do this.

e.g.

        rest.put<ArrayBuffer>(/s3\.amazonaws\.com/, (req, res, ctx) => {
           // do something with this
           res.body.byteLength

res.body seems to always be a string.

EDIT: should be req.body!!

[kettanaito]

Hey, @ellispritchard.

Note that the res argument of the resolver is a function that creates a mocked response. It's not used to access the original response, because no requests have yet happened. In your resolver you're deciding what should happen next once a request matching /s3\.amazonaws\.com/ occurs.

If you wish to read the original response body for that captured request, you'll be doing something similar to response patching.

Read original response

To get the original response you need to perform the captured request first. You can do that using the ctx.fetch utility that's designed just for that.

rest.put<ArrayBuffer>(/s3\.amazonaws\.com/, async (req, res, ctx) => {
  // Perform an original request to the same endpoint.
  // The returned data is an instance of the "Response".
  const original = await ctx.fetch(req)
  const body = await original.body
  body.byteLength
})

Please bear in mind that this introduces an actual network request in your handler, which is not desired during testing. You can use this perfectly fine for development or debugging, though.

[ellispritchard]

Hello; thanks for your answer, but I'm not sure I've explained my problem well enough...

actually, there was an error in my question: I say res.body when I meant req.body 🤕

What you describe is nicely documented, but not what I need.

It is the request from the code under test that I'm interested in, not the response I'm returning to it. In this particular instance I actually really don't care about sending back anything interesting in the response at all, except a 200 OK.

The code under test is making a request and I want to test that the request was good; in this case it's not enough to just match the URL or headers etc., I also want to make some assertions about the request body, e.g. the size, or the actual content (or a hash value of it).

However, I can only get the body as a string, which is not good enough for this 😞. So, in the same way as you can req.text or req.json I need the request body as some kind stream or buffer.

Is this possible?

[kettanaito]

It's not currently possible (not sure if it'll ever be). The request body is always converted to a string. This is due to the broadcast limitations between the main thread and the worker thread, which can only interchange text data. This is possible in Node.js but I value isomorphism of MSW API more than enabling certain features only in some environments.

We may consider re-creating non-textual request bodies manually but that's not always possible (and will likely to be resource-consuming). For instance, if I'm not mistaken, decoded base64 body cannot be encoded back with the same result. Not sure how it's for binary bodies.

That being said, if you feel like we can achieve this given the current limitations, please let us know. Perhaps even open an RFC so we could elaborate together and develop a new feature. Thanks.

[ellispritchard]

Thanks for the detail @kettanaito ; I'll have a think about what could be done, but yes it sounds like I won't be able to achieve what I was originally trying right now in MSW, due to the design of (real) service workers, so I'll have to try something else. 🤷‍♂️