Error when uploading 900+ files in one request
```TSX
async (_, { files, projectId }, ctx) => {
        const slicedFiles: any = [];
        const chunkSize = 100;
        for (let index = 0; index < files.file.length; index += chunkSize) {
          slicedFiles.push(files.file.slice(index, index + chunkSize));
        }

        const createPromise = async (uploads: any, ctx: any) => {
          const promises = uploads.map((upload: any) => {
            const { file, filetype, participant, scene, trial } = upload;
            return new Promise(resolve => {
              resolve(
                processUpload(
                  {
                    file,
                    filetype,
                    participant,
                    scene,
                    trial,
                    projectId,
                  },
                  ctx,
                ),
              );
            }).catch(err => {
              console.log(err);
            });
          });
          return await Promise.all(promises).then(() => {
            console.log('done');
          });
        };

        for (let i = 0; i < slicedFiles.length; i++) {
          await createPromise(slicedFiles[i], ctx);
        }

        return { test: 'finished' };
      },
```

this is my resolver for multiple files uploading. the processUpload functions is like this below.

```TSX
export const processUpload = async (file: any, ctx: any) => {
  if (!file) {
    return console.log('ERROR: No file received.');
  }

  const { filetype } = await file;
  const { createReadStream, filename, mimetype, encoding } = await file.file;

  const stream = createReadStream();

  const sceneInfo = await ctx.prisma.scenes(
    {
      where: {
        AND: [{ ... }, { ...}],
      },
    },
     { ... } ,
  );

 .......

  const key = '************';

  await s3
    .upload({
      Key: key,
      ACL: 'public-read',
      Body: stream,
      Bucket: 'some_bucket',
    })
    .promise();

  const data: FileCreateInput = {
    filename,
    mimetype,
    encoding,
  };

  const { id } = await ctx.prisma.createFile(data,  {... } );

  const fileInfo = {
    id,
    filename,
    mimetype,
    encoding,
  };

  return fileInfo;
};
```

when my resolver got message, and it runs 100 processUpload function parallel. I am testing with 1157 files and it works very well for 800~900 files and suddenly It returns error like below.

```Shell
Error: A ReadStream cannot be created from a destroyed WriteStream.
    at WriteStream.createReadStream (/***/node_modules/fs-capacitor/lib/index.js:188:31)
    at createReadStream (/***/node_modules/graphql-upload/lib/processRequest.js:237:28)
    at Object.<anonymous> (/***/server/fileUploader.ts:21:18)
    at Generator.next (<anonymous>)
    at fulfilled (/***/server/fileUploader.ts:4:58)
    at process._tickCallback (internal/process/next_tick.js:68:7)
```

it works fine with chunkSize 500, but it returns same error while batching 15 ~ 16 loop.
Am I doing something wrong?