fastify 4.28.0 → 5.0.0-alpha.3

package/lib/server.js

@@ -3,8 +3,8 @@
 const http = require('node:http')
 const https = require('node:https')
 const dns = require('node:dns')
+const os = require('node:os')
 
-const { FSTDEP011 } = require('./warnings')
 const { kState, kOptions, kServerBindings } = require('./symbols')
 const { onListenHookRunner } = require('./hooks')
 const {
@@ -15,7 +15,6 @@ const {
 } = require('./errors')
 
 module.exports.createServer = createServer
-module.exports.compileValidateHTTPVersion = compileValidateHTTPVersion
 
 function defaultResolveServerListeningText (address) {
   return `Server listening at ${address}`
@@ -25,27 +24,11 @@ function createServer (options, httpHandler) {
   const server = getServerInstance(options, httpHandler)
 
   // `this` is the Fastify object
-  function listen (listenOptions, ...args) {
-    let cb = args.slice(-1).pop()
-    // When the variadic signature deprecation is complete, the function
-    // declaration should become:
-    //   function listen (listenOptions = { port: 0, host: 'localhost' }, cb = undefined)
-    // Upon doing so, the `normalizeListenArgs` function is no longer needed,
-    // and all of this preamble to feed it correctly also no longer needed.
-    const firstArgType = Object.prototype.toString.call(arguments[0])
-    if (arguments.length === 0) {
-      listenOptions = normalizeListenArgs([])
-    } else if (arguments.length > 0 && (firstArgType !== '[object Object]' && firstArgType !== '[object Function]')) {
-      FSTDEP011()
-      listenOptions = normalizeListenArgs(Array.from(arguments))
-      cb = listenOptions.cb
-    } else if (args.length > 1) {
-      // `.listen(obj, a, ..., n, callback )`
-      FSTDEP011()
-      // Deal with `.listen(port, host, backlog, [cb])`
-      const hostPath = listenOptions.path ? [listenOptions.path] : [listenOptions.port ?? 0, listenOptions.host ?? 'localhost']
-      Object.assign(listenOptions, normalizeListenArgs([...hostPath, ...args]))
-    } else {
+  function listen (
+    listenOptions = { port: 0, host: 'localhost' },
+    cb = undefined
+  ) {
+    if (typeof cb === 'function') {
       listenOptions.cb = cb
     }
     if (listenOptions.signal) {
@@ -220,6 +203,7 @@ function multipleBindings (mainServer, httpHandler, serverOpts, listenOptions, o
 function listenCallback (server, listenOptions) {
   const wrap = (err) => {
     server.removeListener('error', wrap)
+    server.removeListener('listening', wrap)
     if (!err) {
       const address = logServerAddress.call(this, server, listenOptions.listenTextResolver || defaultResolveServerListeningText)
       listenOptions.cb(null, address)
@@ -240,7 +224,8 @@ function listenCallback (server, listenOptions) {
 
     server.once('error', wrap)
     if (!this[kState].closing) {
-      server.listen(listenOptions, wrap)
+      server.once('listening', wrap)
+      server.listen(listenOptions)
       this[kState].listening = true
     }
   }
@@ -255,79 +240,37 @@ function listenPromise (server, listenOptions) {
 
   return this.ready().then(() => {
     let errEventHandler
+    let listeningEventHandler
+    function cleanup () {
+      server.removeListener('error', errEventHandler)
+      server.removeListener('listening', listeningEventHandler)
+    }
     const errEvent = new Promise((resolve, reject) => {
       errEventHandler = (err) => {
+        cleanup()
         this[kState].listening = false
         reject(err)
       }
       server.once('error', errEventHandler)
     })
-    const listen = new Promise((resolve, reject) => {
-      server.listen(listenOptions, () => {
-        server.removeListener('error', errEventHandler)
+    const listeningEvent = new Promise((resolve, reject) => {
+      listeningEventHandler = () => {
+        cleanup()
+        this[kState].listening = true
         resolve(logServerAddress.call(this, server, listenOptions.listenTextResolver || defaultResolveServerListeningText))
-      })
-      // we set it afterwards because listen can throw
-      this[kState].listening = true
+      }
+      server.once('listening', listeningEventHandler)
     })
 
+    server.listen(listenOptions)
+
     return Promise.race([
       errEvent, // e.g invalid port range error is always emitted before the server listening
-      listen
+      listeningEvent
     ])
   })
 }
 
-/**
- * Creates a function that, based upon initial configuration, will
- * verify that every incoming request conforms to allowed
- * HTTP versions for the Fastify instance, e.g. a Fastify HTTP/1.1
- * server will not serve HTTP/2 requests upon the result of the
- * verification function.
- *
- * @param {object} options fastify option
- * @param {function} [options.serverFactory] If present, the
- * validator function will skip all checks.
- * @param {boolean} [options.http2 = false] If true, the validator
- * function will allow HTTP/2 requests.
- * @param {object} [options.https = null] https server options
- * @param {boolean} [options.https.allowHTTP1] If true and use
- * with options.http2 the validator function will allow HTTP/1
- * request to http2 server.
- *
- * @returns {function} HTTP version validator function.
- */
-function compileValidateHTTPVersion (options) {
-  let bypass = false
-  // key-value map to store valid http version
-  const map = new Map()
-  if (options.serverFactory) {
-    // When serverFactory is passed, we cannot identify how to check http version reliably
-    // So, we should skip the http version check
-    bypass = true
-  }
-  if (options.http2) {
-    // HTTP2 must serve HTTP/2.0
-    map.set('2.0', true)
-    if (options.https && options.https.allowHTTP1 === true) {
-      // HTTP2 with HTTPS.allowHTTP1 allow fallback to HTTP/1.1 and HTTP/1.0
-      map.set('1.1', true)
-      map.set('1.0', true)
-    }
-  } else {
-    // HTTP must server HTTP/1.1 and HTTP/1.0
-    map.set('1.1', true)
-    map.set('1.0', true)
-  }
-  // The compiled function here placed in one of the hottest path inside fastify
-  // the implementation here must be as performant as possible
-  return function validateHTTPVersion (httpVersion) {
-    // `bypass` skip the check when custom server factory provided
-    // `httpVersion in obj` check for the valid http version we should support
-    return bypass || map.has(httpVersion)
-  }
-}
-
 function getServerInstance (options, httpHandler) {
   let server = null
   // node@20 do not accepts options as boolean
@@ -364,57 +307,53 @@ function getServerInstance (options, httpHandler) {
   }
   return server
 }
-
-function normalizeListenArgs (args) {
-  if (args.length === 0) {
-    return { port: 0, host: 'localhost' }
-  }
-
-  const cb = typeof args[args.length - 1] === 'function' ? args.pop() : undefined
-  const options = { cb }
-
-  const firstArg = args[0]
-  const argsLength = args.length
-  const lastArg = args[argsLength - 1]
-  if (typeof firstArg === 'string' && isNaN(firstArg)) {
-    /* Deal with listen (pipe[, backlog]) */
-    options.path = firstArg
-    options.backlog = argsLength > 1 ? lastArg : undefined
-  } else {
-    /* Deal with listen ([port[, host[, backlog]]]) */
-    options.port = argsLength >= 1 && Number.isInteger(firstArg) ? firstArg : normalizePort(firstArg)
-    // This will listen to what localhost is.
-    // It can be 127.0.0.1 or ::1, depending on the operating system.
-    // Fixes https://github.com/fastify/fastify/issues/1022.
-    options.host = argsLength >= 2 && args[1] ? args[1] : 'localhost'
-    options.backlog = argsLength >= 3 ? args[2] : undefined
+/**
+ * Inspects the provided `server.address` object and returns a
+ * normalized list of IP address strings. Normalization in this
+ * case refers to mapping wildcard `0.0.0.0` to the list of IP
+ * addresses the wildcard refers to.
+ *
+ * @see https://nodejs.org/docs/latest/api/net.html#serveraddress
+ *
+ * @param {object} A server address object as described in the
+ * linked docs.
+ *
+ * @returns {string[]}
+ */
+function getAddresses (address) {
+  if (address.address === '0.0.0.0') {
+    return Object.values(os.networkInterfaces()).flatMap((iface) => {
+      return iface.filter((iface) => iface.family === 'IPv4')
+    }).sort((iface) => {
+      /* c8 ignore next 2 */
+      // Order the interfaces so that internal ones come first
+      return iface.internal ? -1 : 1
+    }).map((iface) => { return iface.address })
   }
-
-  return options
-}
-
-function normalizePort (firstArg) {
-  const port = Number(firstArg)
-  return port >= 0 && !Number.isNaN(port) && Number.isInteger(port) ? port : 0
+  return [address.address]
 }
 
 function logServerAddress (server, listenTextResolver) {
-  let address = server.address()
-  const isUnixSocket = typeof address === 'string'
-  /* istanbul ignore next */
+  let addresses
+  const isUnixSocket = typeof server.address() === 'string'
   if (!isUnixSocket) {
-    if (address.address.indexOf(':') === -1) {
-      address = address.address + ':' + address.port
+    if (server.address().address.indexOf(':') === -1) {
+      // IPv4
+      addresses = getAddresses(server.address()).map((address) => address + ':' + server.address().port)
     } else {
-      address = '[' + address.address + ']:' + address.port
+      // IPv6
+      addresses = ['[' + server.address().address + ']:' + server.address().port]
     }
+
+    addresses = addresses.map((address) => ('http' + (this[kOptions].https ? 's' : '') + '://') + address)
+  } else {
+    addresses = [server.address()]
   }
-  /* istanbul ignore next */
-  address = (isUnixSocket ? '' : ('http' + (this[kOptions].https ? 's' : '') + '://')) + address
 
-  const serverListeningText = listenTextResolver(address)
-  this.log.info(serverListeningText)
-  return address
+  for (const address of addresses) {
+    this.log.info(listenTextResolver(address))
+  }
+  return addresses[0]
 }
 
 function http2 () {

package/lib/warnings.js

@@ -2,16 +2,30 @@
 
 const { createDeprecation, createWarning } = require('process-warning')
 
+/**
+ * Deprecation codes:
+ *   - FSTDEP005
+ *   - FSTDEP007
+ *   - FSTDEP008
+ *   - FSTDEP009
+ *   - FSTDEP010
+ *   - FSTDEP012
+ *   - FSTDEP013
+ *   - FSTDEP015
+ *   - FSTDEP016
+ *   - FSTDEP017
+ *   - FSTDEP018
+ *   - FSTDEP019
+ *   - FSTDEP021
+ *   - FSTWRN001
+ *   - FSTSEC001
+ */
+
 const FSTDEP005 = createDeprecation({
   code: 'FSTDEP005',
   message: 'You are accessing the deprecated "request.connection" property. Use "request.socket" instead.'
 })
 
-const FSTDEP006 = createDeprecation({
-  code: 'FSTDEP006',
-  message: 'You are decorating Request/Reply with a reference type. This reference is shared amongst all requests. Use onRequest hook instead. Property: %s'
-})
-
 const FSTDEP007 = createDeprecation({
   code: 'FSTDEP007',
   message: 'You are trying to set a HEAD route using "exposeHeadRoute" route flag when a sibling route is already set. See documentation for more info.'
@@ -32,11 +46,6 @@ const FSTDEP010 = createDeprecation({
   message: 'Modifying the "reply.sent" property is deprecated. Use the "reply.hijack()" method instead.'
 })
 
-const FSTDEP011 = createDeprecation({
-  code: 'FSTDEP011',
-  message: 'Variadic listen method is deprecated. Please use ".listen(optionsObject)" instead. The variadic signature will be removed in `fastify@5`.'
-})
-
 const FSTDEP012 = createDeprecation({
   code: 'FSTDEP012',
   message: 'request.context property access is deprecated. Please use "request.routeOptions.config" or "request.routeOptions.schema" instead for accessing Route settings. The "request.context" will be removed in `fastify@5`.'
@@ -47,11 +56,6 @@ const FSTDEP013 = createDeprecation({
   message: 'Direct return of "trailers" function is deprecated. Please use "callback" or "async-await" for return value. The support of direct return will removed in `fastify@5`.'
 })
 
-const FSTDEP014 = createDeprecation({
-  code: 'FSTDEP014',
-  message: 'You are trying to set/access the default route. This property is deprecated. Please, use setNotFoundHandler if you want to custom a 404 handler or the wildcard (*) to match all routes.'
-})
-
 const FSTDEP015 = createDeprecation({
   code: 'FSTDEP015',
   message: 'You are accessing the deprecated "request.routeSchema" property. Use "request.routeOptions.schema" instead. Property "req.routeSchema" will be removed in `fastify@5`.'
@@ -77,11 +81,6 @@ const FSTDEP019 = createDeprecation({
   message: 'reply.context property access is deprecated. Please use "request.routeOptions.config" or "request.routeOptions.schema" instead for accessing Route settings. The "reply.context" will be removed in `fastify@5`.'
 })
 
-const FSTDEP020 = createDeprecation({
-  code: 'FSTDEP020',
-  message: 'You are using the deprecated "reply.getResponseTime()" method. Use the "reply.elapsedTime" property instead. Method "reply.getResponseTime()" will be removed in `fastify@5`.'
-})
-
 const FSTDEP021 = createDeprecation({
   code: 'FSTDEP021',
   message: 'The `reply.redirect()` method has a new signature: `reply.redirect(url: string, code?: number)`. It will be enforced in `fastify@v5`'
@@ -94,31 +93,27 @@ const FSTWRN001 = createWarning({
   unlimited: true
 })
 
-const FSTWRN002 = createWarning({
-  name: 'FastifyWarning',
-  code: 'FSTWRN002',
-  message: 'The %s plugin being registered mixes async and callback styles, which will result in an error in `fastify@5`',
+const FSTSEC001 = createWarning({
+  name: 'FastifySecurity',
+  code: 'FSTSEC001',
+  message: 'You are using /%s/ Content-Type which may be vulnerable to CORS attack. Please make sure your RegExp start with "^" or include ";?" to proper detection of the essence MIME type.',
   unlimited: true
 })
 
 module.exports = {
   FSTDEP005,
-  FSTDEP006,
   FSTDEP007,
   FSTDEP008,
   FSTDEP009,
   FSTDEP010,
-  FSTDEP011,
   FSTDEP012,
   FSTDEP013,
-  FSTDEP014,
   FSTDEP015,
   FSTDEP016,
   FSTDEP017,
   FSTDEP018,
   FSTDEP019,
-  FSTDEP020,
   FSTDEP021,
   FSTWRN001,
-  FSTWRN002
+  FSTSEC001
 }

package/lib/wrapThenable.js

@@ -5,44 +5,68 @@ const {
   kReplyHijacked
 } = require('./symbols')
 
-function wrapThenable (thenable, reply) {
+const diagnostics = require('dc-polyfill')
+const channels = diagnostics.tracingChannel('fastify.request.handler')
+
+function wrapThenable (thenable, reply, store) {
+  if (store) store.async = true
   thenable.then(function (payload) {
     if (reply[kReplyHijacked] === true) {
       return
     }
 
-    // this is for async functions that are using reply.send directly
-    //
-    // since wrap-thenable will be called when using reply.send directly
-    // without actual return. the response can be sent already or
-    // the request may be terminated during the reply. in this situation,
-    // it require an extra checking of request.aborted to see whether
-    // the request is killed by client.
-    if (payload !== undefined || (reply.sent === false && reply.raw.headersSent === false && reply.request.raw.aborted === false)) {
-      // we use a try-catch internally to avoid adding a catch to another
-      // promise, increase promise perf by 10%
-      try {
-        reply.send(payload)
-      } catch (err) {
-        reply[kReplyIsError] = true
-        reply.send(err)
+    if (store) {
+      channels.asyncStart.publish(store)
+    }
+
+    try {
+      // this is for async functions that are using reply.send directly
+      //
+      // since wrap-thenable will be called when using reply.send directly
+      // without actual return. the response can be sent already or
+      // the request may be terminated during the reply. in this situation,
+      // it require an extra checking of request.aborted to see whether
+      // the request is killed by client.
+      if (payload !== undefined || (reply.sent === false && reply.raw.headersSent === false && reply.request.raw.aborted === false)) {
+        // we use a try-catch internally to avoid adding a catch to another
+        // promise, increase promise perf by 10%
+        try {
+          reply.send(payload)
+        } catch (err) {
+          reply[kReplyIsError] = true
+          reply.send(err)
+        }
+      }
+    } finally {
+      if (store) {
+        channels.asyncEnd.publish(store)
       }
     }
   }, function (err) {
-    if (reply.sent === true) {
-      reply.log.error({ err }, 'Promise errored, but reply.sent = true was set')
-      return
+    if (store) {
+      store.error = err
+      channels.error.publish(store) // note that error happens before asyncStart
+      channels.asyncStart.publish(store)
     }
 
-    reply[kReplyIsError] = true
-
-    // try-catch allow to re-throw error in error handler for async handler
     try {
+      if (reply.sent === true) {
+        reply.log.error({ err }, 'Promise errored, but reply.sent = true was set')
+        return
+      }
+
+      reply[kReplyIsError] = true
+
       reply.send(err)
       // The following should not happen
       /* c8 ignore next 3 */
     } catch (err) {
+      // try-catch allow to re-throw error in error handler for async handler
       reply.send(err)
+    } finally {
+      if (store) {
+        channels.asyncEnd.publish(store)
+      }
     }
   })
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.28.0",
+  "version": "5.0.0-alpha.3",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -11,24 +11,22 @@
     "benchmark:parser": "concurrently -k -s first \"node ./examples/benchmark/parser.js\" \"autocannon -c 100 -d 30 -p 10 -i ./examples/benchmark/body.json -H \"content-type:application/jsoff\" -m POST localhost:3000/\"",
     "build:validation": "node build/build-error-serializer.js && node build/build-validation.js",
     "coverage": "npm run unit -- --coverage-report=html",
-    "coverage:ci": "c8 --reporter=lcov tap --coverage-report=html --no-browser --no-check-coverage",
-    "coverage:ci-check-coverage": "c8 check-coverage --branches 100 --functions 100 --lines 100 --statements 100",
-    "lint": "npm run lint:standard && npm run lint:typescript && npm run lint:markdown",
-    "lint:fix": "standard --fix && npm run lint:typescript:fix",
+    "coverage:ci": "tap --coverage-report=html --coverage-report=lcov --allow-incomplete-coverage",
+    "coverage:ci-check-coverage": "tap replay",
+    "lint": "npm run lint:eslint",
+    "lint:fix": "eslint --fix",
     "lint:markdown": "markdownlint-cli2",
-    "lint:standard": "standard | snazzy",
-    "lint:typescript": "eslint -c types/.eslintrc.json types/**/*.d.ts test/types/**/*.test-d.ts",
-    "lint:typescript:fix": "npm run lint:typescript -- --fix",
-    "prepublishOnly": "cross-env PREPUBLISH=true tap --no-check-coverage test/build/**.test.js && npm run test:validator:integrity",
+    "lint:eslint": "eslint",
+    "prepublishOnly": "cross-env PREPUBLISH=true tap --allow-incomplete-coverage test/build/**.test.js && npm run test:validator:integrity",
     "test": "npm run lint && npm run unit && npm run test:typescript",
-    "test:ci": "npm run unit -- --cov --coverage-report=lcovonly && npm run test:typescript",
+    "test:ci": "npm run unit -- --coverage-report=lcovonly && npm run test:typescript",
     "test:report": "npm run lint && npm run unit:report && npm run test:typescript",
     "test:validator:integrity": "npm run build:validation && git diff --quiet --ignore-all-space --ignore-blank-lines --ignore-cr-at-eol lib/error-serializer.js && git diff --quiet --ignore-all-space --ignore-blank-lines --ignore-cr-at-eol lib/configValidator.js",
     "test:typescript": "tsc test/types/import.ts && tsd",
-    "test:watch": "npm run unit -- --watch --cov --no-coverage-report --reporter=terse",
-    "unit": "c8 tap",
+    "test:watch": "npm run unit -- --watch --coverage-report=none --reporter=terse",
+    "unit": "tap",
     "unit:junit": "tap-mocha-reporter xunit < out.tap > test/junit-testresults.xml",
-    "unit:report": "tap --cov --coverage-report=html --coverage-report=cobertura | tee out.tap",
+    "unit:report": "tap --coverage-report=html --coverage-report=cobertura | tee out.tap",
     "citgm": "tap --jobs=1 --timeout=120"
   },
   "repository": {
@@ -153,79 +151,61 @@
     }
   ],
   "devDependencies": {
-    "@fastify/pre-commit": "^2.0.2",
-    "@sinclair/typebox": "^0.31.17",
-    "@sinonjs/fake-timers": "^11.1.0",
-    "@types/node": "^20.8.4",
-    "@typescript-eslint/eslint-plugin": "^6.7.5",
-    "@typescript-eslint/parser": "^6.7.5",
+    "@fastify/pre-commit": "^2.1.0",
+    "@sinclair/typebox": "^0.32.22",
+    "@sinonjs/fake-timers": "^11.2.2",
+    "@stylistic/eslint-plugin": "^2.1.0",
+    "@stylistic/eslint-plugin-js": "^2.1.0",
+    "@types/node": "^20.12.7",
     "ajv": "^8.12.0",
     "ajv-errors": "^3.0.0",
-    "ajv-formats": "^2.1.1",
+    "ajv-formats": "^3.0.1",
     "ajv-i18n": "^4.2.0",
     "ajv-merge-patch": "^5.0.1",
-    "autocannon": "^7.14.0",
+    "autocannon": "^7.15.0",
     "branch-comparer": "^1.1.0",
-    "c8": "^8.0.1",
     "concurrently": "^8.2.2",
     "cross-env": "^7.0.3",
-    "eslint": "^8.51.0",
-    "eslint-config-standard": "^17.1.0",
-    "eslint-import-resolver-node": "^0.3.9",
-    "eslint-plugin-import": "^2.28.1",
-    "eslint-plugin-n": "^16.2.0",
-    "eslint-plugin-promise": "^6.1.1",
+    "eslint": "^9.0.0",
     "fast-json-body": "^1.1.0",
     "fastify-plugin": "^4.5.1",
-    "fluent-json-schema": "^4.1.2",
-    "form-data": "^4.0.0",
+    "fluent-json-schema": "^4.2.1",
     "h2url": "^0.2.0",
     "http-errors": "^2.0.0",
-    "joi": "^17.11.0",
-    "json-schema-to-ts": "^2.9.2",
+    "joi": "^17.12.3",
+    "json-schema-to-ts": "^3.0.1",
     "JSONStream": "^1.3.5",
-    "markdownlint-cli2": "^0.10.0",
+    "markdownlint-cli2": "^0.13.0",
+    "neostandard": "^0.8.0",
     "node-forge": "^1.3.1",
     "proxyquire": "^2.1.3",
     "send": "^0.18.0",
     "simple-get": "^4.0.1",
-    "snazzy": "^9.0.0",
     "split2": "^4.2.0",
-    "standard": "^17.1.0",
-    "tap": "^16.3.9",
-    "tsd": "^0.29.0",
-    "typescript": "^5.2.2",
-    "undici": "^5.26.0",
+    "tap": "^19.0.0",
+    "tsd": "^0.31.0",
+    "typescript": "^5.4.5",
+    "undici": "^6.13.0",
     "vary": "^1.1.2",
-    "yup": "^1.3.2"
+    "yup": "^1.4.0"
   },
   "dependencies": {
     "@fastify/ajv-compiler": "^3.5.0",
-    "@fastify/error": "^3.4.0",
+    "@fastify/error": "^4.0.0",
     "@fastify/fast-json-stringify-compiler": "^4.3.0",
     "abstract-logging": "^2.0.1",
     "avvio": "^8.3.0",
-    "fast-content-type-parse": "^1.1.0",
-    "fast-json-stringify": "^5.8.0",
-    "find-my-way": "^8.0.0",
-    "light-my-request": "^5.11.0",
+    "dc-polyfill": "^0.1.6",
+    "fast-json-stringify": "^6.0.0",
+    "find-my-way": "^8.1.0",
+    "light-my-request": "^5.13.0",
     "pino": "^9.0.0",
     "process-warning": "^3.0.0",
     "proxy-addr": "^2.0.7",
-    "rfdc": "^1.3.0",
+    "rfdc": "^1.3.1",
     "secure-json-parse": "^2.7.0",
-    "semver": "^7.5.4",
-    "toad-cache": "^3.3.0"
-  },
-  "standard": {
-    "ignore": [
-      "lib/configValidator.js",
-      "lib/error-serializer.js",
-      "fastify.d.ts",
-      "types/*",
-      "test/types/*",
-      "test/same-shape.test.js"
-    ]
+    "semver": "^7.6.0",
+    "toad-cache": "^3.7.0"
   },
   "tsd": {
     "directory": "test/types"

package/test/404s.test.js

@@ -6,7 +6,6 @@ const fp = require('fastify-plugin')
 const sget = require('simple-get').concat
 const errors = require('http-errors')
 const split = require('split2')
-const FormData = require('form-data')
 const Fastify = require('..')
 const { getServerUrl } = require('./helper')
 
@@ -68,21 +67,18 @@ test('default 404', t => {
       })
     })
 
-    test('using post method and multipart/formdata', t => {
+    test('using post method and multipart/formdata', async t => {
       t.plan(3)
-      const form = FormData()
-      form.append('test-field', 'just some field')
+      const form = new FormData()
+      form.set('test-field', 'just some field')
 
-      sget({
+      const response = await fetch(getServerUrl(fastify) + '/notSupported', {
         method: 'POST',
-        url: getServerUrl(fastify) + '/notSupported',
-        body: form,
-        json: false
-      }, (err, response, body) => {
-        t.error(err)
-        t.equal(response.statusCode, 404)
-        t.equal(response.headers['content-type'], 'application/json; charset=utf-8')
+        body: form
       })
+      t.equal(response.status, 404)
+      t.equal(response.statusText, 'Not Found')
+      t.equal(response.headers.get('content-type'), 'application/json; charset=utf-8')
     })
   })
 })