the v3 plan?

• require Node 10 or 12
• latest Stream APIs
  • pipeline(...streams, (err) => {})
  • https://nodesource.com/blog/understanding-streams-in-nodejs/
  • https://nodejs.org/api/stream.html
  • https://www.youtube.com/watch?v=aTEDCotcn20 (Matteo Collina, NearForm, Node core)
• Readable Stream by default, #360 ?
• strictly only multipart/* ?
• util wrappers around iterators & async iterators
• rewrite MultipartParser class to async generator function?
  • so we can Readable.from(multipart())?
• compatible (make use of) VFile or Vinyl? v2?
  • battles path related things and opreatons

Okay, some thoughts.

I think we can just wrap the Node’s stream.pipeline() and provide it to our users, but they still will be able to do whatever they want, using the Node’s pipeline(). Something like this

const { pipeline, MultipartParser, formidable } = require('formidable');

// accepts a callback, or returns a promise if no cb
const { fields, files } = await pipeline(req, formidableOptions);

// if they want more transform or whatever,
// they can add more things, just like in the Node's pipeline()
const { fields, files } = await pipeline(
  req,
  ...streams,
  ...iterators,
);

// or directly using the native pipeline()

const parser = new MultipartParser(); // it's Transform Stream

await promisify(stream.pipeline)(
  req,
  parser,
  formidable(),
);

[GrosSacASac]

I see it as breaking changes (fields and files output changen new dependency) so we can start with version 4.x I add you to formdiable github so you can create new branches and make commits if you want to try to implement your ideas in a new branch, (use 3.x as a starting point)

Overall I like the ideas to move towards web apis when possible.

[jimmywarting]

FormData package is for sending formdata, and formidable is for receiving. I am not sure if we can reuse some code. Or are you proposing to use FormData package to make it easy to forward a received form ? In that case feel free to add an example inside ./examples first.

FormData could be used for both sending and receiving, We wouldn’t have Response.formData() or Request.formData() otherwise. They exist so you can intercept the payload from Service Worker. FormData did not have any method for reading/manipulating a FormData earlier but now we have .has(), .delete(), .get(), .entries(), for..of and so on

So yes, I’m proposing to use a FormData package to make it easy to forward a received form. But also for parsing and consuming a received form

I think it would be cool if form.formData() could utilize a FormData package and resolve the stream with a FormData instance. Here is an example from the Readme that i have rewritten:

import { createServer } from 'node:http'
import formidable from 'formidable'

const server = createServer(async (req, res) => {
  if (req.url === '/api/upload' && req.method.toLowerCase() === 'post') {
    // parse a file upload
    const form = formidable({ uploadDir: '/tmp' });

    // Similar to whatwg `request.fromData()`
    const formData = await form.formData(req)
    console.log(...formData.entries())

    // file is a web File object
    const file = formData.get('file') // ( The file could be backed up by the filesystem - in /tmp dir )
    console.log(file.name)

    res.writeHead(200, { 
      'Content-Type': file.type,
      'Content-Length': file.size
    })

    // file.stream() is a whatwg:stream
    for await (const uint8 of file.stream()) {
      res.send(uint8)
    }
		
    return res.end()
  }

  // show a file upload form
  res.writeHead(200, { 'Content-Type': 'text/html' });
  res.end(`
    <h2>With Node.js <code>"http"</code> module</h2>
    <form action="/api/upload" enctype="multipart/form-data" method="post">
      <div>Text field title: <input type="text" name="title" /></div>
      <div>File: <input type="file" name="file" /></div>
      <input type="submit" value="Upload" />
    </form>
  `)
})

server.listen(8080, () => {
  console.log('Server listening on http://localhost:8080/ ...')
});

(calling form.formData() would work for both urlencoded and multipart payloads)

---

On a side note: you said you wanted to handle a (web)stream… that would be 👍, it would be great if formidable was not so bound to HttpIncomingRequest so you can just hand it some iterable object (wheater it be stream, req, webstream or any asyncIterator) - so something like: const formData = await form.formData(iterable, contentType) maybe? idk