Occasional empty / zero byte streams at high load
Hi!

First of all, thank you for this great library! I've been using it for a couple of years now and it really makes the GraphQL developer experience better 🙂.

Unfortunately, we're seeing occasional errors where the `createReadStream()` would have zero bytes on our production environment with very little load running on GKE even though the whole multipart request was received (I've added a PassThrough stream to print out the whole request when the stream length is zero).

I have been able to replicate this on a local K8S when load testing the service at 40-60 rps with a chance of around 1 in 5000. Basically, the service in question here is a GraphQL Gateway, we're using `graphql-upload v13.0.0`'s processRequest as a middleware for `fastify` to process the body and then passing it to `apollo-server-fastify` and `@apollo/gateway` together with [apollo-federation-file-upload](https://github.com/profusion/apollo-federation-file-upload) as the datasource to replay the file upload.

My initial assumption was that it has something to do with the networking/parsing layer but I had run a separate test using the received request body directly to `dicer` in a >100,000 loop to see if it was the cause but the result didn't have any errors parsing the multipart.

I have a couple of theories as to why this happens.
1. Upon diving with `fs-capacitor` I have learned that all file uploads create a temporary file so maybe during high load it fails to create a temporary possibly due to too many files being open? I'm currently thinking if this is related to this [issue](https://github.com/mike-marcacci/fs-capacitor/issues/45)
2. During debugging, whenever I encounter the zero byte stream the [`onData` and `onEnd` was never called](https://github.com/mscdex/busboy/blob/v0.3.1/lib/types/multipart.js#L216-L231), I'm not super experienced when it comes to streams but would it be possible for `createReadStream()` to execute before the data is written to the FileStream?
3. It may also be the combination of the two? During high load disk writes can cause high latency which affects reading of the file when calling `createReadStream`.

Our solution right now is to migrate to [graphql-upload-minimal](https://github.com/flash-oss/graphql-upload-minimal) since we're only using the stream to pass through to the receiving backend service. I haven't encountered the issue so far with this setup even at 120 rps load.