fastify 4.9.2 → 4.10.0

package/README.md

@@ -339,6 +339,8 @@ listed in alphabetical order.
   <https://twitter.com/manueomm>, <https://www.npmjs.com/~eomm>
 * [__Rafael Gonzaga__](https://github.com/rafaelgss),
   <https://twitter.com/_rafaelgss>, <https://www.npmjs.com/~rafaelgss>
+* [__Simone Busoli__](https://github.com/simoneb),
+  <https://twitter.com/simonebu>, <https://www.npmjs.com/~simoneb>  
 
 ### Great Contributors
 Great contributors on a specific area in the Fastify ecosystem will be invited
@@ -374,11 +376,15 @@ in the [OpenJS Foundation](https://openjsf.org/).
 ## Acknowledgements
 
 This project is kindly sponsored by:
-- [nearForm](https://nearform.com)
+- [NearForm](https://nearform.com)
+- [Platformatic](https://platformatic.dev)
 
 Past Sponsors:
 - [LetzDoIt](https://www.letzdoitapp.com/)
 
+This list includes all companies that support one or more of the team members
+in the maintainance of this project.
+
 ## License
 
 Licensed under [MIT](./LICENSE).

package/docs/Guides/Ecosystem.md

@@ -378,6 +378,8 @@ section.
   Fastify plugin to parse request language.
 - [`fastify-lcache`](https://github.com/denbon05/fastify-lcache)
   Lightweight cache plugin
+- [`fastify-list-routes`](https://github.com/chuongtrh/fastify-list-routes) 
+  A simple plugin for Fastify list all available routes.
 - [`fastify-loader`](https://github.com/TheNoim/fastify-loader) Load routes from
   a directory and inject the Fastify instance in each file.
 - [`fastify-lured`](https://github.com/lependu/fastify-lured) Plugin to load lua

package/docs/Guides/Plugins-Guide.md

@@ -439,24 +439,6 @@ async function plugin (fastify, opts) {
 
 export default plugin
 ```
-__Note__: Fastify does not support named imports within an ESM context. Instead,
-the `default` export is available.
-
-```js
-// server.mjs
-import Fastify from 'fastify'
-
-const fastify = Fastify()
-
-///...
-
-fastify.listen({ port: 3000 }, (err, address) => {
-  if (err) {
-    fastify.log.error(err)
-    process.exit(1)
-  }
-})
-```
 
 ## Handle errors
 <a id="handle-errors"></a>

package/docs/Guides/Recommendations.md

@@ -8,6 +8,8 @@ This document contains a set of recommendations when using Fastify.
   - [HAProxy](#haproxy)
   - [Nginx](#nginx)
 - [Kubernetes](#kubernetes)
+- [Capacity Planning For Production](#capacity)
+- [Running Multiple Instances](#multiple)
 
 ## Use A Reverse Proxy
 <a id="reverseproxy"></a>
@@ -298,3 +300,52 @@ readinessProbe:
     timeoutSeconds: 3
     successThreshold: 1
     failureThreshold: 5
+```
+
+## Capacity Planning For Production
+<a id="capacity"></a>
+
+In order to rightsize the production environment for your Fastify application, 
+it is highly recommended that you perform your own measurements against 
+different configurations of the environment, which may
+use real CPU cores, virtual CPU cores (vCPU), or even fractional
+vCPU cores. We will use the term vCPU throughout this
+recommendation to represent any CPU type.
+
+Tools such as [k6](https://github.com/grafana/k6) 
+or [autocannon](https://github.com/mcollina/autocannon) can be used for
+conducting the necessary performance tests.
+
+That said, you may also consider the following as a rule of thumb:
+
+* To have the lowest possible latency, 2 vCPU are recommended per app 
+instance (e.g., a k8s pod). The second vCPU will mostly be used by the 
+garbage collector (GC) and libuv threadpool. This will minimize the latency 
+for your users, as well as the memory usage, as the GC will be run more
+frequently. Also, the main thread won't have to stop to let the GC run.
+
+* To optimize for throughput (handling the largest possible amount of
+requests per second per vCPU available), consider using a smaller amount of vCPUs
+per app instance. It is totally fine to run Node.js application with 1 vCPU.
+
+* You may experiment with an even smaller amount of vCPU, which may provide 
+even better throughput in certain use-cases. There are reports of API gateway
+solutions working well with 100m-200m vCPU in Kubernetes.
+
+See [Node's Event Loop From the Inside Out ](https://www.youtube.com/watch?v=P9csgxBgaZ8)
+to understand the workings of Node.js in greater detail and make a
+better determination about what your specific application needs.
+
+## Running Multiple Instances
+<a id="multiple"></a>
+
+There are several use-cases where running multiple Fastify
+apps on the same server might be considered. A common example
+would be exposing metrics endpoints on a separate port,
+to prevent public access, when using a reverse proxy or an ingress
+firewall is not an option.
+
+It is perfectly fine to spin up several Fastify instances within the same 
+Node.js process and run them concurrently, even in high load systems. 
+Each Fastify instance only generates as much load as the traffic it receives,
+plus the memory used for that Fastify instance.

package/docs/Guides/Write-Type-Provider.md

@@ -0,0 +1,32 @@
+<h1 align="center">Fastify</h1>
+
+## How to write your own type provider
+
+Things to keep in mind when implementing a custom [type provider](../Reference/Type-Providers.md):
+
+### Type Contravariance
+
+Whereas exhaustive type narrowing checks normally rely on `never` to represent
+an unreachable state, reduction in type provider interfaces should only be done
+up to `unknown`.
+
+The reasoning is that certain methods of `FastifyInstance` are 
+contravariant on `TypeProvider`, which can lead to TypeScript surfacing 
+assignability issues unless the custom type provider interface is 
+substitutible with `FastifyTypeProviderDefault`.
+
+For example, `FastifyTypeProviderDefault` will not be assignable to the following:
+```ts
+export interface NotSubstitutibleTypeProvider extends FastifyTypeProvider {
+   // bad, nothing is assignable to `never` (except for itself)
+  output: this['input'] extends /** custom check here**/ ? /** narrowed type here **/ : never;
+}
+```
+
+Unless changed to:
+```ts
+export interface SubstitutibleTypeProvider extends FastifyTypeProvider {
+  // good, anything can be assigned to `unknown`
+  output: this['input'] extends /** custom check here**/ ? /** narrowed type here **/ : unknown; 
+}
+```

package/docs/Reference/Decorators.md

@@ -107,7 +107,13 @@ route [route](./Routes.md) handlers:
 fastify.decorate('db', new DbConnection())
 
 fastify.get('/', async function (request, reply) {
-  reply({hello: await this.db.query('world')})
+  // using return
+  return { hello: await this.db.query('world') }
+  
+  // or
+  // using reply.send()
+  reply.send({ hello: await this.db.query('world') })
+  await reply
 })
 ```
 

package/docs/Reference/Reply.md

@@ -234,8 +234,8 @@ as soon as possible.
 *Note: The header `Transfer-Encoding: chunked` will be added once you use the
 trailer. It is a hard requirement for using trailer in Node.js.*
 
-*Note: Currently, the computation function only supports synchronous function.
-That means `async-await` and `promise` are not supported.*
+*Note: Any error passed to `done` callback will be ignored. If you interested
+in the error, you can turn on `debug` level logging.*
 
 ```js
 reply.trailer('server-timing', function() {
@@ -246,7 +246,15 @@ const { createHash } = require('crypto')
 // trailer function also recieve two argument
 // @param {object} reply fastify reply
 // @param {string|Buffer|null} payload payload that already sent, note that it will be null when stream is sent
-reply.trailer('content-md5', function(reply, payload) {
+// @param {function} done callback to set trailer value
+reply.trailer('content-md5', function(reply, payload, done) {
+  const hash = createHash('md5')
+  hash.update(payload)
+  done(null, hash.disgest('hex'))
+})
+
+// when you prefer async-await
+reply.trailer('content-md5', async function(reply, payload) {
   const hash = createHash('md5')
   hash.update(payload)
   return hash.disgest('hex')
@@ -488,11 +496,11 @@ console.log(newSerialize === serialize) // false
 ### .serializeInput(data, [schema | httpStatus], [httpStatus], [contentType])
 <a id="serializeinput"></a>
 
-This function will serialize the input data based on the provided schema,
-or http status code. If both provided, the `httpStatus` will take presedence.
+This function will serialize the input data based on the provided schema
+or HTTP status code. If both are provided the `httpStatus` will take precedence.
 
-If there is not a serialization function for a given `schema`, a new serialization
-function will be compiled forwarding the `httpStatus`, and the `contentType` if provided.
+If there is not a serialization function for a given `schema` a new serialization
+function will be compiled, forwarding the `httpStatus` and `contentType` if provided.
 
 ```js
 reply

package/docs/Reference/Request.md

@@ -42,6 +42,17 @@ Request is a core Fastify object containing the following fields:
   handling the request
 - `routeConfig` - The route [`config`](./Routes.md#routes-config) 
   object.
+- `routeOptions` - The route [`option`](./Routes.md#routes-options) object
+  - `bodyLimit` - either server limit or route limit
+  - `method` - the http method for the route
+  - `url` - the path of the URL to match this route
+  - `attachValidation` - attach `validationError` to request 
+    (if there is a schema defined)
+  - `logLevel` - log level defined for this route
+  - `version` -  a semver compatible string that defines the version of the endpoint
+  - `exposeHeadRoute` - creates a sibling HEAD route for any GET routes
+  - `prefixTrailingSlash` - string used to determine how to handle passing / 
+    as a route with a prefix.
 - [.getValidationFunction(schema | httpPart)](#getvalidationfunction) - 
   Returns a validation function for the specified schema or http part,
   if any of either are set or cached.
@@ -90,7 +101,15 @@ fastify.post('/:params', options, function (request, reply) {
   console.log(request.protocol)
   console.log(request.url)
   console.log(request.routerMethod)
-  console.log(request.routerPath)
+  console.log(request.routeOptions.bodyLimit)
+  console.log(request.routeOptions.method)
+  console.log(request.routeOptions.url)
+  console.log(request.routeOptions.attachValidation)
+  console.log(request.routeOptions.logLevel)
+  console.log(request.routeOptions.version)
+  console.log(request.routeOptions.exposeHeadRoute)
+  console.log(request.routeOptions.prefixTrailingSlash)
+  console.log(request.routerPath.logLevel)
   request.log.info('some info')
 })
 ```

package/docs/Reference/Server.md

@@ -674,7 +674,7 @@ The default configuration is explained in the
 const fastify = require('fastify')({
   ajv: {
     customOptions: {
-      removeAdditional: 'all' // Refer to [ajv options](https://ajv.js.org/#options)
+      removeAdditional: 'all' // Refer to [ajv options](https://ajv.js.org/options.html#removeadditional)
     },
     plugins: [
       require('ajv-merge-patch'),
@@ -1426,6 +1426,13 @@ plugins are registered. If you would like to augment the behavior of the default
 arguments `fastify.setNotFoundHandler()` within the context of these registered
 plugins.
 
+> Note: Some config properties from the request object will be 
+> undefined inside the custom not found handler. E.g:
+> `request.routerPath`, `routerMethod` and `context.config`. 
+> This method design goal is to allow calling the common not found route.
+> To return a per-route customized 404 response, you can do it in
+> the response itself.
+
 #### setErrorHandler
 <a id="set-error-handler"></a>
 

package/docs/Reference/TypeScript.md

@@ -843,7 +843,7 @@ const server = fastify()
 Check out the Learn By Example - [Getting Started](#getting-started) example for
 a more detailed http server walkthrough.
 
-###### Example 2: HTTPS sever
+###### Example 2: HTTPS server
 
 1. Create the following imports from `@types/node` and `fastify`
    ```typescript

package/fastify.d.ts

@@ -183,6 +183,7 @@ type TrustProxyFunction = (address: string, hop: number) => boolean
 declare module '@fastify/error' {
   interface FastifyError {
     validation?: ValidationResult[];
+    validationContext?: 'body' | 'headers' | 'parameters' | 'querystring';
   }
 }
 

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.9.2'
+const VERSION = '4.10.0'
 
 const Avvio = require('avvio')
 const http = require('http')
@@ -410,11 +410,12 @@ function fastify (options) {
 
         /* istanbul ignore next: Cannot test this without Node.js core support */
         if (forceCloseConnections === 'idle') {
+          // Not needed in Node 19
           instance.server.closeIdleConnections()
         /* istanbul ignore next: Cannot test this without Node.js core support */
         } else if (serverHasCloseAllConnections && forceCloseConnections) {
           instance.server.closeAllConnections()
-        } else {
+        } else if (forceCloseConnections === true) {
           for (const conn of fastify[kKeepAliveConnections]) {
             // We must invoke the destroy method instead of merely unreffing
             // the sockets. If we only unref, then the callback passed to
@@ -565,17 +566,21 @@ function fastify (options) {
   function addHook (name, fn) {
     throwIfAlreadyStarted('Cannot call "addHook" when fastify instance is already started!')
 
+    if (fn == null) {
+      throw new errorCodes.FST_ERR_HOOK_INVALID_HANDLER(name, fn)
+    }
+
     if (name === 'onSend' || name === 'preSerialization' || name === 'onError' || name === 'preParsing') {
       if (fn.constructor.name === 'AsyncFunction' && fn.length === 4) {
-        throw new Error('Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+        throw new errorCodes.FST_ERR_HOOK_INVALID_ASYNC_HANDLER()
       }
     } else if (name === 'onReady') {
       if (fn.constructor.name === 'AsyncFunction' && fn.length !== 0) {
-        throw new Error('Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+        throw new errorCodes.FST_ERR_HOOK_INVALID_ASYNC_HANDLER()
       }
     } else {
       if (fn.constructor.name === 'AsyncFunction' && fn.length === 3) {
-        throw new Error('Async function has too many arguments. Async hooks should not use the \'done\' argument.')
+        throw new errorCodes.FST_ERR_HOOK_INVALID_ASYNC_HANDLER()
       }
     }
 

package/lib/contentTypeParser.js

@@ -94,9 +94,8 @@ ContentTypeParser.prototype.getParser = function (contentType) {
     return this.customParsers.get(contentType)
   }
 
-  if (this.cache.has(contentType)) {
-    return this.cache.get(contentType)
-  }
+  const parser = this.cache.get(contentType)
+  if (parser !== undefined) return parser
 
   // eslint-disable-next-line no-var
   for (var i = 0; i !== this.parserList.length; ++i) {
@@ -190,6 +189,9 @@ function rawBody (request, reply, options, parser, done) {
     : Number(request.headers['content-length'])
 
   if (contentLength > limit) {
+    // We must close the connection as the client is going
+    // to send this data anyway
+    reply.header('connection', 'close')
     reply.send(new FST_ERR_CTP_BODY_TOO_LARGE())
     return
   }
@@ -243,6 +245,7 @@ function rawBody (request, reply, options, parser, done) {
     }
 
     if (!Number.isNaN(contentLength) && (payload.receivedEncodedLength || receivedLength) !== contentLength) {
+      reply.header('connection', 'close')
       reply.send(new FST_ERR_CTP_INVALID_CONTENT_LENGTH())
       return
     }

package/lib/context.js

@@ -31,6 +31,8 @@ function Context ({
   serializerCompiler,
   replySerializer,
   schemaErrorFormatter,
+  exposeHeadRoute,
+  prefixTrailingSlash,
   server,
   isFastify
 }) {
@@ -52,6 +54,8 @@ function Context ({
   this._parserOptions = {
     limit: bodyLimit || server[kBodyLimit]
   }
+  this.exposeHeadRoute = exposeHeadRoute
+  this.prefixTrailingSlash = prefixTrailingSlash
   this.logLevel = logLevel || server[kLogLevel]
   this.logSerializers = logSerializers
   this[kFourOhFourContext] = null

package/lib/errors.js

@@ -101,6 +101,12 @@ const codes = {
     500,
     TypeError
   ),
+  FST_ERR_HOOK_INVALID_ASYNC_HANDLER: createError(
+    'FST_ERR_HOOK_INVALID_ASYNC_HANDLER',
+    'Async function has too many arguments. Async hooks should not use the \'done\' argument.',
+    500,
+    TypeError
+  ),
 
   /**
    * Middlewares

package/lib/hooks.js

@@ -52,7 +52,7 @@ Hooks.prototype.validate = function (hook, fn) {
   if (supportedHooks.indexOf(hook) === -1) {
     throw new Error(`${hook} hook not supported!`)
   }
-  if (typeof fn !== 'function') throw new FST_ERR_HOOK_INVALID_HANDLER(hook, typeof fn)
+  if (typeof fn !== 'function') throw new FST_ERR_HOOK_INVALID_HANDLER(hook, Object.prototype.toString.call(fn))
 }
 
 Hooks.prototype.add = function (hook, fn) {

package/lib/reply.js

@@ -570,8 +570,6 @@ function onSendEnd (reply, payload) {
 
     res.writeHead(statusCode, reply[kReplyHeaders])
     sendTrailer(payload, res, reply)
-    // avoid ArgumentsAdaptorTrampoline from V8
-    res.end(null, null, null)
     return
   }
 
@@ -600,8 +598,6 @@ function onSendEnd (reply, payload) {
   res.write(payload)
   // then send trailers
   sendTrailer(payload, res, reply)
-  // avoid ArgumentsAdaptorTrampoline from V8
-  res.end(null, null, null)
 }
 
 function logStreamError (logger, err, res) {
@@ -670,14 +666,61 @@ function sendStream (payload, res, reply) {
 }
 
 function sendTrailer (payload, res, reply) {
-  if (reply[kReplyTrailers] === null) return
+  if (reply[kReplyTrailers] === null) {
+    // when no trailer, we close the stream
+    res.end(null, null, null) // avoid ArgumentsAdaptorTrampoline from V8
+    return
+  }
   const trailerHeaders = Object.keys(reply[kReplyTrailers])
   const trailers = {}
+  let handled = 0
+  let skipped = true
+  function send () {
+    // add trailers when all handler handled
+    /* istanbul ignore else */
+    if (handled === 0) {
+      res.addTrailers(trailers)
+      // we need to properly close the stream
+      // after trailers sent
+      res.end(null, null, null) // avoid ArgumentsAdaptorTrampoline from V8
+    }
+  }
+
   for (const trailerName of trailerHeaders) {
     if (typeof reply[kReplyTrailers][trailerName] !== 'function') continue
-    trailers[trailerName] = reply[kReplyTrailers][trailerName](reply, payload)
+    skipped = false
+    handled--
+
+    function cb (err, value) {
+      // TODO: we may protect multiple callback calls
+      //       or mixing async-await with callback
+      handled++
+
+      // we can safely ignore error for trailer
+      // since it does affect the client
+      // we log in here only for debug usage
+      if (err) reply.log.debug(err)
+      else trailers[trailerName] = value
+
+      // we push the check to the end of event
+      // loop, so the registration continue to
+      // process.
+      process.nextTick(send)
+    }
+
+    const result = reply[kReplyTrailers][trailerName](reply, payload, cb)
+    if (typeof result === 'object' && typeof result.then === 'function') {
+      result.then((v) => cb(null, v), cb)
+    } else if (result !== null && result !== undefined) {
+      // TODO: should be removed in fastify@5
+      warning.emit('FSTDEP013')
+      cb(null, result)
+    }
   }
-  res.addTrailers(trailers)
+
+  // when all trailers are skipped
+  // we need to close the stream
+  if (skipped) res.end(null, null, null) // avoid ArgumentsAdaptorTrampoline from V8
 }
 
 function sendStreamTrailer (payload, res, reply) {

package/lib/request.js

@@ -165,6 +165,25 @@ Object.defineProperties(Request.prototype, {
       return this[kRouteContext].config.url
     }
   },
+  routeOptions: {
+    get () {
+      const context = this[kRouteContext]
+      const routeLimit = context._parserOptions.limit
+      const serverLimit = context.server.initialConfig.bodyLimit
+      const version = context.server.hasConstraintStrategy('version') ? this.raw.headers['accept-version'] : undefined
+      const options = {
+        method: context.config.method,
+        url: context.config.url,
+        bodyLimit: (routeLimit || serverLimit),
+        attachValidation: context.attachValidation,
+        logLevel: context.logLevel,
+        exposeHeadRoute: context.exposeHeadRoute,
+        prefixTrailingSlash: context.prefixTrailingSlash,
+        version
+      }
+      return Object.freeze(options)
+    }
+  },
   routerMethod: {
     get () {
       return this[kRouteContext].config.method

package/lib/route.js

@@ -249,11 +249,11 @@ function buildRouting (options) {
           if (Array.isArray(opts[hook])) {
             for (const func of opts[hook]) {
               if (typeof func !== 'function') {
-                throw new FST_ERR_HOOK_INVALID_HANDLER(hook, typeof func)
+                throw new FST_ERR_HOOK_INVALID_HANDLER(hook, Object.prototype.toString.call(func))
               }
             }
           } else if (opts[hook] !== undefined && typeof opts[hook] !== 'function') {
-            throw new FST_ERR_HOOK_INVALID_HANDLER(hook, typeof opts[hook])
+            throw new FST_ERR_HOOK_INVALID_HANDLER(hook, Object.prototype.toString.call(opts[hook]))
           }
         }
       }
@@ -278,6 +278,8 @@ function buildRouting (options) {
         replySerializer: this[kReplySerializerDefault],
         validatorCompiler: opts.validatorCompiler,
         serializerCompiler: opts.serializerCompiler,
+        exposeHeadRoute: shouldExposeHead,
+        prefixTrailingSlash: (opts.prefixTrailingSlash || 'both'),
         server: this,
         isFastify
       })
@@ -398,11 +400,15 @@ function buildRouting (options) {
     if (closing === true) {
       /* istanbul ignore next mac, windows */
       if (req.httpVersionMajor !== 2) {
-        res.once('finish', () => req.destroy())
         res.setHeader('Connection', 'close')
       }
 
+      // TODO remove return503OnClosing after Node v18 goes EOL
+      /* istanbul ignore else */
       if (return503OnClosing) {
+        // On Node v19 we cannot test this behavior as it won't be necessary
+        // anymore. It will close all the idle connections before they reach this
+        // stage.
         const headers = {
           'Content-Type': 'application/json',
           'Content-Length': '80'

package/lib/warnings.js

@@ -23,4 +23,6 @@ warning.create('FastifyDeprecation', 'FSTDEP011', 'Variadic listen method is dep
 
 warning.create('FastifyDeprecation', 'FSTDEP012', 'Request#context property access is deprecated. Please use "Request#routeConfig" or "Request#routeSchema" instead for accessing Route settings. The "Request#context" will be removed in `fastify@5`.')
 
+warning.create('FastifyDeprecation', 'FSTDEP013', '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`.')
+
 module.exports = warning

package/package.json

@@ -1,32 +1,10 @@
 {
   "name": "fastify",
-  "version": "4.9.2",
+  "version": "4.10.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
   "types": "fastify.d.ts",
-  "scripts": {
-    "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 && npm run lint:markdown",
-    "lint:fix": "standard --fix",
-    "lint:markdown": "markdownlint-cli2",
-    "lint:standard": "standard | snazzy",
-    "lint:typescript": "eslint -c types/.eslintrc.json types/**/*.d.ts test/types/**/*.test-d.ts",
-    "prepublishOnly": "PREPUBLISH=true tap --no-check-coverage test/build/**.test.js",
-    "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": "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 --cov --coverage-report=html --coverage-report=cobertura | tee out.tap"
-  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/fastify/fastify.git"
@@ -126,7 +104,7 @@
   "homepage": "https://www.fastify.io/",
   "devDependencies": {
     "@fastify/pre-commit": "^2.0.2",
-    "@sinclair/typebox": "^0.24.41",
+    "@sinclair/typebox": "^0.25.2",
     "@sinonjs/fake-timers": "^9.1.2",
     "@types/node": "^18.7.18",
     "@typescript-eslint/eslint-plugin": "^5.37.0",
@@ -184,7 +162,7 @@
     "rfdc": "^1.3.0",
     "secure-json-parse": "^2.5.0",
     "semver": "^7.3.7",
-    "tiny-lru": "^9.0.2"
+    "tiny-lru": "^10.0.0"
   },
   "standard": {
     "ignore": [
@@ -198,5 +176,26 @@
   },
   "tsd": {
     "directory": "test/types"
+  },
+  "scripts": {
+    "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 && npm run lint:markdown",
+    "lint:fix": "standard --fix",
+    "lint:markdown": "markdownlint-cli2",
+    "lint:standard": "standard | snazzy",
+    "lint:typescript": "eslint -c types/.eslintrc.json types/**/*.d.ts test/types/**/*.test-d.ts",
+    "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": "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 --cov --coverage-report=html --coverage-report=cobertura | tee out.tap"
   }
-}
+}