feat(fetch): initial FormData support

Author: ronag

index.js

@@ -96,6 +96,7 @@ if (nodeMajor > 16 || (nodeMajor === 16 && nodeMinor >= 5)) {
   module.exports.Headers = require('./lib/fetch/headers').Headers
   module.exports.Response = require('./lib/fetch/response').Response
   module.exports.Request = require('./lib/fetch/request').Request
+  module.exports.FormData = require('./lib/fetch/formdata').FormData
 }
 
 module.exports.request = makeDispatcher(api.request)

lib/fetch/body.js

@@ -2,13 +2,15 @@
 
 const util = require('../core/util')
 const { toWebReadable } = require('./util')
+const { FormData, File } = require('./formdata')
 const { kState } = require('./symbols')
 const { Blob } = require('buffer')
 const { Readable } = require('stream')
-const { NotSupportedError } = require('../core/errors')
 const { kBodyUsed } = require('../core/symbols')
 const assert = require('assert')
 const nodeUtil = require('util')
+const Dicer = require('dicer')
+const { pipeline: pipelinep } = require('stream/promises')
 
 let ReadableStream
 
@@ -71,12 +73,67 @@ function extractBody (object, keepalive = false) {
 
     // Set source to a copy of the bytes held by object.
     source = new Uint8Array(object)
+  } else if (object instanceof FormData) {
+    const boundary = '----formdata-undici-' + Math.random()
+    const prefix = `--${boundary}\r\nContent-Disposition: form-data; name="`
+
+    /*! formdata-polyfill. MIT License. Jimmy Wärting <https://jimmy.warting.se/opensource> */
+    const escape = (str, filename) =>
+      (filename ? str : str.replace(/\r?\n|\r/g, '\r\n'))
+        .replace(/\n/g, '%0A')
+        .replace(/\r/g, '%0D')
+        .replace(/"/g, '%22')
+
+    // Set action to this step: run the multipart/form-data
+    // encoding algorithm, with object’s entry list and UTF-8.
+    action = async (onNext, onError, onComplete) => {
+      try {
+        for (const [name, value] of object) {
+          let str
+          if (typeof value === 'string') {
+            str =
+              prefix +
+              escape(name) +
+              `"\r\n\r\n${value.replace(/\r(?!\n)|(?<!\r)\n/g, '\r\n')}\r\n`
+          } else {
+            str =
+              (prefix +
+                escape(name) +
+                `"; filename="${escape(value.name, 1)}"\r\n` +
+                `Content-Type: ${
+                  value.type || 'application/octet-stream'
+                }\r\n\r\n`,
+              value,
+              '\r\n')
+          }
+
+          // TODO: Backpressure?
+          onNext(Buffer.from(str))
+        }
+        onNext(Buffer.from(`--${boundary}--`))
+        onComplete()
+      } catch (err) {
+        onError(err)
+      }
+    }
+
+    // Set source to object.
+    source = object
+
+    // Set length to unclear, see html/6424 for improving this.
+    // TODO
+
+    // Set Content-Type to `multipart/form-data; boundary=`,
+    // followed by the multipart/form-data boundary string generated
+    // by the multipart/form-data encoding algorithm.
+    contentType = 'multipart/form-data; boundary=' + boundary
   } else if (object instanceof Blob) {
     // Blob
 
     // Set action to this step: read object.
     action = async (onNext, onError, onComplete) => {
       try {
+        // TODO: object.stream() + read in parts + back-pressure?
         onNext(await object.arrayBuffer())
         onComplete()
       } catch (err) {
@@ -244,8 +301,115 @@ const methods = {
   },
 
   async formData () {
-    // TODO: Implement.
-    throw new NotSupportedError('formData')
+    const contentType = this.headers.get('Content-Type')
+
+    // If mimeType’s essence is "multipart/form-data", then:
+    if (/multipart\/form-data/.test(contentType)) {
+      const entries = []
+
+      // 1. Parse bytes, using the value of the `boundary` parameter from
+      // mimeType, per the rules set forth in Returning Values from Forms:
+      // multipart/form-data. [RFC7578]
+      const m =
+        contentType.match(
+          /^multipart\/form-data(?:; boundary=(?:(?:"(.+)")|(?:([^\s]+))))$/
+        ) ?? []
+
+      // TODO: Try to avoid dicer.
+      const d = new Dicer({ boundary: m[1] || m[2] }).on('part', (p) => {
+        const chunks = []
+        let headers
+        p.on('header', (header) => {
+          headers = header
+        })
+          .on('data', (data) => {
+            chunks.push(data)
+          })
+          .on('end', () => {
+            // Each part whose `Content-Disposition` header contains a `filename`
+            // parameter must be parsed into an entry whose value is a File object
+            // whose contents are the contents of the part. The name attribute of
+            // the File object must have the value of the `filename` parameter of
+            // the part. The type attribute of the File object must have the value
+            // of the `Content-Type` header of the part if the part has such header,
+            // and `text/plain` (the default defined by [RFC7578] section 4.4)
+            // otherwise.
+
+            let name
+            let filename
+
+            if (headers['content-disposition']) {
+              const parts = headers['content-disposition']
+                .map((header) =>
+                  header.split(';').map((x) => x.trim().split('='))
+                )
+                .flat()
+              name = parts.find((part) => part[0] === 'name')?.[1]
+              filename = parts.find((part) => part[0] === 'filename')?.[1]
+            }
+
+            if (!name) {
+              return
+            }
+
+            // TODO: When should this be a Blob and when should it be a string?
+            entries.push([
+              name.match(/^"(.*)"$|(.*)/)[1],
+              filename
+                ? new File(chunks, filename, {
+                    type: headers['content-type'] ?? 'text/plain'
+                  })
+                : new Blob(chunks)
+            ])
+          })
+      })
+      await pipelinep(this.body, d)
+
+      // Each part whose `Content-Disposition` header does not contain a
+      // `filename` parameter must be parsed into an entry whose value is the
+      // UTF-8 decoded without BOM content of the part. This is done regardless
+      // of the presence or the value of a `Content-Type` header and regardless
+      // of the presence or the value of a `charset` parameter.
+      // TODO
+
+      // 2. If that fails for some reason, then throw a TypeError.
+      if (entries instanceof Error) {
+        throw Object.assign(new TypeError(), { cause: entries })
+      }
+
+      // 3. Return a new FormData object, appending each entry, resulting from
+      // the parsing operation, to entries.
+      const formData = new FormData()
+      for (const [name, value] of entries) {
+        formData.append(name, value)
+      }
+      return formData
+    } else if (/application\/x-www-form-urlencoded/.test(contentType)) {
+      // Otherwise, if mimeType’s essence is "application/x-www-form-urlencoded", then:
+
+      // 1. Let entries be the result of parsing bytes.
+      let entries
+      try {
+        entries = new URLSearchParams(await this.text())
+      } catch (err) {
+        entries = err
+      }
+
+      // 2. If entries is failure, then throw a TypeError.
+      if (entries instanceof Error) {
+        throw Object.assign(new TypeError(), { cause: entries })
+      }
+
+      // 3. Return a new FormData object whose entries are entries.
+      const formData = new FormData()
+      for (const [name, value] of entries) {
+        formData.append(name, value)
+      }
+      return formData
+    } else {
+      // Otherwise, throw a TypeError.
+      throw new TypeError()
+    }
   }
 }
 

lib/fetch/formdata.js

@@ -0,0 +1,141 @@
+'use strict'
+
+const { Blob } = require('buffer')
+
+const { kState } = require('./symbols')
+
+class File extends Blob {
+  constructor (fileBits, fileName, options = {}) {
+    super(fileBits)
+    this[kState] = {
+      filename: fileName,
+      lastModified: options.lastModified
+    }
+  }
+
+  get filename () {
+    return this[kState].filename
+  }
+
+  get lastModified () {
+    return this[kState].lastModified
+  }
+}
+
+class FormData {
+  constructor () {
+    this[kState] = []
+  }
+
+  append (name, value, filename) {
+    // 1. Let value be value if given; otherwise blobValue.
+    // 2. Let entry be the result of creating an entry with
+    // name, value, and filename if given.
+    const entry = makeEntry(name, value, filename)
+
+    // 3. Append entry to this’s entry list.
+    this[kState].push(entry)
+  }
+
+  delete (name) {
+    // The delete(name) method steps are to remove all entries whose name
+    // is name from this’s entry list.
+    const next = []
+    for (const entry of this[kState]) {
+      if (entry.name !== name) {
+        next.push(entry)
+      }
+    }
+
+    this[kState] = next
+  }
+
+  get (name) {
+    // 1. If there is no entry whose name is name in this’s entry list,
+    // then return null.
+    const idx = this[kState].findIndex((entry) => entry.name === name)
+    if (idx === -1) {
+      return null
+    }
+
+    // 2. Return the value of the first entry whose name is name from
+    // this’s entry list.
+    return this[kState][idx].value
+  }
+
+  getAll (name) {
+    // 1. If there is no entry whose name is name in this’s entry list,
+    // then return the empty list.
+    // 2. Return the values of all entries whose name is name, in order,
+    // from this’s entry list.
+    return this[kState]
+      .filter((entry) => entry.name === name)
+      .map((entry) => entry.value)
+  }
+
+  has (name) {
+    // The has(name) method steps are to return true if there is an entry
+    // whose name is name in this’s entry list; otherwise false.
+    return this[kState].findIndex((entry) => entry.name === name) !== -1
+  }
+
+  set (name, value, filename) {
+    // The set(name, value) and set(name, blobValue, filename) method steps
+    // are:
+
+    // 1. Let value be value if given; otherwise blobValue.
+    // 2. Let entry be the result of creating an entry with name, value, and
+    // filename if given.
+    const entry = makeEntry(name, value, filename)
+
+    // 3. If there are entries in this’s entry list whose name is name, then
+    // replace the first such entry with entry and remove the others.
+    this[kState] = this[kState].filter((entry) => entry.name !== name)
+
+    // 4. Otherwise, append entry to this’s entry list.
+    this[kState].push(entry)
+  }
+
+  * [Symbol.iterator] () {
+    // The value pairs to iterate over are this’s entry list’s entries with
+    // the key being the name and the value being the value.
+    for (const { name, value } of this[kState]) {
+      yield [name, value]
+    }
+  }
+}
+
+function makeEntry (name, value, filename) {
+  // To create an entry for name, value, and optionally a filename, run these
+  // steps:
+
+  // Let entry be a new entry.
+  const entry = {
+    name: null,
+    value: null
+  }
+
+  // Set entry’s name to name.
+  entry.name = name
+
+  // If value is a Blob object and not a File object, then set value to a new File
+  // object, representing the same bytes, whose name attribute value is "blob".
+  if (value instanceof Blob && !(value instanceof File)) {
+    // TODO
+  }
+
+  // If value is (now) a File object and filename is given, then set value to a
+  // new File object, representing the same bytes, whose name attribute value is
+  // filename.
+  if (value instanceof File && filename) {
+    // TODO
+  }
+
+  // Set entry’s value to value.
+  entry.value = value
+
+  // Return entry.
+  return entry
+}
+
+module.exports = { FormData, File }

package.json

@@ -53,7 +53,6 @@
     "@sinonjs/fake-timers": "^7.0.5",
     "@types/node": "^15.0.2",
     "abort-controller": "^3.0.0",
-    "busboy": "^0.3.1",
     "chai": "^4.3.4",
     "chai-as-promised": "^7.1.1",
     "chai-iterator": "^3.0.2",
@@ -96,5 +95,8 @@
     "compilerOptions": {
       "esModuleInterop": true
     }
+  },
+  "dependencies": {
+    "dicer": "^0.3.0"
   }
 }