fastify 3.27.3 → 4.0.0-alpha.2

package/lib/server.js

@@ -1,16 +1,213 @@
 'use strict'
 
-const assert = require('assert')
 const http = require('http')
 const https = require('https')
+const dns = require('dns')
 
-const { kState, kOptions } = require('./symbols')
+const warnings = require('./warnings')
+const { kState, kOptions, kServerBindings } = require('./symbols')
 const { FST_ERR_HTTP2_INVALID_VERSION, FST_ERR_REOPENED_CLOSE_SERVER, FST_ERR_REOPENED_SERVER } = require('./errors')
 
+module.exports = createServer
+
 function createServer (options, httpHandler) {
-  assert(options, 'Missing options')
-  assert(httpHandler, 'Missing http handler')
+  const server = getServerInstance(options, httpHandler)
+
+  return { server, listen }
+
+  // `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]')) {
+      warnings.emit('FSTDEP011')
+      listenOptions = normalizeListenArgs(Array.from(arguments))
+      cb = listenOptions.cb
+    } else if (args.length > 1) {
+      // `.listen(obj, a, ..., n, callback )`
+      warnings.emit('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 {
+      listenOptions.cb = cb
+    }
+
+    const { host = 'localhost' } = listenOptions
+    if (Object.prototype.hasOwnProperty.call(listenOptions, 'host') === false) {
+      listenOptions.host = host
+    }
+
+    if (host === 'localhost') {
+      listenOptions.cb = (err, address) => {
+        if (err) {
+          // the server did not start
+          cb(err, address)
+          return
+        }
+
+        multipleBindings.call(this, server, httpHandler, options, listenOptions, () => {
+          this[kState].listening = true
+          cb(null, address)
+        })
+      }
+    }
+
+    // https://github.com/nodejs/node/issues/9390
+    // If listening to 'localhost', listen to both 127.0.0.1 or ::1 if they are available.
+    // If listening to 127.0.0.1, only listen to 127.0.0.1.
+    // If listening to ::1, only listen to ::1.
+
+    if (cb === undefined) {
+      const listening = listenPromise.call(this, server, listenOptions)
+      /* istanbul ignore else */
+      if (host === 'localhost') {
+        return listening.then(address => {
+          return new Promise((resolve, reject) => {
+            multipleBindings.call(this, server, httpHandler, options, listenOptions, () => {
+              this[kState].listening = true
+              resolve(address)
+            })
+          })
+        })
+      }
+    }
+
+    this.ready(listenCallback.call(this, server, listenOptions))
+  }
+}
+
+function multipleBindings (mainServer, httpHandler, serverOpts, listenOptions, onListen) {
+  // the main server is started, we need to start the secondary servers
+  this[kState].listening = false
+
+  // let's check if we need to bind additional addresses
+  dns.lookup(listenOptions.host, { all: true }, (dnsErr, addresses) => {
+    if (dnsErr) {
+      // not blocking the main server listening
+      // this.log.warn('dns.lookup error:', dnsErr)
+      onListen()
+      return
+    }
+
+    let binding = 0
+    let binded = 0
+    const primaryAddress = mainServer.address()
+    for (const adr of addresses) {
+      if (adr.address !== primaryAddress.address) {
+        binding++
+        const secondaryOpts = Object.assign({}, listenOptions, {
+          host: adr.address,
+          port: primaryAddress.port,
+          cb: (_ignoreErr) => {
+            binded++
+
+            if (!_ignoreErr) {
+              this[kServerBindings].push(secondaryServer)
+            }
+
+            if (binded === binding) {
+              // regardless of the error, we are done
+              onListen()
+            }
+          }
+        })
+
+        const secondaryServer = getServerInstance(serverOpts, httpHandler)
+        const closeSecondary = () => { secondaryServer.close(() => {}) }
+        mainServer.on('unref', closeSecondary)
+        mainServer.on('close', closeSecondary)
+        mainServer.on('error', closeSecondary)
+        listenCallback.call(this, secondaryServer, secondaryOpts)()
+      }
+    }
+
+    // no extra bindings are necessary
+    if (binding === 0) {
+      onListen()
+      return
+    }
+
+    // in test files we are using unref so we need to propagate the unref event
+    // to the secondary servers. It is valid only when the user is
+    // listening on localhost
+    const originUnref = mainServer.unref
+    /* istanbul ignore next */
+    mainServer.unref = function () {
+      originUnref.call(mainServer)
+      mainServer.emit('unref')
+    }
+  })
+}
+
+function listenCallback (server, listenOptions) {
+  const wrap = (err) => {
+    server.removeListener('error', wrap)
+    if (!err) {
+      const address = logServerAddress.call(this, server)
+      listenOptions.cb(null, address)
+    } else {
+      this[kState].listening = false
+      listenOptions.cb(err, null)
+    }
+  }
+
+  return (err) => {
+    if (err != null) return listenOptions.cb(err)
+
+    if (this[kState].listening && this[kState].closing) {
+      return listenOptions.cb(new FST_ERR_REOPENED_CLOSE_SERVER(), null)
+    } else if (this[kState].listening) {
+      return listenOptions.cb(new FST_ERR_REOPENED_SERVER(), null)
+    }
+
+    server.once('error', wrap)
+    server.listen(listenOptions, wrap)
+
+    this[kState].listening = true
+  }
+}
+
+function listenPromise (server, listenOptions) {
+  if (this[kState].listening && this[kState].closing) {
+    return Promise.reject(new FST_ERR_REOPENED_CLOSE_SERVER())
+  } else if (this[kState].listening) {
+    return Promise.reject(new FST_ERR_REOPENED_SERVER())
+  }
 
+  return this.ready().then(() => {
+    let errEventHandler
+    const errEvent = new Promise((resolve, reject) => {
+      errEventHandler = (err) => {
+        this[kState].listening = false
+        reject(err)
+      }
+      server.once('error', errEventHandler)
+    })
+    const listen = new Promise((resolve, reject) => {
+      server.listen(listenOptions, () => {
+        server.removeListener('error', errEventHandler)
+        resolve(logServerAddress.call(this, server))
+      })
+      // we set it afterwards because listen can throw
+      this[kState].listening = true
+    })
+
+    return Promise.race([
+      errEvent, // e.g invalid port range error is always emitted before the server listening
+      listen
+    ])
+  })
+}
+
+function getServerInstance (options, httpHandler) {
   let server = null
   if (options.serverFactory) {
     server = options.serverFactory(httpHandler, options)
@@ -41,123 +238,53 @@ function createServer (options, httpHandler) {
   if (!options.serverFactory) {
     server.setTimeout(options.connectionTimeout)
   }
+  return server
+}
 
-  return { server, listen }
-
-  // `this` is the Fastify object
-  function listen () {
-    const 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]
-      /* Deal with listen (options) || (handle[, backlog]) */
-      if (typeof firstArg === 'object' && firstArg !== null) {
-        options.backlog = argsLength > 1 ? lastArg : undefined
-        Object.assign(options, firstArg)
-      } else 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 && firstArg ? firstArg : 0
-        // 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
-      }
-
-      return options
-    }
-
-    const listenOptions = normalizeListenArgs(Array.from(arguments))
-    const cb = listenOptions.cb
-
-    const wrap = err => {
-      server.removeListener('error', wrap)
-      if (!err) {
-        const address = logServerAddress()
-        cb(null, address)
-      } else {
-        this[kState].listening = false
-        cb(err, null)
-      }
-    }
+function normalizeListenArgs (args) {
+  if (args.length === 0) {
+    return { port: 0, host: 'localhost' }
+  }
 
-    const listenPromise = (listenOptions) => {
-      if (this[kState].listening && this[kState].closing) {
-        return Promise.reject(new FST_ERR_REOPENED_CLOSE_SERVER())
-      } else if (this[kState].listening) {
-        return Promise.reject(new FST_ERR_REOPENED_SERVER())
-      }
+  const cb = typeof args[args.length - 1] === 'function' ? args.pop() : undefined
+  const options = { cb }
 
-      return this.ready().then(() => {
-        let errEventHandler
-        const errEvent = new Promise((resolve, reject) => {
-          errEventHandler = (err) => {
-            this[kState].listening = false
-            reject(err)
-          }
-          server.once('error', errEventHandler)
-        })
-        const listen = new Promise((resolve, reject) => {
-          server.listen(listenOptions, () => {
-            server.removeListener('error', errEventHandler)
-            resolve(logServerAddress())
-          })
-          // we set it afterwards because listen can throw
-          this[kState].listening = true
-        })
+  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 : 0
+    // 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
+  }
 
-        return Promise.race([
-          errEvent, // e.g invalid port range error is always emitted before the server listening
-          listen
-        ])
-      })
-    }
+  return options
+}
 
-    const logServerAddress = () => {
-      let address = server.address()
-      const isUnixSocket = typeof address === 'string'
-      /* istanbul ignore next */
-      if (!isUnixSocket) {
-        if (address.address.indexOf(':') === -1) {
-          address = address.address + ':' + address.port
-        } else {
-          address = '[' + address.address + ']:' + address.port
-        }
-      }
-      /* istanbul ignore next */
-      address = (isUnixSocket ? '' : ('http' + (this[kOptions].https ? 's' : '') + '://')) + address
-      this.log.info('Server listening at ' + address)
-      return address
+function logServerAddress (server) {
+  let address = server.address()
+  const isUnixSocket = typeof address === 'string'
+  /* istanbul ignore next */
+  if (!isUnixSocket) {
+    if (address.address.indexOf(':') === -1) {
+      address = address.address + ':' + address.port
+    } else {
+      address = '[' + address.address + ']:' + address.port
     }
-
-    if (cb === undefined) return listenPromise(listenOptions)
-
-    this.ready(err => {
-      if (err != null) return cb(err)
-
-      if (this[kState].listening && this[kState].closing) {
-        return cb(new FST_ERR_REOPENED_CLOSE_SERVER(), null)
-      } else if (this[kState].listening) {
-        return cb(new FST_ERR_REOPENED_SERVER(), null)
-      }
-
-      server.once('error', wrap)
-      server.listen(listenOptions, wrap)
-
-      this[kState].listening = true
-    })
   }
+  /* istanbul ignore next */
+  address = (isUnixSocket ? '' : ('http' + (this[kOptions].https ? 's' : '') + '://')) + address
+
+  this.log.info('Server listening at ' + address)
+  return address
 }
 
 function http2 () {
@@ -177,5 +304,3 @@ function sessionTimeout (timeout) {
 function close () {
   this.close()
 }
-
-module.exports = { createServer }

package/lib/symbols.js

@@ -3,12 +3,12 @@
 const keys = {
   kAvvioBoot: Symbol('fastify.avvioBoot'),
   kChildren: Symbol('fastify.children'),
+  kServerBindings: Symbol('fastify.serverBindings'),
   kBodyLimit: Symbol('fastify.bodyLimit'),
   kRoutePrefix: Symbol('fastify.routePrefix'),
   kLogLevel: Symbol('fastify.logLevel'),
   kLogSerializers: Symbol('fastify.logSerializers'),
   kHooks: Symbol('fastify.hooks'),
-  kHooksDeprecatedPreParsing: Symbol('fastify.hooks.DeprecatedPreParsing'),
   kSchemaController: Symbol('fastify.schemaController'),
   kSchemaHeaders: Symbol('headers-schema'),
   kSchemaParams: Symbol('params-schema'),
@@ -31,9 +31,9 @@ const keys = {
   kReplyIsError: Symbol('fastify.reply.isError'),
   kReplyHeaders: Symbol('fastify.reply.headers'),
   kReplyHasStatusCode: Symbol('fastify.reply.hasStatusCode'),
-  kReplySent: Symbol('fastify.reply.sent'),
-  kReplySentOverwritten: Symbol('fastify.reply.sentOverwritten'),
+  kReplyHijacked: Symbol('fastify.reply.hijacked'),
   kReplyStartTime: Symbol('fastify.reply.startTime'),
+  kReplyNextErrorHandler: Symbol('fastify.reply.nextErrorHandler'),
   kReplyEndTime: Symbol('fastify.reply.endTime'),
   kReplyErrorHandlerCalled: Symbol('fastify.reply.errorHandlerCalled'),
   kReplyIsRunningOnErrorHook: Symbol('fastify.reply.isRunningOnErrorHook'),
@@ -45,6 +45,7 @@ const keys = {
   // This symbol is only meant to be used for fastify tests and should not be used for any other purpose
   kTestInternals: Symbol('fastify.testInternals'),
   kErrorHandler: Symbol('fastify.errorHandler'),
+  kHasBeenDecorated: Symbol('fastify.hasBeenDecorated'),
   kKeepAliveConnections: Symbol('fastify.keepAliveConnections')
 }
 

package/lib/validation.js

@@ -68,7 +68,8 @@ function compileSchemasForValidation (context, compile) {
 }
 
 function validateParam (validatorFunction, request, paramName) {
-  const ret = validatorFunction && validatorFunction(request[paramName])
+  const isUndefined = request[paramName] === undefined
+  const ret = validatorFunction && validatorFunction(isUndefined ? null : request[paramName])
   if (ret === false) return validatorFunction.errors
   if (ret && ret.error) return ret.error
   if (ret && ret.value) request[paramName] = ret.value

package/lib/warnings.js

@@ -4,21 +4,9 @@ const warning = require('process-warning')()
 
 /**
  * Deprecation codes:
- *   - FSTDEP001
- *   - FSTDEP002
- *   - FSTDEP003
- *   - FSTDEP004
  *   - FSTDEP005
  */
 
-warning.create('FastifyDeprecation', 'FSTDEP001', 'You are accessing the Node.js core request object via "request.req", Use "request.raw" instead.')
-
-warning.create('FastifyDeprecation', 'FSTDEP002', 'You are accessing the Node.js core response object via "reply.res", Use "reply.raw" instead.')
-
-warning.create('FastifyDeprecation', 'FSTDEP003', 'You are using the legacy Content Type Parser function signature. Use the one suggested in the documentation instead.')
-
-warning.create('FastifyDeprecation', 'FSTDEP004', 'You are using the legacy preParsing hook signature. Use the one suggested in the documentation instead.')
-
 warning.create('FastifyDeprecation', 'FSTDEP005', 'You are accessing the deprecated "request.connection" property. Use "request.socket" instead.')
 
 warning.create('FastifyDeprecation', 'FSTDEP006', 'You are decorating Request/Reply with a reference type. This reference is shared amongst all requests. Use onRequest hook instead. Property: %s')
@@ -29,4 +17,8 @@ warning.create('FastifyDeprecation', 'FSTDEP008', 'You are using route constrain
 
 warning.create('FastifyDeprecation', 'FSTDEP009', 'You are using a custom route versioning strategy via the server { versioning: "..." } option, use { constraints: { version: "..." } } option instead.')
 
+warning.create('FastifyDeprecation', 'FSTDEP010', 'Modifying the "reply.sent" property is deprecated. Use the "reply.hijack()" method instead.')
+
+warning.create('FastifyDeprecation', 'FSTDEP011', 'Variadic listen method is deprecated. Please use ".listen(optionsObject)" instead. The variadic signature will be removed in `fastify@5`.')
+
 module.exports = warning

package/lib/wrapThenable.js

@@ -2,40 +2,33 @@
 
 const {
   kReplyIsError,
-  kReplySent,
-  kReplySentOverwritten
+  kReplyHijacked
 } = require('./symbols')
 
-const { FST_ERR_PROMISE_NOT_FULFILLED } = require('./errors')
-
 function wrapThenable (thenable, reply) {
   thenable.then(function (payload) {
-    if (reply[kReplySentOverwritten] === true) {
+    if (reply[kReplyHijacked] === true) {
       return
     }
 
     // this is for async functions that
     // are using reply.send directly
-    if (payload !== undefined || (reply.raw.statusCode === 204 && reply[kReplySent] === false)) {
+    if (payload !== undefined || reply.sent === 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[kReplySent] = false
         reply[kReplyIsError] = true
         reply.send(err)
       }
-    } else if (reply[kReplySent] === false) {
-      reply.log.error({ err: new FST_ERR_PROMISE_NOT_FULFILLED() }, "Promise may not be fulfilled with 'undefined' when statusCode is not 204")
     }
   }, function (err) {
-    if (reply[kReplySentOverwritten] === true || reply.sent === true) {
+    if (reply.sent === true) {
       reply.log.error({ err }, 'Promise errored, but reply.sent = true was set')
       return
     }
 
-    reply[kReplySent] = false
     reply[kReplyIsError] = true
     reply.send(err)
   })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "3.27.3",
+  "version": "4.0.0-alpha.2",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -9,6 +9,8 @@
     "bench": "branchcmp -r 2 -g -s \"npm run benchmark\"",
     "benchmark": "npx concurrently -k -s first \"node ./examples/benchmark/simple.js\" \"npx autocannon -c 100 -d 30 -p 10 localhost:3000/\"",
     "coverage": "npm run unit -- --cov --coverage-report=html",
+    "coverage:ci": "npm run unit -- --cov --coverage-report=html --no-browser --no-check-coverage -R terse",
+    "coverage:ci-check-coverage": "nyc check-coverage --branches 100 --functions 100 --lines 100 --statements 100",
     "license-checker": "license-checker --production --onlyAllow=\"MIT;ISC;BSD-3-Clause;BSD-2-Clause\"",
     "lint": "npm run lint:standard && npm run lint:typescript",
     "lint:fix": "standard --fix",
@@ -18,10 +20,11 @@
     "test": "npm run lint && npm run unit && npm run test:typescript",
     "test:ci": "npm run unit -- -R terse --cov --coverage-report=lcovonly && npm run test:typescript",
     "test:report": "npm run lint && npm run unit:report && npm run test:typescript",
-    "test:typescript": "tsd",
-    "unit": "tap -J test/*.test.js test/*/*.test.js",
+    "test:typescript": "tsc test/types/import.ts && tsd",
+    "test:watch": "npm run unit -- -w --no-coverage-report -R terse",
+    "unit": "tap",
     "unit:junit": "tap-mocha-reporter xunit < out.tap > test/junit-testresults.xml",
-    "unit:report": "tap -J test/*.test.js test/*/*.test.js --cov --coverage-report=html --coverage-report=cobertura | tee out.tap"
+    "unit:report": "tap --cov --coverage-report=html --coverage-report=cobertura | tee out.tap"
   },
   "repository": {
     "type": "git",
@@ -121,24 +124,19 @@
   },
   "homepage": "https://www.fastify.io/",
   "devDependencies": {
-    "@fastify/ajv-compiler-8": "npm:@fastify/ajv-compiler@^2.0.0",
     "@fastify/pre-commit": "^2.0.1",
-    "@hapi/joi": "^17.1.1",
+    "@sinclair/typebox": "^0.23.1",
     "@sinonjs/fake-timers": "^9.1.0",
-    "@types/node": "^16.0.0",
-    "@types/pino": "^6.0.1",
-    "@typescript-eslint/eslint-plugin": "^5.0.0",
-    "@typescript-eslint/parser": "^5.0.0",
-    "JSONStream": "^1.3.5",
-    "ajv": "^6.0.0",
-    "ajv-errors": "^1.0.1",
+    "@types/node": "^17.0.18",
+    "@typescript-eslint/eslint-plugin": "^5.7.0",
+    "@typescript-eslint/parser": "^5.7.0",
+    "ajv": "^8.10.0",
+    "ajv-errors": "^3.0.0",
     "ajv-formats": "^2.1.1",
-    "ajv-i18n": "^3.5.0",
-    "ajv-merge-patch": "^4.1.0",
-    "ajv-pack": "^0.3.1",
-    "branch-comparer": "^1.0.2",
+    "ajv-i18n": "^4.2.0",
+    "ajv-merge-patch": "^5.0.1",
+    "branch-comparer": "^1.1.0",
     "cors": "^2.8.5",
-    "coveralls": "^3.1.0",
     "dns-prefetch-control": "^0.3.0",
     "eslint": "^8.0.1",
     "eslint-config-standard": "^17.0.0-1",
@@ -147,46 +145,45 @@
     "eslint-plugin-n": "^14.0.0",
     "eslint-plugin-promise": "^6.0.0",
     "fast-json-body": "^1.1.0",
+    "fast-json-stringify": "^3.0.0",
     "fastify-plugin": "^3.0.0",
-    "fluent-json-schema": "^3.0.0",
+    "fluent-json-schema": "^3.0.1",
     "form-data": "^4.0.0",
     "frameguard": "^4.0.0",
     "h2url": "^0.2.0",
     "helmet": "^5.0.1",
     "hide-powered-by": "^1.1.0",
-    "hsts": "^2.2.0",
     "http-errors": "^2.0.0",
-    "ienoopen": "^1.1.0",
+    "joi": "^17.5.0",
+    "json-schema-to-ts": "^1.6.4",
+    "JSONStream": "^1.3.5",
     "license-checker": "^25.0.1",
-    "pem": "^1.14.4",
     "proxyquire": "^2.1.3",
     "pump": "^3.0.0",
-    "send": "^0.17.1",
+    "self-cert": "^2.0.0",
+    "send": "^0.17.2",
     "serve-static": "^1.14.1",
     "simple-get": "^4.0.0",
     "snazzy": "^9.0.0",
     "split2": "^4.1.0",
     "standard": "^17.0.0-2",
-    "tap": "^15.1.1",
-    "tap-mocha-reporter": "^5.0.1",
-    "then-sleep": "^1.0.1",
-    "tsd": "^0.19.0",
-    "typescript": "^4.0.2",
-    "undici": "^3.3.6",
+    "tap": "^16.0.0",
+    "tsd": "^0.19.1",
+    "typescript": "^4.5.4",
+    "undici": "^4.11.3",
     "x-xss-protection": "^2.0.0",
-    "yup": "^0.32.0"
+    "yup": "^0.32.11"
   },
   "dependencies": {
-    "@fastify/ajv-compiler": "^1.0.0",
-    "abstract-logging": "^2.0.0",
-    "avvio": "^7.1.2",
-    "fast-json-stringify": "^2.5.2",
-    "fastify-error": "^0.3.0",
+    "@fastify/ajv-compiler": "^3.1.0",
+    "@fastify/fast-json-stringify-compiler": "^1.0.0",
+    "abstract-logging": "^2.0.1",
+    "avvio": "^8.1.0",
+    "fastify-error": "^1.0.0",
+    "find-my-way": "^5.1.0",
+    "light-my-request": "^4.7.0",
+    "pino": "^7.5.1",
     "process-warning": "^1.0.0",
-    "find-my-way": "^4.5.0",
-    "flatstr": "^1.0.12",
-    "light-my-request": "^4.2.0",
-    "pino": "^6.13.0",
     "proxy-addr": "^2.0.7",
     "rfdc": "^1.1.4",
     "secure-json-parse": "^2.0.0",
@@ -196,6 +193,7 @@
   "standard": {
     "ignore": [
       "lib/configValidator.js",
+      "lib/error-serializer.js",
       "fastify.d.ts",
       "types/*",
       "test/types/*",