fastify 4.15.0 → 4.16.0

package/README.md

@@ -9,11 +9,11 @@
 
 <div align="center">
 
-[![CI](https://github.com/fastify/fastify/workflows/ci/badge.svg)](https://github.com/fastify/fastify/actions/workflows/ci.yml)
+[![CI](https://github.com/fastify/fastify/workflows/ci/badge.svg?branch=main)](https://github.com/fastify/fastify/actions/workflows/ci.yml)
 [![Package Manager
-CI](https://github.com/fastify/fastify/workflows/package-manager-ci/badge.svg)](https://github.com/fastify/fastify/actions/workflows/package-manager-ci.yml)
+CI](https://github.com/fastify/fastify/workflows/package-manager-ci/badge.svg?branch=main)](https://github.com/fastify/fastify/actions/workflows/package-manager-ci.yml)
 [![Web
-SIte](https://github.com/fastify/fastify/workflows/website/badge.svg)](https://github.com/fastify/fastify/actions/workflows/website.yml)
+SIte](https://github.com/fastify/fastify/workflows/website/badge.svg?branch=main)](https://github.com/fastify/fastify/actions/workflows/website.yml)
 [![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat)](https://standardjs.com/)
 
 </div>

package/docs/Guides/Database.md

@@ -130,19 +130,18 @@ fastify.register(require('@fastify/mongodb'), {
   url: 'mongodb://mongo/mydb'
 })
 
-fastify.get('/user/:id', function (req, reply) {
+fastify.get('/user/:id', async function (req, reply) {
   // Or this.mongo.client.db('mydb').collection('users')
   const users = this.mongo.db.collection('users')
 
   // if the id is an ObjectId format, you need to create a new ObjectId
   const id = this.mongo.ObjectId(req.params.id)
-  users.findOne({ id }, (err, user) => {
-    if (err) {
-      reply.send(err)
-      return
-    }
-    reply.send(user)
-  })
+  try {
+    const user = await users.findOne({ id })
+    return user
+  } catch (err) {
+    return err
+  }
 })
 
 fastify.listen({ port: 3000 }, err => {

package/docs/Guides/Ecosystem.md

@@ -11,7 +11,7 @@ section.
 - [`@fastify/accepts`](https://github.com/fastify/fastify-accepts) to have
   [accepts](https://www.npmjs.com/package/accepts) in your request object.
 - [`@fastify/accepts-serializer`](https://github.com/fastify/fastify-accepts-serializer)
-  to serialize to output according to `Accept` header.
+  to serialize to output according to the `Accept` header.
 - [`@fastify/any-schema`](https://github.com/fastify/any-schema-you-like) Save
   multiple schemas and decide which one to use to serialize the payload
 - [`@fastify/auth`](https://github.com/fastify/fastify-auth) Run multiple auth
@@ -151,7 +151,7 @@ section.
 - [`@eropple/fastify-openapi3`](https://github.com/eropple/fastify-openapi3) Provides
   easy, developer-friendly OpenAPI 3.1 specs + doc explorer based on your routes.
 - [`@ethicdevs/fastify-custom-session`](https://github.com/EthicDevs/fastify-custom-session)
-  A plugin that let you use session and decide only where to load/save from/to. Has
+  A plugin lets you use session and decide only where to load/save from/to. Has
   great TypeScript support + built-in adapters for common ORMs/databases (Firebase,
   Prisma Client, Postgres (wip), InMemory) and you can easily make your own adapter!
 - [`@ethicdevs/fastify-git-server`](https://github.com/EthicDevs/fastify-git-server)
@@ -174,7 +174,6 @@ section.
 - [`@immobiliarelabs/fastify-sentry`](https://github.com/immobiliare/fastify-sentry)
   Sentry errors handler that just works! Install, add your DSN and you're good
   to go!
-- [`@mateonunez/fastify-lyra`](https://github.com/mateonunez/fastify-lyra)
   A plugin to implement [Lyra](https://github.com/nearform/lyra) search engine
   on Fastify
 - [`@mgcrea/fastify-graceful-exit`](https://github.com/mgcrea/fastify-graceful-exit)
@@ -391,9 +390,11 @@ section.
 - [`fastify-keycloak-adapter`](https://github.com/yubinTW/fastify-keycloak-adapter)
   A keycloak adapter for a Fastify app.
 - [`fastify-knexjs`](https://github.com/chapuletta/fastify-knexjs) Fastify
-  plugin for support KnexJS Query Builder.
+  plugin for supporting KnexJS Query Builder.
 - [`fastify-knexjs-mock`](https://github.com/chapuletta/fastify-knexjs-mock)
   Fastify Mock KnexJS for testing support.
+- [`fastify-koa`](https://github.com/rozzilla/fastify-koa) Convert Koa
+middlewares into Fastify plugins
 - [`fastify-kubernetes`](https://github.com/greguz/fastify-kubernetes) Fastify
   Kubernetes client plugin.
 - [`fastify-language-parser`](https://github.com/lependu/fastify-language-parser)
@@ -401,13 +402,14 @@ section.
 - [`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.
+  A simple plugin for Fastify to 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-log-controller`](https://github.com/Eomm/fastify-log-controller/)
+  changes the log level of your Fastify server at runtime.
 - [`fastify-lured`](https://github.com/lependu/fastify-lured) Plugin to load lua
   scripts with [fastify-redis](https://github.com/fastify/fastify-redis) and
   [lured](https://github.com/enobufs/lured).
-- [`fastify-lyra`](https://github.com/mateonunez/fastify-lyra)
   A plugin to implement [Lyra](https://github.com/LyraSearch/lyra) search engine
   on Fastify.
 - [`fastify-mailer`](https://github.com/coopflow/fastify-mailer) Plugin to
@@ -475,6 +477,7 @@ section.
 - [`fastify-oracle`](https://github.com/cemremengu/fastify-oracle) Attaches an
   [`oracledb`](https://github.com/oracle/node-oracledb) connection pool to a
   Fastify server instance.
+- [`fastify-orama`](https://github.com/mateonunez/fastify-orama)
 - [`fastify-orientdb`](https://github.com/mahmed8003/fastify-orientdb) Fastify
   OrientDB connection plugin, with which you can share the OrientDB connection
   across every part of your server.
@@ -518,6 +521,8 @@ section.
 - [`fastify-redis-channels`](https://github.com/hearit-io/fastify-redis-channels)
   A plugin for fast, reliable, and scalable channels implementation based on
   Redis streams.
+- [`fastify-redis-session`](https://github.com/mohammadraufzahed/fastify-redis-session)
+  Redis Session plugin for fastify.
 - [`fastify-register-routes`](https://github.com/israeleriston/fastify-register-routes)
   Plugin to automatically load routes from a specified path and optionally limit
   loaded file names by a regular expression.
@@ -586,6 +591,10 @@ section.
   TOTP (e.g. for 2FA).
 - [`fastify-twitch-ebs-tools`](https://github.com/lukemnet/fastify-twitch-ebs-tools)
   Useful functions for Twitch Extension Backend Services (EBS).
+- [`fastify-type-provider-effect-schema`](https://github.com/daotl/fastify-type-provider-effect-schema)
+  Fastify
+  [type provider](https://www.fastify.io/docs/latest/Reference/Type-Providers/)
+  for [@effect/schema](https://github.com/effect-ts/schema).
 - [`fastify-type-provider-zod`](https://github.com/turkerdev/fastify-type-provider-zod)
   Fastify
   [type provider](https://www.fastify.io/docs/latest/Reference/Type-Providers/)
@@ -637,7 +646,7 @@ section.
 - [`openapi-validator-middleware`](https://github.com/PayU/openapi-validator-middleware#fastify)
   Swagger and OpenAPI 3.0 spec-based request validation middleware that supports
   Fastify.
-- [`pubsub-http-handler`](https://github.com/cobraz/pubsub-http-handler) A Fastify
+- [`pubsub-http-handler`](https://github.com/simenandre/pubsub-http-handler) A Fastify
   plugin to easily create Google Cloud PubSub endpoints.
 - [`sequelize-fastify`](https://github.com/hsynlms/sequelize-fastify) A simple
   and lightweight Sequelize plugin for Fastify.

package/docs/Guides/Getting-Started.md

@@ -538,7 +538,7 @@ an amazing [ecosystem](./Ecosystem.md)!
 <a id="test-server"></a>
 
 Fastify does not offer a testing framework, but we do recommend a way to write
-your tests that uses the features and architecture of Fastify.
+your tests that use the features and architecture of Fastify.
 
 Read the [testing](./Testing.md) documentation to learn more!
 

package/docs/Guides/Migration-Guide-V4.md

@@ -130,6 +130,27 @@ As a result, if you specify an `onRoute` hook in a plugin you should now either:
   });
   ```
 
+### Optional URL parameters
+
+If you've already used any implicitly optional parameters, you'll get a 404
+error when trying to access the route. You will now need to declare the
+optional parameters explicitly.
+
+For example, if you have the same route for listing and showing a post,
+refactor this:
+```js
+fastify.get('/posts/:id', (request, reply) => {
+  const { id } = request.params;
+});
+```
+
+Into this:
+```js
+fastify.get('/posts/:id?', (request, reply) => {
+  const { id } = request.params;
+});
+```
+
 ## Non-Breaking Changes
 
 ### Deprecation of variadic `.listen()` signature

package/docs/Guides/Plugins-Guide.md

@@ -427,7 +427,7 @@ variables that were injected by preceding plugins in the order of declaration.
 
 ESM is supported as well from [Node.js
 `v13.3.0`](https://nodejs.org/api/esm.html) and above! Just export your plugin
-as ESM module and you are good to go!
+as an ESM module and you are good to go!
 
 ```js
 // plugin.mjs

package/docs/Guides/Prototype-Poisoning.md

@@ -4,29 +4,24 @@
 > but otherwise remains the same. The original HTML can be retrieved from the
 > above permission link.
 
-## A Tale of (prototype) Poisoning
+## History behind prototype poisoning
 <a id="pp"></a>
 
-This story is a behind-the-scenes look at the process and drama created by a
-particularity interesting web security issue. It is also a perfect illustration
-of the efforts required to maintain popular pieces of open source software and
-the limitations of existing communication channels.
-
-But first, if you use a JavaScript framework to process incoming JSON data, take
-a moment to read up on [Prototype
-Poisoning](https://medium.com/intrinsic/javascript-prototype-poisoning-vulnerabilities-in-the-wild-7bc15347c96)
-in general, and the specific [technical
-details](https://github.com/hapijs/hapi/issues/3916) of this issue. I'll explain
-it all in a bit, but since this could be a critical issue, you might want to
-verify your own code first. While this story is focused on a specific framework,
-any solution that uses `JSON.parse()` to process external data is potentially at
-risk.
+Based on the article by Eran Hammer,the issue is created by a web security bug.
+It is also a perfect illustration of the efforts required to maintain 
+open-source software and the limitations of existing communication channels.
+
+But first, if we use a JavaScript framework to process incoming JSON data, take
+a moment to read up on [Prototype Poisoning](https://medium.com/intrinsic/javascript-prototype-poisoning-vulnerabilities-in-the-wild-7bc15347c96)
+in general, and the specific [technical details]
+(https://github.com/hapijs/hapi/issues/3916) of this issue.
+This could be a critical issue so, we might need to verify your own code first.
+It focuses on specific framework however, any solution that uses `JSON.parse()` 
+to process external data is potentially at risk.
 
 ### BOOM
 <a id="pp-boom"></a>
 
-Our story begins with a bang.
-
 The engineering team at Lob (long time generous supporters of my work!) reported
 a critical security vulnerability they identified in our data validation
 module — [joi](https://github.com/hapijs/joi). They provided some technical
@@ -34,21 +29,22 @@ details and a proposed solution.
 
 The main purpose of a data validation library is to ensure the output fully
 complies with the rules defined. If it doesn't, validation fails. If it passes,
-your can blindly trust that the data you are working with is safe. In fact, most
+we can blindly trust that the data you are working with is safe. In fact, most
 developers treat validated input as completely safe from a system integrity
-perspective. This is crucial.
+perspective which is crucial!
 
-In our case, the Lob team provided an example where some data was able to sneak
+In our case, the Lob team provided an example where some data was able to escape
 by the validation logic and pass through undetected. This is the worst possible
 defect a validation library can have.
 
 ### Prototype in a nutshell
 <a id="pp-nutshell"></a>
 
-To understand this story, you need to understand how JavaScript works a bit.
+To understand this, we need to understand how JavaScript works a bit.
 Every object in JavaScript can have a prototype. It is a set of methods and
-properties it "inherits" from another object. I put inherits in quotes because
-JavaScript isn't really an object oriented language.
+properties it "inherits" from another object. I have put inherits in quotes 
+because JavaScript isn't really an object-oriented language.It is prototype-
+based object-oriented language.
 
 A long time ago, for a bunch of irrelevant reasons, someone decided that it
 would be a good idea to use the special property name `__proto__` to access (and
@@ -68,22 +64,21 @@ To demonstrate:
 { b: 5 }
 ```
 
-As you can see, the object doesn't have a `c` property, but its prototype does.
+The object doesn't have a `c` property, but its prototype does.
 When validating the object, the validation library ignores the prototype and
 only validates the object's own properties. This allows `c` to sneak in via the
 prototype.
 
-Another important part of this story is the way `JSON.parse()` — a utility
-provided by the language to convert JSON formatted text into objects  —  handles
-this magic `__proto__` property name.
+Another important part is the way `JSON.parse()` — a utility
+provided by the language to convert JSON formatted text into
+objects  —  handles this magic `__proto__` property name.
 
 ```
-> const text = '{ "b": 5, "__proto__": { "c": 6 } }';
+> const text = '{"b": 5, "__proto__": { "c": 6 }}';
 > const a = JSON.parse(text);
 > a;
-{ b: 5, __proto__: { c: 6 } }
+{b: 5, __proto__: { c: 6 }}
 ```
-
 Notice how `a` has a `__proto__` property. This is not a prototype reference. It
 is a simple object property key, just like `b`. As we've seen from the first
 example, we can't actually create this key through assignment as that invokes
@@ -111,17 +106,17 @@ level properties of `a` into the provided empty `{}` object), the magic
 
 Surprise!
 
-Put together, if you get some external text input, parse it with `JSON.parse()`
-then perform some simple manipulation of that object (say, shallow clone and add
-an `id` ), and then pass it to our validation library, anything passed through
-via `__proto__` would sneak in undetected.
+If you get some external text input and parse it with `JSON.parse()`
+then perform some simple manipulation of that object (e.g shallow clone and add
+an `id` ), and pass it to our validation library, it would sneak in undetected
+via `__proto__`.
 
 ### Oh joi!
 <a id="pp-oh-joi"></a>
 
 The first question is, of course, why does the validation module **joi** ignore
 the prototype and let potentially harmful data through? We asked ourselves the
-same question and our instant thought was "it was an oversight". A bug. A really
+same question and our instant thought was "it was an oversight". A bug - a really
 big mistake. The joi module should not have allowed this to happen. But…
 
 While joi is used primarily for validating web input data, it also has a
@@ -166,7 +161,6 @@ will share with the world how to exploit this vulnerability while also making it
 more time consuming for systems to upgrade (breaking changes never get applied
 automatically by build tools).
 
-Lose — Lose.
 
 ### A detour
 <a id="pp-detour"></a>
@@ -386,6 +380,4 @@ plan](https://web.archive.org/web/20190201220503/https://hueniverse.com/on-hapi-
 coming in March. You can read more about it
 [here](https://web.archive.org/web/20190201220503/https://hueniverse.com/on-hapi-licensing-a-preview-f982662ee898).
 
-Of all the time consuming things, security is at the very top. I hope this story
-successfully conveyed not just the technical details, but also the human drama and
-what it takes to keep the web secure.
+

package/docs/Guides/Recommendations.md

@@ -326,7 +326,7 @@ 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.
+per app instance. It is totally fine to run Node.js applications 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

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

@@ -13,11 +13,11 @@ 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`.
+substitutable with `FastifyTypeProviderDefault`.
 
 For example, `FastifyTypeProviderDefault` will not be assignable to the following:
 ```ts
-export interface NotSubstitutibleTypeProvider extends FastifyTypeProvider {
+export interface NotSubstitutableTypeProvider extends FastifyTypeProvider {
    // bad, nothing is assignable to `never` (except for itself)
   output: this['input'] extends /** custom check here**/ ? /** narrowed type here **/ : never;
 }
@@ -25,7 +25,7 @@ export interface NotSubstitutibleTypeProvider extends FastifyTypeProvider {
 
 Unless changed to:
 ```ts
-export interface SubstitutibleTypeProvider extends FastifyTypeProvider {
+export interface SubstitutableTypeProvider extends FastifyTypeProvider {
   // good, anything can be assigned to `unknown`
   output: this['input'] extends /** custom check here**/ ? /** narrowed type here **/ : unknown; 
 }

package/docs/Reference/Hooks.md

@@ -25,6 +25,7 @@ are Request/Reply hooks and application hooks:
 - [Application Hooks](#application-hooks)
   - [onReady](#onready)
   - [onClose](#onclose)
+  - [preClose](#preclose)
   - [onRoute](#onroute)
   - [onRegister](#onregister)
 - [Scope](#scope)
@@ -266,19 +267,19 @@ fastify.addHook('onTimeout', async (request, reply) => {
 `onTimeout` is useful if you need to monitor the request timed out in your
 service (if the `connectionTimeout` property is set on the Fastify instance).
 The `onTimeout` hook is executed when a request is timed out and the HTTP socket
-has been hanged up. Therefore, you will not be able to send data to the client.
+has been hung up. Therefore, you will not be able to send data to the client.
 
 ### onRequestAbort
 
 ```js
-fastify.addHook('onRequestAbort', (request, reply, done) => {
+fastify.addHook('onRequestAbort', (request, done) => {
   // Some code
   done()
 })
 ```
 Or `async/await`:
 ```js
-fastify.addHook('onRequestAbort', async (request, reply) => {
+fastify.addHook('onRequestAbort', async (request) => {
   // Some code
   await asyncMethod()
 })
@@ -385,6 +386,7 @@ You can hook into the application-lifecycle as well.
 
 - [onReady](#onready)
 - [onClose](#onclose)
+- [preClose](#preclose)
 - [onRoute](#onroute)
 - [onRegister](#onregister)
 
@@ -414,9 +416,10 @@ fastify.addHook('onReady', async function () {
 ### onClose
 <a id="on-close"></a>
 
-Triggered when `fastify.close()` is invoked to stop the server. It is useful
-when [plugins](./Plugins.md) need a "shutdown" event, for example, to close an
-open connection to a database.
+Triggered when `fastify.close()` is invoked to stop the server, after all in-flight
+HTTP requests have been completed.
+It is useful when [plugins](./Plugins.md) need a "shutdown" event, for example,
+to close an open connection to a database.
 
 The hook function takes the Fastify instance as a first argument, 
 and a `done` callback for synchronous hook functions.
@@ -434,10 +437,34 @@ fastify.addHook('onClose', async (instance) => {
 })
 ```
 
+### preClose
+<a id="pre-close"></a>
+
+Triggered when `fastify.close()` is invoked to stop the server, before all in-flight
+HTTP requests have been completed.
+It is useful when [plugins](./Plugins.md) have set up some state attached
+to the HTTP server that would prevent the server to close.
+_It is unlikely you will need to use this hook_,
+use the [`onClose`](#onclose) for the most common case.
+
+```js
+// callback style
+fastify.addHook('preClose', (done) => {
+  // Some code
+  done()
+})
+
+// or async/await style
+fastify.addHook('preClose', async () => {
+  // Some async code
+  await removeSomeServerState()
+})
+```
+
 ### onRoute
 <a id="on-route"></a>
 
-Triggered when a new route is registered. Listeners are passed a `routeOptions`
+Triggered when a new route is registered. Listeners are passed a [`routeOptions`](./Routes.md#routes-options)
 object as the sole parameter. The interface is synchronous, and, as such, the
 listeners are not passed a callback. This hook is encapsulated.
 
@@ -655,6 +682,12 @@ fastify.route({
     // This hook will always be executed after the shared `onRequest` hooks
     done()
   },
+  // // Example with an async hook. All hooks support this syntax
+  //
+  // onRequest: async function (request, reply) {
+  //  // This hook will always be executed after the shared `onRequest` hooks
+  //  await ...
+  // }
   onResponse: function (request, reply, done) {
     // this hook will always be executed after the shared `onResponse` hooks
     done()
@@ -728,7 +761,7 @@ fastify.get('/me/is-admin', async function (req, reply) {
 ```
 
 Note that `.authenticatedUser` could actually be any property name
-choosen by yourself. Using your own custom property prevents you
+chosen by yourself. Using your own custom property prevents you
 from mutating existing properties, which
 would be a dangerous and destructive operation. So be careful and
 make sure your property is entirely new, also using this approach
@@ -774,7 +807,7 @@ initialization of the tracking package, in the typical "require instrumentation
 tools first" fashion.
 
 ```js
-const tracer = /* retrieved from elsehwere in the package */
+const tracer = /* retrieved from elsewhere in the package */
 const dc = require('diagnostics_channel')
 const channel = dc.channel('fastify.initialization')
 const spans = new WeakMap()

package/docs/Reference/Reply.md

@@ -243,7 +243,7 @@ reply.trailer('server-timing', function() {
 })
 
 const { createHash } = require('crypto')
-// trailer function also recieve two argument
+// trailer function also receive 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
 // @param {function} done callback to set trailer value
@@ -396,7 +396,7 @@ The function returned (a.k.a. _serialization function_) returned is compiled
 by using the provided `SerializerCompiler`. Also this is cached by using
 a `WeakMap` for reducing compilation calls.
 
-The optional paramaters `httpStatus` and `contentType`, if provided, 
+The optional parameters `httpStatus` and `contentType`, if provided, 
 are forwarded directly to the `SerializerCompiler`, so it can be used 
 to compile the serialization function if a custom `SerializerCompiler` is used.
 

package/docs/Reference/Routes.md

@@ -78,7 +78,7 @@ fastify.route(options)
   when a response has been sent, so you will not be able to send more data to
   the client. It could also be an array of functions.
 * `onTimeout(request, reply, done)`: a [function](./Hooks.md#ontimeout) called
-  when a request is timed out and the HTTP socket has been hanged up.
+  when a request is timed out and the HTTP socket has been hung up.
 * `onError(request, reply, error, done)`: a [function](./Hooks.md#onerror)
   called when an Error is thrown or sent to the client by the route handler.
 * `handler(request, reply)`: the function that will handle this request. The
@@ -219,7 +219,7 @@ fastify.get('/', opts)
 ```
 
 > Note: if the handler is specified in both the `options` and as the third
-> parameter to the shortcut method then throws duplicate `handler` error.
+> parameter to the shortcut method then throws a duplicate `handler` error.
 
 ### Url building
 <a id="url-building"></a>
@@ -290,6 +290,17 @@ fastify.get('/example/at/:hour(^\\d{2})h:minute(^\\d{2})m', function (request, r
 In this case as parameter separator it is possible to use whatever character is
 not matched by the regular expression.
 
+The last parameter can be made optional if you add a question mark ("?") to the
+end of the parameters name.
+```js
+fastify.get('/example/posts/:id?', function (request, reply) {
+  const { id } = request.params;
+  // your code here
+})
+```
+In this case you can request `/example/posts` as well as `/example/posts/1`.
+The optional param will be undefined if not specified.
+
 Having a route with multiple parameters may negatively affect performance, so
 prefer a single parameter approach whenever possible, especially on routes that
 are on the hot path of your application. If you are interested in how we handle

package/docs/Reference/Server.md

@@ -916,9 +916,25 @@ fastify.ready().then(() => {
 
 Starts the server and internally waits for the `.ready()` event. The signature
 is `.listen([options][, callback])`. Both the `options` object and the
-`callback` parameters follow the [Node.js
-core](https://nodejs.org/api/net.html#serverlistenoptions-callback) parameter
-definitions.
+`callback` parameters extend the [Node.js
+core](https://nodejs.org/api/net.html#serverlistenoptions-callback) options
+object. Thus, all core options are available with the following additional 
+Fastify specific options:
+
+### `listenTextResolver`
+<a id="listen-text-resolver"></a>
+
+Set an optional resolver for the text to log after server has been successfully
+started.
+It is possible to override the default `Server listening at [address]` log 
+entry using this option.
+
+```js
+server.listen({ 
+  port: 9080, 
+  listenTextResolver: (address) => { return `Prometheus metrics server is listening at ${address}` } 
+})
+```
 
 By default, the server will listen on the address(es) resolved by `localhost`
 when no specific host is provided. If listening on any available interface is

package/docs/Reference/Type-Providers.md

@@ -170,7 +170,7 @@ function plugin1(fastify: FastifyInstance, _opts, done): void {
       })
     }
   }, (req) => {
-    // it doesn't works! in a new scope needs to call `withTypeProvider` again
+    // it doesn't work! in a new scope needs to call `withTypeProvider` again
     const { x, y, z } = req.body
   });
   done()

package/docs/Reference/TypeScript.md

@@ -186,7 +186,7 @@ Serialization](./Validation-and-Serialization.md) documentation for more info.
 Also it has the advantage to use the defined type within your handlers
 (including pre-validation, etc.).
 
-Here are some options how to achieve this.
+Here are some options on how to achieve this.
 
 #### Fastify Type Providers
 
@@ -1307,10 +1307,10 @@ types defined in this section are used under-the-hood by the Fastify instance
 [src](https://github.com/fastify/fastify/blob/main/types/route.d.ts#L105)
 
 A type declaration for the route handler methods. Has two arguments, `request`
-and `reply` which are typed by `FastifyRequest` and `FastifyReply` respectfully.
+and `reply` which are typed by `FastifyRequest` and `FastifyReply` respectively.
 The generics parameters are passed through to these arguments. The method
 returns either `void` or `Promise<any>` for synchronous and asynchronous
-handlers respectfully.
+handlers respectively.
 
 ##### fastify.RouteOptions<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>
 

package/docs/index.md

@@ -7,8 +7,8 @@ The documentation for Fastify is split into two categories:
 
 The reference documentation utilizes a very formal style in an effort to document
 Fastify's API and implementation details thoroughly for the developer who needs
-such. The guides category utilizes an informal, educational, style as a means to
-introduce newcomers to core, and advanced, Fastify concepts.
+such. The guides category utilizes an informal educational style as a means to
+introduce newcomers to core and advanced Fastify concepts.
 
 ## Where To Start
 

package/examples/benchmark/parser.js

@@ -0,0 +1,47 @@
+'use strict'
+
+const fastify = require('../../fastify')({
+  logger: false
+})
+
+const jsonParser = require('fast-json-body')
+const querystring = require('querystring')
+
+// Handled by fastify
+// curl -X POST -d '{"hello":"world"}' -H'Content-type: application/json' http://localhost:3000/
+
+// curl -X POST -d '{"hello":"world"}' -H'Content-type: application/jsoff' http://localhost:3000/
+fastify.addContentTypeParser('application/jsoff', function (request, payload, done) {
+  jsonParser(payload, function (err, body) {
+    done(err, body)
+  })
+})
+
+// curl -X POST -d 'hello=world' -H'Content-type: application/x-www-form-urlencoded' http://localhost:3000/
+fastify.addContentTypeParser('application/x-www-form-urlencoded', function (request, payload, done) {
+  let body = ''
+  payload.on('data', function (data) {
+    body += data
+  })
+  payload.on('end', function () {
+    try {
+      const parsed = querystring.parse(body)
+      done(null, parsed)
+    } catch (e) {
+      done(e)
+    }
+  })
+  payload.on('error', done)
+})
+
+// curl -X POST -d '{"hello":"world"}' -H'Content-type: application/vnd.custom+json' http://localhost:3000/
+fastify.addContentTypeParser(/^application\/.+\+json$/, { parseAs: 'string' }, fastify.getDefaultJsonParser('error', 'ignore'))
+
+fastify
+  .post('/', function (req, reply) {
+    reply.send(req.body)
+  })
+
+fastify.listen({ port: 3000 }, (err, address) => {
+  if (err) throw err
+})