feat: implement 0 dependency streaming multipart/form-data parser

index.d.ts

@@ -21,6 +21,7 @@ export * from './types/fetch'
 export * from './types/file'
 export * from './types/filereader'
 export * from './types/formdata'
+export * from './types/formdataparser'
 export * from './types/diagnostics-channel'
 export * from './types/websocket'
 export * from './types/content-type'

index.js

@@ -141,6 +141,10 @@ if (util.nodeMajor >= 18 && hasCrypto) {
   const { WebSocket } = require('./lib/websocket/websocket')
 
   module.exports.WebSocket = WebSocket
+
+  const { FormDataParser } = require('./lib/formdata/parser')
+
+  module.exports.FormDataParser = FormDataParser
 }
 
 module.exports.request = makeDispatcher(api.request)

lib/fetch/body.js

@@ -1,6 +1,5 @@
 'use strict'
 
-const Busboy = require('busboy')
 const util = require('../core/util')
 const {
   ReadableStreamFrom,
@@ -21,6 +20,7 @@ const { isErrored } = require('../core/util')
 const { isUint8Array, isArrayBuffer } = require('util/types')
 const { File: UndiciFile } = require('./file')
 const { parseMIMEType, serializeAMimeType } = require('./dataURL')
+const { FormDataParser } = require('../formdata/parser')
 
 let ReadableStream = globalThis.ReadableStream
 
@@ -374,21 +374,21 @@ function bodyMixinMethods (instance) {
 
         const responseFormData = new FormData()
 
-        let busboy
+        let parser
 
         try {
-          busboy = Busboy({
+          parser = new FormDataParser({
             headers,
             defParamCharset: 'utf8'
           })
         } catch (err) {
           throw new DOMException(`${err}`, 'AbortError')
         }
 
-        busboy.on('field', (name, value) => {
+        parser.on('field', (name, value) => {
           responseFormData.append(name, value)
         })
-        busboy.on('file', (name, value, info) => {
+        parser.on('file', (name, value, info) => {
           const { filename, encoding, mimeType } = info
           const chunks = []
 
@@ -417,14 +417,14 @@ function bodyMixinMethods (instance) {
           }
         })
 
-        const busboyResolve = new Promise((resolve, reject) => {
-          busboy.on('finish', resolve)
-          busboy.on('error', (err) => reject(new TypeError(err)))
+        const promise = new Promise((resolve, reject) => {
+          parser.on('close', () => resolve())
+          parser.on('error', (err) => reject(new TypeError(err)))
         })
 
-        if (this.body !== null) for await (const chunk of consumeBody(this[kState].body)) busboy.write(chunk)
-        busboy.end()
-        await busboyResolve
+        if (this.body !== null) for await (const chunk of consumeBody(this[kState].body)) parser.write(chunk)
+        parser.end()
+        await promise
 
         return responseFormData
       } else if (/application\/x-www-form-urlencoded/.test(contentType)) {

lib/fetch/dataURL.js

@@ -132,33 +132,47 @@ function URLSerializer (url, excludeFragment = false) {
 
 // https://infra.spec.whatwg.org/#collect-a-sequence-of-code-points
 /**
- * @param {(char: string) => boolean} condition
- * @param {string} input
+ * @template {string|Buffer} T
+ * @param {(char: T[number]) => boolean} condition
+ * @param {T} input
  * @param {{ position: number }} position
+ * @returns {T}
  */
 function collectASequenceOfCodePoints (condition, input, position) {
+  const inputIsString = typeof input === 'string'
+  const start = position.position
+
   // 1. Let result be the empty string.
   let result = ''
 
   // 2. While position doesn’t point past the end of input and the
   // code point at position within input meets the condition condition:
   while (position.position < input.length && condition(input[position.position])) {
     // 1. Append that code point to the end of result.
-    result += input[position.position]
+    if (inputIsString) {
+      result += input[position.position]
+    }
 
     // 2. Advance position by 1.
     position.position++
   }
 
   // 3. Return result.
+
+  if (!inputIsString) {
+    return input.subarray(start, position.position)
+  }
+
   return result
 }
 
 /**
  * A faster collectASequenceOfCodePoints that only works when comparing a single character.
+ * @template {string|Buffer} T
  * @param {string} char
- * @param {string} input
+ * @param {T} input
  * @param {{ position: number }} position
+ * @returns {T}
  */
 function collectASequenceOfCodePointsFast (char, input, position) {
   const idx = input.indexOf(char, position.position)

lib/formdata/constants.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const states = {
+  INITIAL: 0,
+  BOUNDARY: 1,
+  READ_HEADERS: 2,
+  READ_BODY: 3
+}
+
+const headerStates = {
+  DEFAULT: -1, // no match
+  FIRST: 0,
+  SECOND: 1,
+  THIRD: 2
+}
+
+const chars = {
+  '-': 0x2D,
+  cr: 0x0D,
+  lf: 0x0A,
+  ':': 0x3A,
+  ' ': 0x20,
+  ';': 0x3B,
+  '=': 0x3D,
+  '"': 0x22
+}
+
+const emptyBuffer = Buffer.alloc(0)
+
+const crlfBuffer = Buffer.from([0x0D, 0x0A]) // \r\n
+
+const maxHeaderLength = 16 * 1024
+
+module.exports = {
+  states,
+  chars,
+  headerStates,
+  emptyBuffer,
+  maxHeaderLength,
+  crlfBuffer
+}

lib/formdata/filestream.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const { Readable } = require('stream')
+
+class FileStream extends Readable {
+  _read () {}
+}
+
+module.exports = {
+  FileStream
+}