@teammy/server 0.0.3 → 0.0.4

package/node_modules/fastify/docs/Reference/Server.md

@@ -0,0 +1,2538 @@
+<h1 align="center">Fastify</h1>
+
+## Factory
+<a id="factory"></a>
+
+The Fastify module exports a factory function that is used to create new
+<code><b>Fastify server</b></code> instances. This factory function accepts an
+options object which is used to customize the resulting instance. This document
+describes the properties available in that options object.
+
+- [Factory](#factory)
+  - [`http`](#http)
+  - [`http2`](#http2)
+  - [`https`](#https)
+  - [`connectionTimeout`](#connectiontimeout)
+  - [`keepAliveTimeout`](#keepalivetimeout)
+  - [`forceCloseConnections`](#forcecloseconnections)
+  - [`maxRequestsPerSocket`](#maxrequestspersocket)
+  - [`requestTimeout`](#requesttimeout)
+  - [`bodyLimit`](#bodylimit)
+  - [`onProtoPoisoning`](#onprotopoisoning)
+  - [`onConstructorPoisoning`](#onconstructorpoisoning)
+  - [`logger`](#logger)
+  - [`loggerInstance`](#loggerinstance)
+  - [`disableRequestLogging`](#disablerequestlogging)
+  - [`logController`](#logcontroller)
+  - [`serverFactory`](#serverfactory)
+  - [`requestIdHeader`](#requestidheader)
+  - [`requestIdLogLabel`](#requestidloglabel)
+  - [`genReqId`](#genreqid)
+  - [`trustProxy`](#trustproxy)
+  - [`pluginTimeout`](#plugintimeout)
+  - [`exposeHeadRoutes`](#exposeheadroutes)
+  - [`return503OnClosing`](#return503onclosing)
+  - [`ajv`](#ajv)
+  - [`serializerOpts`](#serializeropts)
+  - [`http2SessionTimeout`](#http2sessiontimeout)
+  - [`frameworkErrors`](#frameworkerrors)
+  - [`clientErrorHandler`](#clienterrorhandler)
+  - [`rewriteUrl`](#rewriteurl)
+  - [`allowErrorHandlerOverride`](#allowerrorhandleroverride)
+  - [RouterOptions](#routeroptions)
+    - [`allowUnsafeRegex`](#allowunsaferegex)
+    - [`buildPrettyMeta`](#buildprettymeta)
+    - [`caseSensitive`](#casesensitive)
+    - [`constraints`](#constraints)
+    - [`defaultRoute`](#defaultroute)
+    - [`ignoreDuplicateSlashes`](#ignoreduplicateslashes)
+    - [`ignoreTrailingSlash`](#ignoretrailingslash)
+    - [`maxParamLength`](#maxparamlength)
+    - [`onBadUrl`](#onbadurl)
+    - [`onMaxParamLength`](#onmaxparamlength)
+    - [`querystringParser`](#querystringparser)
+    - [`useSemicolonDelimiter`](#usesemicolondelimiter)
+- [Instance](#instance)
+  - [Server Methods](#server-methods)
+    - [server](#server)
+    - [after](#after)
+    - [ready](#ready)
+    - [listen](#listen)
+    - [addresses](#addresses)
+    - [routing](#routing)
+    - [route](#route)
+    - [hasRoute](#hasroute)
+    - [findRoute](#findroute)
+    - [close](#close)
+    - [decorate\*](#decorate)
+    - [register](#register)
+    - [addHook](#addhook)
+    - [prefix](#prefix)
+    - [pluginName](#pluginname)
+    - [hasPlugin](#hasplugin)
+    - [listeningOrigin](#listeningorigin)
+    - [log](#log)
+    - [version](#version)
+    - [inject](#inject)
+    - [addHttpMethod](#addHttpMethod)
+    - [addSchema](#addschema)
+    - [getSchemas](#getschemas)
+    - [getSchema](#getschema)
+    - [setReplySerializer](#setreplyserializer)
+    - [setValidatorCompiler](#setvalidatorcompiler)
+    - [setSchemaErrorFormatter](#setschemaerrorformatter)
+    - [setSerializerCompiler](#setserializercompiler)
+    - [validatorCompiler](#validatorcompiler)
+    - [serializerCompiler](#serializercompiler)
+    - [schemaErrorFormatter](#schemaerrorformatter)
+    - [schemaController](#schemacontroller)
+    - [setNotFoundHandler](#setnotfoundhandler)
+    - [setErrorHandler](#seterrorhandler)
+    - [setChildLoggerFactory](#setchildloggerfactory)
+    - [setGenReqId](#setgenreqid)
+    - [addConstraintStrategy](#addconstraintstrategy)
+    - [hasConstraintStrategy](#hasconstraintstrategy)
+    - [printRoutes](#printroutes)
+    - [printPlugins](#printplugins)
+    - [addContentTypeParser](#addcontenttypeparser)
+    - [hasContentTypeParser](#hascontenttypeparser)
+    - [removeContentTypeParser](#removecontenttypeparser)
+    - [removeAllContentTypeParsers](#removeallcontenttypeparsers)
+    - [getDefaultJsonParser](#getdefaultjsonparser)
+    - [defaultTextParser](#defaulttextparser)
+    - [errorHandler](#errorhandler)
+    - [childLoggerFactory](#childloggerfactory)
+    - [Symbol.asyncDispose](#symbolasyncdispose)
+    - [initialConfig](#initialconfig)
+
+### `http`
+<a id="factory-http"></a>
+
++ Default: `null`
+
+An object used to configure the server's listening socket. The options
+are the same as the Node.js core [`createServer`
+method](https://nodejs.org/docs/latest-v20.x/api/http.html#httpcreateserveroptions-requestlistener).
+
+This option is ignored if options [`http2`](#factory-http2) or
+[`https`](#factory-https) are set.
+
+### `http2`
+<a id="factory-http2"></a>
+
++ Default: `false`
+
+If `true` Node.js core's
+[HTTP/2](https://nodejs.org/dist/latest-v20.x/docs/api/http2.html) module is
+used for binding the socket.
+
+### `https`
+<a id="factory-https"></a>
+
++ Default: `null`
+
+An object used to configure the server's listening socket for TLS. The options
+are the same as the Node.js core [`createServer`
+method](https://nodejs.org/dist/latest-v20.x/docs/api/https.html#https_https_createserver_options_requestlistener).
+When this property is `null`, the socket will not be configured for TLS.
+
+This option also applies when the [`http2`](#factory-http2) option is set.
+
+### `connectionTimeout`
+<a id="factory-connection-timeout"></a>
+
++ Default: `0` (no timeout)
+
+Defines the server timeout in milliseconds. See documentation for
+[`server.timeout`
+property](https://nodejs.org/api/http.html#servertimeout) to understand
+the effect of this option.
+
+When `serverFactory` option is specified this option is ignored.
+
+### `keepAliveTimeout`
+<a id="factory-keep-alive-timeout"></a>
+
++ Default: `72000` (72 seconds)
+
+Defines the server keep-alive timeout in milliseconds. See documentation for
+[`server.keepAliveTimeout`
+property](https://nodejs.org/api/http.html#serverkeepalivetimeout) to
+understand the effect of this option. This option only applies when HTTP/1 is in
+use.
+
+When `serverFactory` option is specified this option is ignored.
+
+### `forceCloseConnections`
+<a id="forcecloseconnections"></a>
+
++ Default: `"idle"` if the HTTP server allows it, `false` otherwise
+
+When set to `true`, upon [`close`](#close) the server will iterate the current
+persistent connections and [destroy their
+sockets](https://nodejs.org/dist/latest-v16.x/docs/api/net.html#socketdestroyerror).
+
+When used with HTTP/2 server, it will also close all active HTTP/2 sessions.
+
+> ℹ️ Note:
+> Since Node.js v24 active sessions are closed by default
+
+
+> ⚠ Warning:
+> Connections are not inspected to determine if requests have
+> been completed.
+
+Fastify will prefer the HTTP server's
+[`closeAllConnections`](https://nodejs.org/dist/latest-v18.x/docs/api/http.html#servercloseallconnections)
+method if supported, otherwise, it will use internal connection tracking.
+
+When set to `"idle"`, upon [`close`](#close) the server will iterate the current
+persistent connections which are not sending a request or waiting for a response
+and destroy their sockets. The value is only supported if the HTTP server
+supports the
+[`closeIdleConnections`](https://nodejs.org/dist/latest-v18.x/docs/api/http.html#servercloseidleconnections)
+method, otherwise attempting to set it will throw an exception.
+
+### `maxRequestsPerSocket`
+<a id="factory-max-requests-per-socket"></a>
+
++ Default: `0` (no limit)
+
+Defines the maximum number of requests a socket can handle before closing keep
+alive connection. See [`server.maxRequestsPerSocket`
+property](https://nodejs.org/dist/latest/docs/api/http.html#servermaxrequestspersocket)
+to understand the effect of this option. This option only applies when HTTP/1.1
+is in use. Also, when `serverFactory` option is specified, this option is
+ignored.
+
+> ℹ️ Note:
+>  At the time of writing, only node >= v16.10.0 supports this option.
+
+### `requestTimeout`
+<a id="factory-request-timeout"></a>
+
++ Default: `0` (no limit)
+
+Defines the maximum number of milliseconds for receiving the entire request from
+the client. See [`server.requestTimeout`
+property](https://nodejs.org/dist/latest/docs/api/http.html#servertimeout)
+to understand the effect of this option.
+
+When `serverFactory` option is specified, this option is ignored.
+It must be set to a non-zero value (e.g. 120 seconds) to protect against potential
+Denial-of-Service attacks in case the server is deployed without a reverse proxy
+in front.
+
+> ℹ️ Note:
+>  At the time of writing, only node >= v14.11.0 supports this option
+
+### `handlerTimeout`
+<a id="factory-handler-timeout"></a>
+
++ Default: `0` (no timeout)
+
+Defines the maximum number of milliseconds allowed for processing a request
+through the entire route lifecycle (from routing through onRequest, parsing,
+validation, handler execution, and serialization). If the response is not sent
+within this time, a `503 Service Unavailable` error is returned and
+`request.signal` is aborted.
+
+Unlike `connectionTimeout` and `requestTimeout` (which operate at the socket
+level), `handlerTimeout` is an application-level timeout that works correctly
+with HTTP keep-alive connections. It can be overridden per-route via
+[route options](./Routes.md#routes-options). When set at both levels, the
+route-level value takes precedence. Routes without an explicit `handlerTimeout`
+inherit the server default. Once a server-level timeout is set, individual
+routes cannot opt out of it — they can only override it with a different
+positive integer.
+
+The timeout is **cooperative**: when it fires, Fastify sends the 503 error
+response, but the handler's async work continues to run. Use
+[`request.signal`](./Request.md) to detect cancellation and stop ongoing work
+(database queries, HTTP requests, etc.). APIs that accept a `signal` option
+(`fetch()`, database drivers, `stream.pipeline()`) will cancel automatically.
+
+The timeout error (`FST_ERR_HANDLER_TIMEOUT`) is sent through the route's
+[error handler](./Routes.md#routes-options), which can be customized per-route
+to change the status code or response body.
+
+When `reply.hijack()` is called, the timeout timer is cleared — the handler
+takes full responsibility for the response lifecycle.
+
+> ℹ️ Note:
+> `handlerTimeout` does not apply to 404 handlers or custom not-found handlers
+> set via `setNotFoundHandler()`, as they bypass the route handler lifecycle.
+
+```js
+const fastify = require('fastify')({
+  handlerTimeout: 10000 // 10s default for all routes
+})
+
+// Override per-route
+fastify.get('/slow-report', { handlerTimeout: 120000 }, async (request) => {
+  // Use request.signal for cooperative cancellation
+  const data = await db.query(longQuery, { signal: request.signal })
+  return data
+})
+
+// Customize the timeout response
+fastify.get('/custom-timeout', {
+  handlerTimeout: 5000,
+  errorHandler: (error, request, reply) => {
+    if (error.code === 'FST_ERR_HANDLER_TIMEOUT') {
+      reply.code(504).send({ error: 'Gateway Timeout' })
+    } else {
+      reply.send(error)
+    }
+  }
+}, async (request) => {
+  const result = await externalService.call({ signal: request.signal })
+  return result
+})
+```
+
+### `bodyLimit`
+<a id="factory-body-limit"></a>
+
++ Default: `1048576` (1MiB)
+
+Defines the maximum payload, in bytes, the server is allowed to accept.
+The default body reader sends [`FST_ERR_CTP_BODY_TOO_LARGE`](./Errors.md#fst_err_ctp_body_too_large)
+reply, if the size of the body exceeds this limit.
+If [`preParsing` hook](./Hooks.md#preparsing) is provided, this limit is applied
+to the size of the stream the hook returns (i.e. the size of "decoded" body).
+
+### `onProtoPoisoning`
+<a id="factory-on-proto-poisoning"></a>
+
++ Default: `'error'`
+
+Defines what action the framework must take when parsing a JSON object with
+`__proto__`. This functionality is provided by
+[secure-json-parse](https://github.com/fastify/secure-json-parse). See
+[Prototype Poisoning](../Guides/Prototype-Poisoning.md) for more details about
+prototype poisoning attacks.
+
+Possible values are `'error'`, `'remove'`, or `'ignore'`.
+
+### `onConstructorPoisoning`
+<a id="factory-on-constructor-poisoning"></a>
+
++ Default: `'error'`
+
+Defines what action the framework must take when parsing a JSON object with
+`constructor`. This functionality is provided by
+[secure-json-parse](https://github.com/fastify/secure-json-parse). See
+[Prototype Poisoning](../Guides/Prototype-Poisoning.md) for more details about
+prototype poisoning attacks.
+
+Possible values are `'error'`, `'remove'`, or `'ignore'`.
+
+### `logger`
+<a id="factory-logger"></a>
+
+Fastify includes built-in logging via the [Pino](https://getpino.io/) logger.
+This property is used to configure the internal logger instance.
+
+The possible values this property may have are:
+
++ Default: `false`. The logger is disabled. All logging methods will point to a
+null logger [abstract-logging](https://www.npmjs.com/package/abstract-logging) instance.
+
++ `object`: a standard Pino [options
+  object](https://github.com/pinojs/pino/blob/c77d8ec5ce/docs/API.md#constructor).
+  This will be passed directly to the Pino constructor. If the following
+  properties are not present on the object, they will be added accordingly:
+    * `level`: the minimum logging level. If not set, it will be set to
+      `'info'`.
+    * `serializers`: a hash of serialization functions. By default, serializers
+      are added for `req` (incoming request objects), `res` (outgoing response
+      objects), and `err` (standard `Error` objects). When a log method receives
+      an object with any of these properties then the respective serializer will
+      be used for that property. For example:
+        ```js
+        fastify.get('/foo', function (req, res) {
+          req.log.info({req}) // log the serialized request object
+          res.send('foo')
+        })
+        ```
+      Any user-supplied serializer will override the default serializer of the
+      corresponding property.
+
+### `loggerInstance`
+<a id="factory-logger-instance"></a>
+
++ Default: `null`
+
+A custom logger instance. The logger must be a Pino instance or conform to the
+Pino interface by having the following methods: `info`, `error`, `debug`,
+`fatal`, `warn`, `trace`, `child`. For example:
+  ```js
+  const pino = require('pino')();
+
+  const customLogger = {
+    info: function (o, ...n) {},
+    warn: function (o, ...n) {},
+    error: function (o, ...n) {},
+    fatal: function (o, ...n) {},
+    trace: function (o, ...n) {},
+    debug: function (o, ...n) {},
+    child: function() {
+      const child = Object.create(this);
+      child.pino = pino.child(...arguments);
+      return child;
+    },
+  };
+
+  const fastify = require('fastify')({ loggerInstance: customLogger });
+  ```
+
+### `disableRequestLogging`
+<a id="factory-disable-request-logging"></a>
+
+> **Deprecated:** Use the [`logController`](#factory-log-controller)
+> option with `disableRequestLogging` or `isLogDisabled` override instead.
+> This top-level option will be removed in `fastify@6`.
+
++ Default: `false`
+
+When logging is enabled, Fastify will issue an `info` level log
+message when a request is received and when the response for that request has
+been sent. By setting this option to `true`, these log messages will be
+disabled. This allows for more flexible request start and end logging by
+attaching custom `onRequest` and `onResponse` hooks.
+
+This option can also be a function that receives the Fastify request object
+and returns a boolean. This allows for conditional request logging based on the
+request properties (e.g., URL, headers, decorations).
+
+```js
+const { LogController } = require('fastify')
+
+// Deprecated
+const fastify = require('fastify')({
+  logger: true,
+  disableRequestLogging: (request) => {
+    return request.url === '/health' || request.url === '/ready'
+  }
+})
+
+// Recommended: use logController instead
+const fastify = require('fastify')({
+  logger: true,
+  logController: new LogController({
+    disableRequestLogging: (request) => {
+      return request.url === '/health' || request.url === '/ready'
+    }
+  })
+})
+```
+
+The other log entries that will be disabled are:
+- an error log written by the default `onResponse` hook on reply callback errors
+- the error and info logs written by the `defaultErrorHandler`
+on error management
+- the info log written by the `fourOhFour` handler when a
+non existent route is requested
+
+Other log messages emitted by Fastify will stay enabled,
+like deprecation warnings and messages
+emitted when requests are received while the server is closing.
+
+```js
+// Examples of hooks to replicate the disabled functionality.
+fastify.addHook('onRequest', (req, reply, done) => {
+  req.log.info({ url: req.raw.url, id: req.id }, 'received request')
+  done()
+})
+
+fastify.addHook('onResponse', (req, reply, done) => {
+  req.log.info({ url: req.raw.originalUrl, statusCode: reply.raw.statusCode }, 'request completed')
+  done()
+})
+```
+
+### `logController`
+<a id="factory-log-controller"></a>
+
++ Default: `undefined`
+
+Accepts an instance of `LogController` (or a subclass) to customize Fastify's
+internal log lines. Extend the `LogController` class and override only the
+methods you want to customize; all others keep their default behavior.
+
+The `LogController` class is exported from `fastify`:
+
+```js
+const { LogController } = require('fastify')
+```
+
+The constructor accepts an optional options object:
+
+| Property | Type | Default | Description |
+|----------|------|---------|-------------|
+| `disableRequestLogging` | `boolean \| (req) => boolean` | `false` | When `true` (or a function returning `true`), per-request log lines are suppressed. |
+| `requestIdLogLabel` | `string` | `'reqId'` | The label used for the request identifier when logging. |
+
+```js
+const { LogController } = require('fastify')
+
+class MyLogController extends LogController {
+  constructor () {
+    super({
+      requestIdLogLabel: 'traceId',
+      disableRequestLogging: (request) => {
+        return request.url === '/health'
+      }
+    })
+  }
+
+  incomingRequest (request, reply, metadata) {
+    // Use debug level instead of info for incoming requests
+    request.log.debug({ req: request }, 'incoming request')
+  }
+
+  requestCompleted (error, request, reply, metadata) {
+    // Add custom fields to the request completed log
+    if (error) {
+      reply.log.error({ res: reply, err: error, responseTime: reply.elapsedTime, customField: 'value' }, 'request errored')
+    } else {
+      reply.log.info({ res: reply, responseTime: reply.elapsedTime, customField: 'value' }, 'request completed')
+    }
+  }
+}
+
+const fastify = require('fastify')({
+  logger: true,
+  logController: new MyLogController()
+})
+```
+
+The error-related methods share a unified signature:
+`(error, request, reply, metadata)`, where `metadata` carries any extra
+per-method data (for example, the `statusCode` passed to `serializerError`).
+`incomingRequest` and `routeNotFound` omit the `error` argument, since they fire
+at lifecycle points where no error exists. `serviceUnavailable` is a further
+exception, since no route — and therefore no `request`/`reply` — is formed.
+
+| Method | Signature | Description |
+|--------|-----------|-------------|
+| `isLogDisabled` | `(request)` | Checks whether request logging is disabled for the given request. It impacts all other log methods. |
+| `incomingRequest` | `(request, reply, metadata)` | Logs an incoming request at `info` level. |
+| `requestCompleted` | `(error, request, reply, metadata)` | Logs the outcome of a completed request. Uses `error` level when an error is present, `info` otherwise. |
+| `defaultErrorLog` | `(error, request, reply, metadata)` | Logs an error handled by the default error handler. Uses `error` for 5xx, `info` for 4xx. |
+| `streamError` | `(error, request, reply, metadata)` | Logs stream-level errors after headers have been sent. |
+| `routeNotFound` | `(request, reply, metadata)` | Logs a "route not found" message at `info` level. |
+| `writeHeadError` | `(error, request, reply, metadata)` | Logs a warning when `writeHead` fails during error handling. |
+| `serializerError` | `(error, request, reply, metadata)` | Logs an error when the serializer for a given status code fails. The triggering status code is available as `metadata.statusCode`. |
+| `serviceUnavailable` | `(logger, server)` | Logs a 503 when the server is closing. Always emitted, not gated by `disableRequestLogging`. |
+
+**Note:** When you override a method, you take full control of it — the
+default `disableRequestLogging` check is **not** automatically applied.
+If you need conditional logging, call `this.isLogDisabled(request)` yourself
+or override `isLogDisabled` as well.
+
+### `serverFactory`
+<a id="custom-http-server"></a>
+
+You can pass a custom HTTP server to Fastify by using the `serverFactory`
+option.
+
+`serverFactory` is a function that takes a `handler` parameter, which takes the
+`request` and `response` objects as parameters, and an options object, which is
+the same you have passed to Fastify.
+
+```js
+const serverFactory = (handler, opts) => {
+  const server = http.createServer((req, res) => {
+    handler(req, res)
+  })
+
+  return server
+}
+
+const fastify = Fastify({ serverFactory })
+
+fastify.get('/', (req, reply) => {
+  reply.send({ hello: 'world' })
+})
+
+fastify.listen({ port: 3000 })
+```
+
+Internally Fastify uses the API of Node core HTTP server, so if you are using a
+custom server you must be sure to have the same API exposed. If not, you can
+enhance the server instance inside the `serverFactory` function before the
+`return` statement.
+
+
+### `requestIdHeader`
+<a id="factory-request-id-header"></a>
+
++ Default: `false`
+
+The header name used to set the request-id. See [the
+request-id](./Logging.md#logging-request-id) section.
+Setting `requestIdHeader` to `true` will set the `requestIdHeader` to
+`"request-id"`.
+Setting `requestIdHeader` to a non-empty string will use
+the specified string as the `requestIdHeader`.
+By default `requestIdHeader` is set to `false` and will immediately use [genReqId](#genreqid).
+Setting `requestIdHeader` to an empty String (`""`) will set the
+requestIdHeader to `false`.
+
+```js
+const fastify = require('fastify')({
+  requestIdHeader: 'x-custom-id', // -> use 'X-Custom-Id' header if available
+  //requestIdHeader: false, // -> always use genReqId
+})
+```
+
+> ⚠ Warning:
+> Enabling this allows any callers to set `reqId` to a
+> value of their choosing.
+> No validation is performed on `requestIdHeader`.
+
+### `requestIdLogLabel`
+<a id="factory-request-id-log-label"></a>
+
+> **Deprecated:** Use the [`logController`](#factory-log-controller)
+> option with `requestIdLogLabel` instead. This top-level option will be
+> removed in `fastify@6`.
+
++ Default: `'reqId'`
+
+Defines the label used for the request identifier when logging the request.
+
+### `genReqId`
+<a id="factory-gen-request-id"></a>
+
++ Default: `value of 'request-id' header if provided or monotonically increasing
+  integers`
+
+Function for generating the request-id. It will receive the _raw_ incoming
+request as a parameter. This function is expected to be error-free.
+
+Especially in distributed systems, you may want to override the default ID
+generation behavior as shown below. For generating `UUID`s you may want to check
+out [hyperid](https://github.com/mcollina/hyperid).
+
+> ℹ️ Note:
+> `genReqId` will not be called if the header set in
+> <code>[requestIdHeader](#requestidheader)</code> is available (defaults to
+> `false`).
+
+```js
+let i = 0
+const fastify = require('fastify')({
+  genReqId: function (req) { return i++ }
+})
+```
+
+### `trustProxy`
+<a id="factory-trust-proxy"></a>
+
++ Default: `false`
++ `true/false`: Trust all proxies (`true`) or do not trust any proxies
+  (`false`).
++ `string`: Trust only given IP/CIDR (e.g. `'127.0.0.1'`). May be a list of
+  comma separated values (e.g. `'127.0.0.1,192.168.1.1/24'`).
++ `Array<string>`: Trust only given IP/CIDR list (e.g. `['127.0.0.1']`).
++ `number`: Hop-count-only trust is disabled because it cannot validate the
+  immediate peer and lets direct clients spoof `X-Forwarded-*` values. Use an
+  IP/CIDR string, array, or custom function that validates the proxy address
+  instead.
++ `Function`: Custom trust function that takes `address` as first argument
+    ```js
+    function myTrustFn(address, hop) {
+      return address === '1.2.3.4' && hop === 0
+    }
+    ```
+
+By enabling the `trustProxy` option, Fastify will know that it is sitting behind
+a proxy and that the `X-Forwarded-*` header fields may be trusted, which
+otherwise may be easily spoofed.
+
+```js
+const fastify = Fastify({ trustProxy: true })
+```
+
+For more examples, refer to the
+[`@fastify/proxy-addr`](https://www.npmjs.com/package/@fastify/proxy-addr) package.
+
+You may access the `ip`, `ips`, `host` and `protocol` values on the
+[`request`](./Request.md) object.
+
+> ⚠️ Security:
+> These values are derived from socket/forwarding metadata and must be treated
+> as untrusted input unless your proxy chain is explicitly trusted and
+> validated. Do not use them directly for authorization or other
+> security-sensitive decisions without explicit validation. Custom trust
+> functions must validate the `address` argument; hop-count-only checks such as
+> `hop < 1` are unsafe when the Fastify origin can be reached directly.
+
+```js
+fastify.get('/', (request, reply) => {
+  console.log(request.ip)
+  console.log(request.ips)
+  console.log(request.host)
+  console.log(request.protocol)
+})
+```
+
+> ℹ️ Note:
+> If a request contains multiple `x-forwarded-host` or `x-forwarded-proto`
+> headers, it is only the last one that is used to derive `request.hostname`
+> and `request.protocol`.
+
+### `pluginTimeout`
+<a id="plugin-timeout"></a>
+
++ Default: `10000`
+
+The maximum amount of time in *milliseconds* in which a plugin can load. If not,
+[`ready`](#ready) will complete with an `Error` with code
+`'ERR_AVVIO_PLUGIN_TIMEOUT'`. When set to `0`, disables this check. This
+controls [avvio](https://www.npmjs.com/package/avvio) 's `timeout` parameter.
+
+### `querystringParser`
+<a id="factory-querystring-parser"></a>
+
+The default query string parser that Fastify uses is a more performant fork
+of Node.js's core `querystring` module called
+[`fast-querystring`](https://github.com/anonrig/fast-querystring).
+
+You can use this option to use a custom parser, such as
+[`qs`](https://www.npmjs.com/package/qs).
+
+If you only want the keys (and not the values) to be case insensitive we
+recommend using a custom parser to convert only the keys to lowercase.
+
+```js
+const qs = require('qs')
+const fastify = require('fastify')({
+  routerOptions: {
+    querystringParser: str => qs.parse(str)
+  }
+})
+```
+
+You can also use Fastify's default parser but change some handling behavior,
+like the example below for case insensitive keys and values:
+
+```js
+const querystring = require('fast-querystring')
+const fastify = require('fastify')({
+  routerOptions: {
+    querystringParser: str => querystring.parse(str.toLowerCase())
+  }
+})
+```
+
+### `exposeHeadRoutes`
+<a id="exposeHeadRoutes"></a>
+
++ Default: `true`
+
+Automatically creates a sibling `HEAD` route for each `GET` route defined. If
+you want a custom `HEAD` handler without disabling this option, make sure to
+define it before the `GET` route.
+
+### `return503OnClosing`
+<a id="factory-return-503-on-closing"></a>
+
++ Default: `true`
+
+When `true`, any request arriving after [`close`](#close) has been called will
+receive a `503 Service Unavailable` response with `Connection: close` header
+(HTTP/1.1). This lets load balancers detect that the server is shutting down and
+stop routing traffic to it.
+
+When `false`, requests arriving during the closing phase are routed and
+processed normally. They will still receive a `Connection: close` header so that
+clients do not attempt to reuse the connection.
+
+### `ajv`
+<a id="factory-ajv"></a>
+
+Configure the Ajv v8 instance used by Fastify without providing a custom one.
+The default configuration is explained in the
+[#schema-validator](./Validation-and-Serialization.md#schema-validator) section.
+
+```js
+const fastify = require('fastify')({
+  ajv: {
+    customOptions: {
+      removeAdditional: 'all' // Refer to [ajv options](https://ajv.js.org/options.html#removeadditional)
+    },
+    plugins: [
+      require('ajv-merge-patch'),
+      [require('ajv-keywords'), 'instanceof']
+      // Usage: [plugin, pluginOptions] - Plugin with options
+      // Usage: plugin - Plugin without options
+    ],
+    onCreate: (ajv) => {
+      // Modify the ajv instance as you need.
+      ajv.addFormat('myFormat', (data) => typeof data === 'string')
+    }
+  }
+})
+```
+
+### `serializerOpts`
+<a id="serializer-opts"></a>
+
+Customize the options of the default
+[`fast-json-stringify`](https://github.com/fastify/fast-json-stringify#options)
+instance that serializes the response's payload:
+
+```js
+const fastify = require('fastify')({
+  serializerOpts: {
+    rounding: 'ceil'
+  }
+})
+```
+
+### `http2SessionTimeout`
+<a id="http2-session-timeout"></a>
+
++ Default: `72000`
+
+Set a default
+[timeout](https://nodejs.org/api/http2.html#http2sessionsettimeoutmsecs-callback)
+to every incoming HTTP/2 session in milliseconds. The session will be closed on
+the timeout.
+
+This option is needed to offer a graceful "close" experience when using
+HTTP/2. The low default has been chosen to mitigate denial of service attacks.
+When the server is behind a load balancer or can scale automatically this value
+can be increased to fit the use case. Node core defaults this to `0`.
+
+### `frameworkErrors`
+<a id="framework-errors"></a>
+
++ Default: `null`
+
+Fastify provides default error handlers for the most common use cases. It is
+possible to override one or more of those handlers with custom code using this
+option.
+
+> ℹ️ Note:
+> Only `FST_ERR_BAD_URL` and `FST_ERR_ASYNC_CONSTRAINT` are implemented at present.
+
+```js
+const fastify = require('fastify')({
+  frameworkErrors: function (error, req, res) {
+    if (error instanceof FST_ERR_BAD_URL) {
+      res.code(400)
+      return res.send("Provided url is not valid")
+    } else if(error instanceof FST_ERR_ASYNC_CONSTRAINT) {
+      res.code(400)
+      return res.send("Provided header is not valid")
+    } else {
+      res.send(error)
+    }
+  }
+})
+```
+
+### `clientErrorHandler`
+<a id="client-error-handler"></a>
+
+Set a
+[clientErrorHandler](https://nodejs.org/api/http.html#event-clienterror)
+that listens to `error` events emitted by client connections and responds with a
+`400`.
+
+It is possible to override the default `clientErrorHandler` using this option.
+
++ Default:
+```js
+function defaultClientErrorHandler (err, socket) {
+  if (err.code === 'ECONNRESET') {
+    return
+  }
+
+  const body = JSON.stringify({
+    error: http.STATUS_CODES['400'],
+    message: 'Client Error',
+    statusCode: 400
+  })
+  this.log.trace({ err }, 'client error')
+
+  if (socket.writable) {
+    socket.end([
+      'HTTP/1.1 400 Bad Request',
+      `Content-Length: ${body.length}`,
+      `Content-Type: application/json\r\n\r\n${body}`
+    ].join('\r\n'))
+  }
+}
+```
+
+> ℹ️ Note:
+> `clientErrorHandler` operates with raw sockets. The handler is expected to
+> return a properly formed HTTP response that includes a status line, HTTP headers
+> and a message body. Before attempting to write the socket, the handler should
+> check if the socket is still writable as it may have already been destroyed.
+
+```js
+const fastify = require('fastify')({
+  clientErrorHandler: function (err, socket) {
+    const body = JSON.stringify({
+      error: {
+        message: 'Client error',
+        code: '400'
+      }
+    })
+
+    // `this` is bound to fastify instance
+    this.log.trace({ err }, 'client error')
+
+    // the handler is responsible for generating a valid HTTP response
+    socket.end([
+      'HTTP/1.1 400 Bad Request',
+      `Content-Length: ${body.length}`,
+      `Content-Type: application/json\r\n\r\n${body}`
+    ].join('\r\n'))
+  }
+})
+```
+
+### `rewriteUrl`
+<a id="rewrite-url"></a>
+
+Set a sync callback function that must return a string that allows rewriting
+URLs. This is useful when you are behind a proxy that changes the URL.
+Rewriting a URL will modify the `url` property of the `req` object.
+
+Note that `rewriteUrl` is called _before_ routing, it is not encapsulated and it
+is an instance-wide configuration.
+
+```js
+// @param {object} req The raw Node.js HTTP request, not the `FastifyRequest` object.
+// @this Fastify The root Fastify instance (not an encapsulated instance).
+// @returns {string} The path that the request should be mapped to.
+function rewriteUrl (req) {
+  if (req.url === '/hi') {
+    this.log.debug({ originalUrl: req.url, url: '/hello' }, 'rewrite url');
+    return '/hello'
+  } else {
+    return req.url;
+  }
+}
+```
+
+## RouterOptions
+<a id="routeroptions"></a>
+
+Fastify uses [`find-my-way`](https://github.com/delvedor/find-my-way) for its
+HTTP router. The `routerOptions` parameter allows passing
+[`find-my-way` options](https://github.com/delvedor/find-my-way?tab=readme-ov-file#findmywayoptions)
+to customize the HTTP router within Fastify.
+
+### `allowUnsafeRegex`
+<a id="allow-unsafe-regex"></a>
+
++ Default `false`
+
+Fastify uses [find-my-way](https://github.com/delvedor/find-my-way) which is,
+disabled by default, so routes only allow safe regular expressions. To use
+unsafe expressions, set `allowUnsafeRegex` to `true`.
+
+```js
+fastify.get('/user/:id(^([0-9]+){4}$)', (request, reply) => {
+  // Throws an error without allowUnsafeRegex = true
+})
+```
+
+
+### `buildPrettyMeta`
+<a id="build-pretty-meta"></a>
+
+Fastify uses [find-my-way](https://github.com/delvedor/find-my-way) which
+supports, `buildPrettyMeta` where you can assign a `buildPrettyMeta`
+function to sanitize a route's store object to use with the `prettyPrint`
+functions. This function should accept a single object and return an object.
+
+```js
+const fastify = require('fastify')({
+  routerOptions: {
+    buildPrettyMeta: route => {
+      const cleanMeta = Object.assign({}, route.store)
+
+      // remove private properties
+      Object.keys(cleanMeta).forEach(k => {
+        if (typeof k === 'symbol') delete cleanMeta[k]
+      })
+
+      return cleanMeta // this will show up in the pretty print output!
+    }
+  }
+})
+```
+
+### `caseSensitive`
+<a id="case-sensitive"></a>
+
++ Default: `true`
+
+When `true` routes are registered as case-sensitive. That is, `/foo`
+is not equal to `/Foo`.
+When `false` then routes are case-insensitive.
+
+Please note that setting this option to `false` goes against
+[RFC3986](https://datatracker.ietf.org/doc/html/rfc3986#section-6.2.2.1).
+
+By setting `caseSensitive` to `false`, all paths will be matched as lowercase,
+but the route parameters or wildcards will maintain their original letter
+casing.
+This option does not affect query strings, please refer to
+[`querystringParser`](#querystringparser) to change their handling.
+
+```js
+fastify.get('/user/:username', (request, reply) => {
+  // Given the URL: /USER/NodeJS
+  console.log(request.params.username) // -> 'NodeJS'
+})
+```
+
+### `constraints`
+<a id="constraints"></a>
+
+Fastify's built-in route constraints are provided by `find-my-way`, which
+allows constraining routes by `version` or `host`. You can add new constraint
+strategies, or override the built-in strategies, by providing a `constraints`
+object with strategies for `find-my-way`. You can find more information on
+constraint strategies in the
+[find-my-way](https://github.com/delvedor/find-my-way) documentation.
+
+```js
+const customVersionStrategy = {
+  storage: function () {
+    const versions = {}
+    return {
+      get: (version) => { return versions[version] || null },
+      set: (version, store) => { versions[version] = store }
+    }
+  },
+  deriveVersion: (req, ctx) => {
+    return req.headers['accept']
+  }
+}
+
+const fastify = require('fastify')({
+  routerOptions: {
+    constraints: {
+      version: customVersionStrategy
+    }
+  }
+})
+```
+
+### `defaultRoute`
+<a id="default-route"></a>
+
+Fastify uses [find-my-way](https://github.com/delvedor/find-my-way) which supports,
+can pass a default route with the option defaultRoute.
+
+```js
+const fastify = require('fastify')({
+  routerOptions: {
+    defaultRoute: (req, res) => {
+      res.statusCode = 404
+      res.end()
+    }
+  }
+})
+```
+
+> ℹ️ Note:
+> The `req` and `res` objects passed to `defaultRoute` are the raw Node.js
+> `IncomingMessage` and `ServerResponse` instances. They do **not** expose the
+> Fastify-specific methods available on `FastifyRequest`/`FastifyReply` (for
+> example, `res.send`).
+
+### `ignoreDuplicateSlashes`
+<a id="factory-ignore-duplicate-slashes"></a>
+
++ Default: `false`
+
+Fastify uses [find-my-way](https://github.com/delvedor/find-my-way) to handle
+routing. You can use `ignoreDuplicateSlashes` option to remove duplicate slashes
+from the path. It removes duplicate slashes in the route path and the request
+URL. This option applies to *all* route registrations for the resulting server
+instance.
+
+When `ignoreTrailingSlash` and `ignoreDuplicateSlashes` are both set
+to `true` Fastify will remove duplicate slashes, and then trailing slashes,
+meaning `//a//b//c//` will be converted to `/a/b/c`.
+
+```js
+const fastify = require('fastify')({
+  routerOptions: {
+    ignoreDuplicateSlashes: true
+  }
+})
+
+// registers "/foo/bar/"
+fastify.get('///foo//bar//', function (req, reply) {
+  reply.send('foo')
+})
+```
+
+### `ignoreTrailingSlash`
+<a id="ignore-slash"></a>
+
++ Default: `false`
+
+Fastify uses [find-my-way](https://github.com/delvedor/find-my-way) to handle
+routing. By default, Fastify will take into account the trailing slashes.
+Paths like `/foo` and `/foo/` are treated as different paths. If you want to
+change this, set this flag to `true`. That way, both `/foo` and `/foo/` will
+point to the same route. This option applies to *all* route registrations for
+the resulting server instance.
+
+```js
+const fastify = require('fastify')({
+  routerOptions: {
+    ignoreTrailingSlash: true
+  }
+})
+
+// registers both "/foo" and "/foo/"
+fastify.get('/foo/', function (req, reply) {
+  reply.send('foo')
+})
+
+// registers both "/bar" and "/bar/"
+fastify.get('/bar', function (req, reply) {
+  reply.send('bar')
+})
+```
+
+### `maxParamLength`
+<a id="max-param-length"></a>
+
++ Default: `100`
+
+You can set a custom length for parameters in parametric (standard, regex, and
+multi) routes by using `maxParamLength` option; the default value is 100
+characters. If the maximum length limit is reached, the not found route will
+be invoked.
+
+This can be useful especially if you have a regex-based route, protecting you
+against [ReDoS
+attacks](https://owasp.org/www-community/attacks/Regular_expression_Denial_of_Service_-_ReDoS).
+
+
+### `onBadUrl`
+<a id="on-bad-url"></a>
+
+Fastify uses [find-my-way](https://github.com/delvedor/find-my-way) which supports,
+the use case of a badly formatted url (eg: /hello/%world), by default find-my-way
+will invoke the defaultRoute, unless you specify the onBadUrl option.
+
+```js
+const fastify = require('fastify')({
+  routerOptions: {
+    onBadUrl: (path, req, res) => {
+      res.statusCode = 400
+      res.end(`Bad path: ${path}`)
+    }
+  }
+})
+```
+
+As with `defaultRoute`, `req` and `res` are the raw Node.js request/response
+objects and do not provide Fastify's decorated helpers.
+
+### `onMaxParamLength`
+<a id="on-max-param-length"></a>
+
+Fastify uses [find-my-way](https://github.com/delvedor/find-my-way) which supports,
+the use case of a provide custom handler when `maxParamLength ` is exceed.
+
+```js
+const fastify = require('fastify')({
+  routerOptions: {
+    maxParamLength: 10,
+    onMaxParamLength: (path, req, res) => {
+      res.statusCode = 414
+      res.end(`Bad path: ${path}`)
+    }
+  }
+})
+```
+
+As with `defaultRoute`, `req` and `res` are the raw Node.js request/response
+objects and do not provide Fastify's decorated helpers.
+
+### `querystringParser`
+<a id="querystringparser"></a>
+
+The default query string parser that Fastify uses is a more performant fork
+of Node.js's core `querystring` module called
+[`fast-querystring`](https://github.com/anonrig/fast-querystring).
+
+You can use this option to use a custom parser, such as
+[`qs`](https://www.npmjs.com/package/qs).
+
+If you only want the keys (and not the values) to be case insensitive we
+recommend using a custom parser to convert only the keys to lowercase.
+
+```js
+const qs = require('qs')
+const fastify = require('fastify')({
+  routerOptions: {
+    querystringParser: str => qs.parse(str)
+  }
+})
+```
+
+You can also use Fastify's default parser but change some handling behavior,
+like the example below for case insensitive keys and values:
+
+```js
+const querystring = require('fast-querystring')
+const fastify = require('fastify')({
+  routerOptions: {
+    querystringParser: str => querystring.parse(str.toLowerCase())
+  }
+})
+```
+
+### `useSemicolonDelimiter`
+<a id="use-semicolon-delimiter"></a>
+
++ Default `false`
+
+Fastify uses [find-my-way](https://github.com/delvedor/find-my-way) which supports,
+separating the path and query string with a `;` character (code 59), e.g. `/dev;foo=bar`.
+This decision originated from [delvedor/find-my-way#76]
+(https://github.com/delvedor/find-my-way/issues/76). Thus, this option will support
+backwards compatibility for the need to split on `;`. To enable support for splitting
+on `;` set `useSemicolonDelimiter` to `true`.
+
+```js
+const fastify = require('fastify')({
+  routerOptions: {
+    useSemicolonDelimiter: true
+  }
+})
+
+fastify.get('/dev', async (request, reply) => {
+  // An example request such as `/dev;foo=bar`
+  // Will produce the following query params result `{ foo = 'bar' }`
+  return request.query
+})
+```
+
+### `allowErrorHandlerOverride`
+<a id="allow-error-handler-override"></a>
+
+* **Default:** `true`
+
+> ⚠ Warning:
+> This option will be set to `false` by default
+> in the next major release.
+
+When set to `false`, it prevents `setErrorHandler` from being called
+multiple times within the same scope, ensuring that the previous error
+handler is not unintentionally overridden.
+
+#### Example of incorrect usage:
+
+```js
+app.setErrorHandler(function freeSomeResources () {
+  // Never executed, memory leaks
+})
+
+app.setErrorHandler(function anotherErrorHandler () {
+  // Overrides the previous handler
+})
+```
+
+## Instance
+
+### Server Methods
+
+#### server
+<a id="server"></a>
+
+`fastify.server`: The Node core
+[server](https://nodejs.org/api/http.html#class-httpserver) object as
+returned by the [**`Fastify factory function`**](#factory).
+
+> ⚠ Warning:
+> If utilized improperly, certain Fastify features could be disrupted.
+> It is recommended to only use it for attaching listeners.
+
+#### after
+<a id="after"></a>
+
+Invoked when the current plugin and all the plugins that have been registered
+within it have finished loading. It is always executed before the method
+`fastify.ready`.
+
+```js
+fastify
+  .register((instance, opts, done) => {
+    console.log('Current plugin')
+    done()
+  })
+  .after(err => {
+    console.log('After current plugin')
+  })
+  .register((instance, opts, done) => {
+    console.log('Next plugin')
+    done()
+  })
+  .ready(err => {
+    console.log('Everything has been loaded')
+  })
+```
+
+In case `after()` is called without a function, it returns a `Promise`:
+
+```js
+fastify.register(async (instance, opts) => {
+  console.log('Current plugin')
+})
+
+await fastify.after()
+console.log('After current plugin')
+
+fastify.register(async (instance, opts) => {
+  console.log('Next plugin')
+})
+
+await fastify.ready()
+
+console.log('Everything has been loaded')
+```
+
+#### ready
+<a id="ready"></a>
+
+Function called when all the plugins have been loaded. It takes an error
+parameter if something went wrong.
+```js
+fastify.ready(err => {
+  if (err) throw err
+})
+```
+If it is called without any arguments, it will return a `Promise`:
+
+```js
+fastify.ready().then(() => {
+  console.log('successfully booted!')
+}, (err) => {
+  console.log('an error happened', err)
+})
+```
+
+#### listen
+<a id="listen"></a>
+
+Starts the server and internally waits for the `.ready()` event. The signature
+is `.listen([options][, callback])`. Both the `options` object and the
+`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: 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
+desired, then specifying `0.0.0.0` for the address will listen on all IPv4
+addresses. The address argument provided above will then return the first such
+IPv4 address. The following table details the possible values for `host` when
+targeting `localhost`, and what the result of those values for `host` will be.
+
+ Host          | IPv4 | IPv6
+ --------------|------|-------
+ `::`            | ✅<sup>*</sup> | ✅
+ `::` + [`ipv6Only`](https://nodejs.org/api/net.html#serverlistenoptions-callback) | 🚫 | ✅
+ `0.0.0.0`       | ✅ | 🚫
+ `localhost`     | ✅ | ✅
+ `127.0.0.1`     | ✅ | 🚫
+ `::1`           | 🚫 | ✅
+
+<sup>*</sup> Using `::` for the address will listen on all IPv6 addresses and,
+depending on OS, may also listen on [all IPv4
+addresses](https://nodejs.org/api/net.html#serverlistenport-host-backlog-callback).
+
+Be careful when deciding to listen on all interfaces; it comes with inherent
+[security
+risks](https://web.archive.org/web/20170711105010/https://snyk.io/blog/mongodb-hack-and-secure-defaults/).
+
+The default is to listen on `port: 0` (which picks the first available open
+port) and `host: 'localhost'`:
+
+```js
+fastify.listen((err, address) => {
+  if (err) {
+    fastify.log.error(err)
+    process.exit(1)
+  }
+})
+```
+
+Specifying an address is also supported:
+
+```js
+fastify.listen({ port: 3000, host: '127.0.0.1' }, (err, address) => {
+  if (err) {
+    fastify.log.error(err)
+    process.exit(1)
+  }
+})
+```
+
+If no callback is provided a Promise is returned:
+
+```js
+fastify.listen({ port: 3000 })
+  .then((address) => console.log(`server listening on ${address}`))
+  .catch(err => {
+    console.log('Error starting server:', err)
+    process.exit(1)
+  })
+```
+
+When deploying to a Docker, and potentially other, containers, it is advisable
+to listen on `0.0.0.0` because they do not default to exposing mapped ports to
+`localhost`:
+
+```js
+fastify.listen({ port: 3000, host: '0.0.0.0' }, (err, address) => {
+  if (err) {
+    fastify.log.error(err)
+    process.exit(1)
+  }
+})
+```
+
+If the `port` is omitted (or is set to zero), a random available port is
+automatically chosen (available via `fastify.server.address().port`).
+
+The default options of listen are:
+
+```js
+fastify.listen({
+  port: 0,
+  host: 'localhost',
+  exclusive: false,
+  readableAll: false,
+  writableAll: false,
+  ipv6Only: false
+}, (err) => {})
+```
+
+#### addresses
+<a id="addresses"></a>
+
+This method returns an array of addresses that the server is listening on. If
+you call it before `listen()` is called or after the `close()` function, it will
+return an empty array.
+
+```js
+await fastify.listen({ port: 8080 })
+const addresses = fastify.addresses()
+// [
+//   { port: 8080, family: 'IPv6', address: '::1' },
+//   { port: 8080, family: 'IPv4', address: '127.0.0.1' }
+// ]
+```
+
+Note that the array contains the `fastify.server.address()` too.
+
+#### routing
+<a id="routing"></a>
+
+Method to access the `lookup` method of the internal router and match the
+request to the appropriate handler:
+
+```js
+fastify.routing(req, res)
+```
+
+#### route
+<a id="route"></a>
+
+Method to add routes to the server, it also has shorthand functions, check
+[here](./Routes.md).
+
+#### hasRoute
+<a id="hasRoute"></a>
+
+Method to check if a route is already registered to the internal router. It
+expects an object as the payload. `url` and `method` are mandatory fields. It
+is possible to also specify `constraints`. The method returns `true` if the
+route is registered or `false` if not.
+
+```js
+const routeExists = fastify.hasRoute({
+  url: '/',
+  method: 'GET',
+  constraints: { version: '1.0.0' } // optional
+})
+
+if (routeExists === false) {
+  // add route
+}
+```
+
+#### findRoute
+<a id="findRoute"></a>
+
+Method to retrieve a route already registered to the internal router. It
+expects an object as the payload. `url` and `method` are mandatory fields. It
+is possible to also specify `constraints`.
+The method returns a route object or `null` if the route cannot be found.
+
+```js
+const route = fastify.findRoute({
+  url: '/artists/:artistId',
+  method: 'GET',
+  constraints: { version: '1.0.0' } // optional
+})
+
+if (route !== null) {
+  // perform some route checks
+  console.log(route.params)   // `{artistId: ':artistId'}`
+}
+```
+
+
+#### close
+<a id="close"></a>
+
+`fastify.close(callback)`: call this function to close the server instance and
+run the [`'onClose'`](./Hooks.md#on-close) hook.
+
+Calling `close` will also cause the server to respond to every new incoming
+request with a `503` error and destroy that request. See [`return503OnClosing`
+flags](#factory-return-503-on-closing) for changing this behavior.
+
+If it is called without any arguments, it will return a Promise:
+
+```js
+fastify.close().then(() => {
+  console.log('successfully closed!')
+}, (err) => {
+  console.log('an error happened', err)
+})
+```
+
+##### Shutdown lifecycle
+
+When `fastify.close()` is called, the following steps happen in order:
+
+1. The server is flagged as **closing**. New incoming requests receive a
+   `Connection: close` header (HTTP/1.1) and are handled according to
+   [`return503OnClosing`](#factory-return-503-on-closing).
+2. [`preClose`](./Hooks.md#pre-close) hooks execute. The server is still
+   processing in-flight requests at this point.
+3. **Connection draining** based on the
+   [`forceCloseConnections`](#forcecloseconnections) option:
+   - `"idle"` — idle keep-alive connections are closed; in-flight requests
+     continue.
+   - `true` — all persistent connections are destroyed immediately.
+   - `false` — no forced closure; idle connections remain open until they time
+     out naturally (see [`keepAliveTimeout`](#keepalivetimeout)).
+4. The HTTP server **stops accepting** new TCP connections
+   (`server.close()`). Node.js waits for all in-flight requests to complete
+   before invoking the callback.
+5. [`onClose`](./Hooks.md#on-close) hooks execute. All in-flight requests have
+   completed and the server is no longer listening.
+6. The `close` callback (or the returned Promise) resolves.
+
+```
+fastify.close() called
+  │
+  ├─▶ closing = true (new requests receive 503)
+  │
+  ├─▶ preClose hooks
+  │     (in-flight requests still active)
+  │
+  ├─▶ Connection draining (forceCloseConnections)
+  │
+  ├─▶ server.close()
+  │     (waits for in-flight requests to complete)
+  │
+  ├─▶ onClose hooks
+  │     (server stopped, all requests done)
+  │
+  └─▶ close callback / Promise resolves
+```
+
+> ℹ️ Note:
+> Upgraded connections (such as WebSocket) are not tracked by the HTTP
+> server and will prevent `server.close()` from completing. Close them
+> explicitly in a [`preClose`](./Hooks.md#pre-close) hook.
+
+#### decorate*
+<a id="decorate"></a>
+
+Function useful if you need to decorate the fastify instance, Reply or Request,
+check [here](./Decorators.md).
+
+#### register
+<a id="register"></a>
+
+Fastify allows the user to extend its functionality with plugins. A plugin can
+be a set of routes, a server decorator, or whatever, check [here](./Plugins.md).
+
+#### addHook
+<a id="addHook"></a>
+
+Function to add a specific hook in the lifecycle of Fastify, check
+[here](./Hooks.md).
+
+#### prefix
+<a id="prefix"></a>
+
+The full path that will be prefixed to a route.
+
+Example:
+
+```js
+fastify.register(function (instance, opts, done) {
+  instance.get('/foo', function (request, reply) {
+    // Will log "prefix: /v1"
+    request.log.info('prefix: %s', instance.prefix)
+    reply.send({ prefix: instance.prefix })
+  })
+
+  instance.register(function (instance, opts, done) {
+    instance.get('/bar', function (request, reply) {
+      // Will log "prefix: /v1/v2"
+      request.log.info('prefix: %s', instance.prefix)
+      reply.send({ prefix: instance.prefix })
+    })
+
+    done()
+  }, { prefix: '/v2' })
+
+  done()
+}, { prefix: '/v1' })
+```
+
+#### pluginName
+<a id="pluginName"></a>
+
+Name of the current plugin. The root plugin is called `'fastify'`. There are
+different ways to define a name (in order).
+
+1. If you use [fastify-plugin](https://github.com/fastify/fastify-plugin) the
+   metadata `name` is used.
+2. If the exported plugin has the `Symbol.for('fastify.display-name')` property,
+   then the value of that property is used.
+   Example: `pluginFn[Symbol.for('fastify.display-name')] = "Custom Name"`
+3. If you `module.exports` a plugin the filename is used.
+4. If you use a regular [function
+   declaration](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Functions#defining_functions)
+   the function name is used.
+
+*Fallback*: The first two lines of your plugin will represent the plugin name.
+Newlines are replaced by ` -- `. This will help to identify the root cause when
+you deal with many plugins.
+
+> ⚠ Warning:
+> If you have to deal with nested plugins, the name differs with the usage of
+> the [fastify-plugin](https://github.com/fastify/fastify-plugin) because
+> no new scope is created and therefore we have no place to attach contextual
+> data. In that case, the plugin name will represent the boot order of all
+> involved plugins in the format of `fastify -> plugin-A -> plugin-B`.
+
+#### hasPlugin
+<a id="hasPlugin"></a>
+
+Method to check if a specific plugin has been registered. Relies on the plugin
+metadata name. Returns `true` if the plugin is registered. Otherwise, returns
+`false`.
+
+```js
+const fastify = require('fastify')()
+fastify.register(require('@fastify/cookie'), {
+  secret: 'my-secret',
+  parseOptions: {}
+})
+
+fastify.ready(() => {
+  fastify.hasPlugin('@fastify/cookie') // true
+})
+```
+
+#### listeningOrigin
+<a id="listeningOrigin"></a>
+
+The current origin the server is listening to.
+For example, a TCP socket based server returns
+a base address like `http://127.0.0.1:3000`,
+and a Unix socket server will return the socket
+path, e.g. `fastify.temp.sock`.
+
+#### log
+<a id="log"></a>
+
+The logger instance, check [here](./Logging.md).
+
+#### version
+<a id="version"></a>
+
+Fastify version of the instance. Used for plugin support. See
+[Plugins](./Plugins.md#handle-the-scope) for information on how the version is
+used by plugins.
+
+#### inject
+<a id="inject"></a>
+
+Fake HTTP injection (for testing purposes)
+[here](../Guides/Testing.md#benefits-of-using-fastifyinject).
+
+#### addHttpMethod
+<a id="addHttpMethod"></a>
+
+Fastify supports the `GET`, `HEAD`, `TRACE`, `DELETE`, `OPTIONS`,
+`PATCH`, `PUT`, `POST` and `QUERY` HTTP methods by default.
+The `addHttpMethod` method allows to add any non standard HTTP
+methods to the server that are [supported by Node.js](https://nodejs.org/api/http.html#httpmethods).
+
+The method accepts an optional configuration object:
+
+| Property | Type | Default | Description |
+| -------- | ---- | ------- | ----------- |
+| `hasBody` | `boolean` | `false` | Whether the method accepts a request body. |
+| `overrideExisting` | `boolean` | `false` | Whether to explicitly override an existing method. |
+
+```js
+// Add a new HTTP method called 'MKCOL' that supports a request body
+fastify.addHttpMethod('MKCOL', { hasBody: true,  })
+
+// Add a new HTTP method called 'COPY' that does not support a request body
+fastify.addHttpMethod('COPY')
+```
+
+After calling `addHttpMethod`, it is possible to use the route shorthand
+methods to define routes for the new HTTP method:
+
+```js
+fastify.addHttpMethod('MKCOL', { hasBody: true })
+fastify.mkcol('/', (req, reply) => {
+  // Handle the 'MKCOL' request
+})
+```
+
+Calling `addHttpMethod` for an existing method overrides its body behavior.
+
+```js
+fastify.addHttpMethod('GET', {
+  hasBody: true,
+  overrideExisting: true
+})
+```
+
+In Fastify v5, omitting `overrideExisting: true` emits `FSTDEP025`; in Fastify
+v6, it will throw an error.
+
+#### addSchema
+<a id="add-schema"></a>
+
+`fastify.addSchema(schemaObj)`, adds a JSON schema to the Fastify instance. This
+allows you to reuse it everywhere in your application just by using the standard
+`$ref` keyword.
+
+To learn more, read the [Validation and
+Serialization](./Validation-and-Serialization.md) documentation.
+
+#### getSchemas
+<a id="get-schemas"></a>
+
+`fastify.getSchemas()`, returns a hash of all schemas added via `.addSchema`.
+The keys of the hash are the `$id`s of the JSON Schema provided.
+
+#### getSchema
+<a id="get-schema"></a>
+
+`fastify.getSchema(id)`, return the JSON schema added with `.addSchema` and the
+matching `id`. It returns `undefined` if it is not found.
+
+#### setReplySerializer
+<a id="set-reply-serializer"></a>
+
+Set the reply serializer for all the routes. This will be used as default if a
+[Reply.serializer(func)](./Reply.md#serializerfunc) has not been set. The
+handler is fully encapsulated, so different plugins can set different error
+handlers. Note: the function parameter is called only for status `2xx`. Check
+out the [`setErrorHandler`](#seterrorhandler) for errors.
+
+```js
+fastify.setReplySerializer(function (payload, statusCode){
+  // serialize the payload with a sync function
+  return `my serialized ${statusCode} content: ${payload}`
+})
+```
+
+#### setValidatorCompiler
+<a id="set-validator-compiler"></a>
+
+Set the schema validator compiler for all routes. See
+[#schema-validator](./Validation-and-Serialization.md#schema-validator).
+
+#### setSchemaErrorFormatter
+<a id="set-schema-error-formatter"></a>
+
+Set the schema error formatter for all routes. See
+[#error-handling](./Validation-and-Serialization.md#schemaerrorformatter).
+
+#### setSerializerCompiler
+<a id="set-serializer-resolver"></a>
+
+Set the schema serializer compiler for all routes. See
+[#schema-serializer](./Validation-and-Serialization.md#schema-serializer).
+
+> ℹ️ Note:
+> [`setReplySerializer`](#set-reply-serializer) has priority if set!
+
+#### validatorCompiler
+<a id="validator-compiler"></a>
+
+This property can be used to get the schema validator. If not set, it will be
+`null` until the server starts, then it will be a function with the signature
+`function ({ schema, method, url, httpPart })` that returns the input `schema`
+compiled to a function for validating data. The input `schema` can access all
+the shared schemas added with [`.addSchema`](#add-schema) function.
+
+#### serializerCompiler
+<a id="serializer-compiler"></a>
+
+This property can be used to get the schema serializer. If not set, it will be
+`null` until the server starts, then it will be a function with the signature
+`function ({ schema, method, url, httpPart })` that returns the input `schema`
+compiled to a function for validating data. The input `schema` can access all
+the shared schemas added with [`.addSchema`](#add-schema) function.
+
+#### schemaErrorFormatter
+<a id="schema-error-formatter"></a>
+
+This property can be used to set a function to format errors that happen while
+the `validationCompiler` fails to validate the schema. See
+[#error-handling](./Validation-and-Serialization.md#schemaerrorformatter).
+
+#### schemaController
+<a id="schema-controller"></a>
+
+This property can be used to fully manage:
+- `bucket`: where the schemas of your application will be stored
+- `compilersFactory`: what module must compile the JSON schemas
+
+It can be useful when your schemas are stored in another data structure that is
+unknown to Fastify.
+
+Another use case is to tweak all the schemas processing. Doing so it is possible
+to use Ajv v8 JTD or Standalone feature. To use such as JTD or the Standalone
+mode, refers to the [`@fastify/ajv-compiler`
+documentation](https://github.com/fastify/ajv-compiler#usage).
+
+```js
+const fastify = Fastify({
+  schemaController: {
+    /**
+     * This factory is called whenever `fastify.register()` is called.
+     * It may receive as input the schemas of the parent context if some schemas have been added.
+     * @param {object} parentSchemas these schemas will be returned by the
+     * `getSchemas()` method function of the returned `bucket`.
+     */
+    bucket: function factory (parentSchemas) {
+      return {
+        add (inputSchema) {
+          // This function must store the schema added by the user.
+          // This function is invoked when `fastify.addSchema()` is called.
+        },
+        getSchema (schema$id) {
+          // This function must return the raw schema requested by the `schema$id`.
+          // This function is invoked when `fastify.getSchema(id)` is called.
+          return aSchema
+        },
+        getSchemas () {
+          // This function must return all the schemas referenced by the routes schemas' $ref
+          // It must return a JSON where the property is the schema `$id` and the value is the raw JSON Schema.
+          const allTheSchemaStored = {
+            'schema$id1': schema1,
+            'schema$id2': schema2
+          }
+          return allTheSchemaStored
+        }
+      }
+    },
+
+    /**
+     * The compilers factory lets you fully control the validator and serializer
+     * in the Fastify's lifecycle, providing the encapsulation to your compilers.
+     */
+    compilersFactory: {
+      /**
+       * This factory is called whenever a new validator instance is needed.
+       * It may be called whenever `fastify.register()` is called only if new schemas have been added to the
+       * encapsulation context.
+       * It may receive as input the schemas of the parent context if some schemas have been added.
+       * @param {object} externalSchemas these schemas will be returned by the
+       * `bucket.getSchemas()`. Needed to resolve the external references $ref.
+       * @param {object} ajvServerOption the server `ajv` options to build your compilers accordingly
+       */
+      buildValidator: function factory (externalSchemas, ajvServerOption) {
+        // This factory function must return a schema validator compiler.
+        // See [#schema-validator](./Validation-and-Serialization.md#schema-validator) for details.
+        const yourAjvInstance = new Ajv(ajvServerOption.customOptions)
+        return function validatorCompiler ({ schema, method, url, httpPart }) {
+          return yourAjvInstance.compile(schema)
+        }
+      },
+
+      /**
+       * This factory is called whenever a new serializer instance is needed.
+       * It may be called whenever `fastify.register()` is called only if new schemas have been added to the
+       * encapsulation context.
+       * It may receive as input the schemas of the parent context if some schemas have been added.
+       * @param {object} externalSchemas these schemas will be returned by the
+       * `bucket.getSchemas()`. Needed to resolve the external references $ref.
+       * @param {object} serializerOptsServerOption the server `serializerOpts`
+       * options to build your compilers accordingly
+       */
+      buildSerializer: function factory (externalSchemas, serializerOptsServerOption) {
+        // This factory function must return a schema serializer compiler.
+        // See [#schema-serializer](./Validation-and-Serialization.md#schema-serializer) for details.
+        return function serializerCompiler ({ schema, method, url, httpStatus, contentType }) {
+          return data => JSON.stringify(data)
+        }
+      }
+    }
+  }
+});
+```
+
+#### setNotFoundHandler
+<a id="set-not-found-handler"></a>
+
+`fastify.setNotFoundHandler(handler(request, reply))`: set the 404 handler. This
+call is encapsulated by prefix, so different plugins can set different not found
+handlers if a different [`prefix` option](./Plugins.md#route-prefixing-option)
+is passed to `fastify.register()`. The handler is treated as a regular route
+handler so requests will go through the full [Fastify
+lifecycle](./Lifecycle.md#lifecycle) for unexisting URLs.
+*async-await* is supported as well.
+Badly formatted URLs are sent to the [`onBadUrl`](#onbadurl)
+handler instead.
+
+You can also register [`preValidation`](./Hooks.md#route-hooks) and
+[`preHandler`](./Hooks.md#route-hooks) hooks for the 404 handler.
+
+> ℹ️ Note:
+> The `preValidation` hook registered using this method will run for a
+> route that Fastify does not recognize and **not** when a route handler manually
+> calls [`reply.callNotFound`](./Reply.md#call-not-found). In which case, only
+> preHandler will be run.
+
+
+```js
+fastify.setNotFoundHandler({
+  preValidation: (req, reply, done) => {
+    // your code
+    done()
+  },
+  preHandler: (req, reply, done) => {
+    // your code
+    done()
+  }
+}, function (request, reply) {
+    // Default not found handler with preValidation and preHandler hooks
+})
+
+fastify.register(function (instance, options, done) {
+  instance.setNotFoundHandler(function (request, reply) {
+    // Handle not found request without preValidation and preHandler hooks
+    // to URLs that begin with '/v1'
+  })
+  done()
+}, { prefix: '/v1' })
+```
+
+Fastify calls setNotFoundHandler to add a default 404 handler at startup before
+plugins are registered. If you would like to augment the behavior of the default
+404 handler, for example with plugins, you can call setNotFoundHandler with no
+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.routeOptions.url`, `routeOptions.method` and `routeOptions.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>
+
+`fastify.setErrorHandler(handler(error, request, reply))`: Set a function that
+will be invoked whenever an exception is thrown during the request lifecycle.
+The handler is bound to the Fastify instance and is fully encapsulated, so
+different plugins can set different error handlers. *async-await* is
+supported as well.
+
+If the error `statusCode` is less than 400, Fastify will automatically
+set it to 500 before calling the error handler.
+
+`setErrorHandler` will ***not*** catch:
+- exceptions thrown in an `onResponse` hook because the response has already been
+  sent to the client. Use the `onSend` hook instead.
+- not found (404) errors. Use [`setNotFoundHandler`](#set-not-found-handler)
+  instead.
+- Stream errors thrown during piping into the response socket, as
+  headers/response were already sent to the client.
+  Use custom in-stream data to signal such errors.
+
+```js
+fastify.setErrorHandler(function (error, request, reply) {
+  // Log error
+  this.log.error(error)
+  // Send error response
+  reply.status(409).send({ ok: false })
+})
+```
+
+Fastify is provided with a default function that is called if no error handler
+is set. It can be accessed using `fastify.errorHandler` and it logs the error
+with respect to its `statusCode`.
+
+```js
+const statusCode = error.statusCode
+if (statusCode >= 500) {
+  log.error(error)
+} else if (statusCode >= 400) {
+  log.info(error)
+} else {
+  log.error(error)
+}
+```
+
+> ⚠ Warning:
+> Avoid calling setErrorHandler multiple times in the same scope.
+> See [`allowErrorHandlerOverride`](#allowerrorhandleroverride).
+
+##### Custom error handler for stream replies
+<a id="set-error-handler-stream-replies"></a>
+
+If `Content-Type` differs between the endpoint and error handler, explicitly
+define it in both. For example, if the endpoint returns an `application/text`
+stream and the error handler responds with `application/json`, the error handler
+must explicitly set `Content-Type`. Otherwise, it will fail serialization with
+a `500` status code. Alternatively, always respond with serialized data in the
+error handler by manually calling a serialization method (e.g.,
+`JSON.stringify`).
+
+```js
+fastify.setErrorHandler((err, req, reply) => {
+  reply
+    .code(400)
+    .type('application/json')
+    .send({ error: err.message })
+})
+```
+
+```js
+fastify.setErrorHandler((err, req, reply) => {
+  reply
+    .code(400)
+    .send(JSON.stringify({ error: err.message }))
+})
+```
+
+#### setChildLoggerFactory
+<a id="set-child-logger-factory"></a>
+
+`fastify.setChildLoggerFactory(factory(logger, bindings, opts, rawReq))`: Set a
+function that will be called when creating a child logger instance for each request
+which allows for modifying or adding child logger bindings and logger options, or
+returning a custom child logger implementation.
+
+Child logger bindings have a performance advantage over per-log bindings because
+they are pre-serialized by Pino when the child logger is created.
+
+The first parameter is the parent logger instance, followed by the default bindings
+and logger options which should be passed to the child logger, and finally
+the raw request (not a Fastify request object). The function is bound with `this`
+being the Fastify instance.
+
+For example:
+```js
+const fastify = require('fastify')({
+  childLoggerFactory: function (logger, bindings, opts, rawReq) {
+    // Calculate additional bindings from the request if needed
+    bindings.traceContext = rawReq.headers['x-cloud-trace-context']
+    return logger.child(bindings, opts)
+  }
+})
+```
+
+The handler is bound to the Fastify instance and is fully encapsulated, so
+different plugins can set different logger factories.
+
+#### setgenreqid
+<a id="set-gen-req-id"></a>
+
+`fastify.setGenReqId(function (rawReq))` Synchronous function for setting the request-id
+for additional Fastify instances. It will receive the _raw_ incoming request as
+a parameter. The provided function should not throw an Error in any case.
+
+Especially in distributed systems, you may want to override the default ID
+generation behavior to handle custom ways of generating different IDs in
+order to handle different use cases. Such as observability or webhooks plugins.
+
+For example:
+```js
+const fastify = require('fastify')({
+  genReqId: (req) => {
+    return 'base'
+  }
+})
+
+fastify.register((instance, opts, done) => {
+  instance.setGenReqId((req) => {
+    // custom request ID for `/webhooks`
+    return 'webhooks-id'
+  })
+  done()
+}, { prefix: '/webhooks' })
+
+fastify.register((instance, opts, done) => {
+  instance.setGenReqId((req) => {
+    // custom request ID for `/observability`
+    return 'observability-id'
+  })
+  done()
+}, { prefix: '/observability' })
+```
+
+The handler is bound to the Fastify instance and is fully encapsulated, so
+different plugins can set a different request ID.
+
+#### addConstraintStrategy
+<a id="addConstraintStrategy"></a>
+
+Function to add a custom constraint strategy. To register a new type of
+constraint, you must add a new constraint strategy that knows how to match
+values to handlers, and that knows how to get the constraint value from a
+request.
+
+Add a custom constraint strategy using the `fastify.addConstraintStrategy`
+method:
+
+```js
+const customResponseTypeStrategy = {
+  // strategy name for referencing in the route handler `constraints` options
+  name: 'accept',
+  // storage factory for storing routes in the find-my-way route tree
+  storage: function () {
+    let handlers = {}
+    return {
+      get: (type) => { return handlers[type] || null },
+      set: (type, store) => { handlers[type] = store }
+    }
+  },
+  // function to get the value of the constraint from each incoming request
+  deriveConstraint: (req, ctx) => {
+    return req.headers['accept']
+  },
+  // optional flag marking if handlers without constraints can match requests that have a value for this constraint
+  mustMatchWhenDerived: true
+}
+
+const router = Fastify();
+router.addConstraintStrategy(customResponseTypeStrategy);
+```
+
+#### hasConstraintStrategy
+<a id="hasConstraintStrategy"></a>
+
+The `fastify.hasConstraintStrategy(strategyName)` checks if there already exists
+a custom constraint strategy with the same name.
+
+#### printRoutes
+<a id="print-routes"></a>
+
+`fastify.printRoutes()`: Fastify router builds a tree of routes for each HTTP
+method. If you call the prettyPrint without specifying an HTTP method, it will
+merge all the trees into one and print it. The merged tree doesn't represent the
+internal router structure. **Do not use it for debugging.**
+
+*Remember to call it inside or after a `ready` call.*
+
+```js
+fastify.get('/test', () => {})
+fastify.get('/test/hello', () => {})
+fastify.get('/testing', () => {})
+fastify.get('/testing/:param', () => {})
+fastify.put('/update', () => {})
+
+fastify.ready(() => {
+  console.log(fastify.printRoutes())
+  // └── /
+  //     ├── test (GET)
+  //     │   ├── /hello (GET)
+  //     │   └── ing (GET)
+  //     │       └── /
+  //     │           └── :param (GET)
+  //     └── update (PUT)
+})
+```
+
+If you want to print the internal router tree, you should specify the `method`
+param. Printed tree will represent the internal router structure.
+**You can use it for debugging.**
+
+```js
+  console.log(fastify.printRoutes({ method: 'GET' }))
+  // └── /
+  //     └── test (GET)
+  //         ├── /hello (GET)
+  //         └── ing (GET)
+  //             └── /
+  //                 └── :param (GET)
+
+  console.log(fastify.printRoutes({ method: 'PUT' }))
+  // └── /
+  //     └── update (PUT)
+```
+
+`fastify.printRoutes({ commonPrefix: false })` will print compressed trees. This
+may be useful when you have a large number of routes with common prefixes.
+It doesn't represent the internal router structure. **Do not use it for debugging.**
+
+```js
+  console.log(fastify.printRoutes({ commonPrefix: false }))
+  // ├── /test (GET)
+  // │   ├── /hello (GET)
+  // │   └── ing (GET)
+  // │       └── /:param (GET)
+  // └── /update (PUT)
+```
+
+`fastify.printRoutes({ includeMeta: (true | []) })` will display properties from
+the `route.store` object for each displayed route. This can be an `array` of
+keys (e.g. `['onRequest', Symbol('key')]`), or `true` to display all properties.
+A shorthand option, `fastify.printRoutes({ includeHooks: true })` will include
+all [hooks](./Hooks.md).
+
+```js
+  fastify.get('/test', () => {})
+  fastify.get('/test/hello', () => {})
+
+  const onTimeout = () => {}
+
+  fastify.addHook('onRequest', () => {})
+  fastify.addHook('onTimeout', onTimeout)
+
+  console.log(fastify.printRoutes({ includeHooks: true, includeMeta: ['errorHandler'] }))
+  // └── /
+  //     └── test (GET)
+  //         • (onTimeout) ["onTimeout()"]
+  //         • (onRequest) ["anonymous()"]
+  //         • (errorHandler) "defaultErrorHandler()"
+  //         test (HEAD)
+  //         • (onTimeout) ["onTimeout()"]
+  //         • (onRequest) ["anonymous()"]
+  //         • (onSend) ["headRouteOnSendHandler()"]
+  //         • (errorHandler) "defaultErrorHandler()"
+  //         └── /hello (GET)
+  //             • (onTimeout) ["onTimeout()"]
+  //             • (onRequest) ["anonymous()"]
+  //             • (errorHandler) "defaultErrorHandler()"
+  //             /hello (HEAD)
+  //             • (onTimeout) ["onTimeout()"]
+  //             • (onRequest) ["anonymous()"]
+  //             • (onSend) ["headRouteOnSendHandler()"]
+  //             • (errorHandler) "defaultErrorHandler()"
+
+  console.log(fastify.printRoutes({ includeHooks: true }))
+  // └── /
+  //     └── test (GET)
+  //         • (onTimeout) ["onTimeout()"]
+  //         • (onRequest) ["anonymous()"]
+  //         test (HEAD)
+  //         • (onTimeout) ["onTimeout()"]
+  //         • (onRequest) ["anonymous()"]
+  //         • (onSend) ["headRouteOnSendHandler()"]
+  //         └── /hello (GET)
+  //             • (onTimeout) ["onTimeout()"]
+  //             • (onRequest) ["anonymous()"]
+  //             /hello (HEAD)
+  //             • (onTimeout) ["onTimeout()"]
+  //             • (onRequest) ["anonymous()"]
+  //             • (onSend) ["headRouteOnSendHandler()"]
+```
+
+#### printPlugins
+<a id="print-plugins"></a>
+
+`fastify.printPlugins()`: Prints the representation of the internal plugin tree
+used by the avvio, useful for debugging require order issues.
+
+*Remember to call it inside or after a `ready` call.*
+
+```js
+fastify.register(async function foo (instance) {
+  instance.register(async function bar () {})
+})
+fastify.register(async function baz () {})
+
+fastify.ready(() => {
+  console.error(fastify.printPlugins())
+  // will output the following to stderr:
+  // └── root
+  //     ├── foo
+  //     │   └── bar
+  //     └── baz
+})
+```
+
+#### addContentTypeParser
+<a id="addContentTypeParser"></a>
+
+`fastify.addContentTypeParser(content-type, options, parser)` is used to pass
+a custom parser for a given content type. Useful for adding parsers for custom
+content types, e.g. `text/json, application/vnd.oasis.opendocument.text`.
+`content-type` can be a string, string array or RegExp.
+
+```js
+// The two arguments passed to getDefaultJsonParser are for ProtoType poisoning
+// and Constructor Poisoning configuration respectively. The possible values are
+// 'ignore', 'remove', 'error'. ignore  skips all validations and it is similar
+// to calling JSON.parse() directly. See the
+// [`secure-json-parse` documentation](https://github.com/fastify/secure-json-parse#api) for more information.
+
+fastify.addContentTypeParser('text/json', { asString: true }, fastify.getDefaultJsonParser('ignore', 'ignore'))
+```
+
+#### hasContentTypeParser
+<a id="hasContentTypeParser"></a>
+
+`fastify.hasContentTypeParser(contentType)` is used to check whether there is a
+content type parser in the current context for the specified content type.
+
+```js
+fastify.hasContentTypeParser('text/json')
+
+fastify.hasContentTypeParser(/^.+\/json$/)
+```
+
+#### removeContentTypeParser
+<a id="removeContentTypeParser"></a>
+
+`fastify.removeContentTypeParser(contentType)` is used to remove content type
+parsers in the current context. This method allows for example to remove the
+both built-in parsers for `application/json` and `text/plain`.
+
+```js
+fastify.removeContentTypeParser('application/json')
+
+fastify.removeContentTypeParser(['application/json', 'text/plain'])
+```
+
+#### removeAllContentTypeParsers
+<a id="removeAllContentTypeParsers"></a>
+
+The `fastify.removeAllContentTypeParsers()` method allows all content type
+parsers in the current context to be removed. A use case of this method is the
+implementation of catch-all content type parser. Before adding this parser with
+`fastify.addContentTypeParser()` one could call the
+`removeAllContentTypeParsers` method.
+
+For more details about the usage of the different content type parser APIs see
+[here](./ContentTypeParser.md#usage).
+
+#### getDefaultJsonParser
+<a id="getDefaultJsonParser"></a>
+
+`fastify.getDefaultJsonParser(onProtoPoisoning, onConstructorPoisoning)` takes
+two arguments. First argument is ProtoType poisoning configuration and second
+argument is constructor poisoning configuration. See the [`secure-json-parse`
+documentation](https://github.com/fastify/secure-json-parse#api) for more
+information.
+
+
+#### defaultTextParser
+<a id="defaultTextParser"></a>
+
+`fastify.defaultTextParser()` can be used to parse content as plain text.
+
+```js
+fastify.addContentTypeParser('text/json', { asString: true }, fastify.defaultTextParser)
+```
+
+#### errorHandler
+<a id="errorHandler"></a>
+
+`fastify.errorHandler` can be used to handle errors using fastify's default
+error handler.
+
+```js
+fastify.get('/', {
+  errorHandler: (error, request, reply) => {
+    if (error.code === 'SOMETHING_SPECIFIC') {
+      reply.send({ custom: 'response' })
+      return
+    }
+
+    fastify.errorHandler(error, request, reply)
+  }
+}, handler)
+```
+
+#### childLoggerFactory
+<a id="childLoggerFactory"></a>
+
+`fastify.childLoggerFactory` returns the custom logger factory function for the
+Fastify instance. See the [`childLoggerFactory` config option](#setchildloggerfactory)
+for more info.
+
+#### Symbol.asyncDispose
+<a id="symbolAsyncDispose"></a>
+
+`fastify[Symbol.asyncDispose]` is a symbol that can be used to define an
+asynchronous function that will be called when the Fastify instance is closed.
+
+It's commonly used alongside the `using` TypeScript keyword to ensure that
+resources are cleaned up when the Fastify instance is closed.
+
+This combines perfectly inside short lived processes or unit tests, where you must
+close all Fastify resources after returning from inside the function.
+
+```ts
+test('Uses app and closes it afterwards', async () => {
+  await using app = fastify();
+  // do something with app.
+})
+```
+
+In the above example, Fastify is closed automatically after the test finishes.
+
+Read more about the
+[ECMAScript Explicit Resource Management](https://tc39.es/proposal-explicit-resource-management/)
+and the [using keyword](https://devblogs.microsoft.com/typescript/announcing-typescript-5-2/)
+introduced in TypeScript 5.2.
+
+#### initialConfig
+<a id="initial-config"></a>
+
+`fastify.initialConfig`: Exposes a frozen read-only object registering the
+initial options passed down by the user to the Fastify instance.
+
+The properties that can currently be exposed are:
+- connectionTimeout
+- keepAliveTimeout
+- handlerTimeout
+- bodyLimit
+- caseSensitive
+- http2
+- https (it will return `false`/`true` or `{ allowHTTP1: true/false }` if
+  explicitly passed)
+- disableRequestLogging
+- onProtoPoisoning
+- onConstructorPoisoning
+- pluginTimeout
+- requestIdHeader
+- requestIdLogLabel
+- http2SessionTimeout
+- routerOptions
+  - allowUnsafeRegex
+  - buildPrettyMeta
+  - caseSensitive
+  - constraints
+  - defaultRoute
+  - ignoreDuplicateSlashes
+  - ignoreTrailingSlash
+  - maxParamLength
+  - onBadUrl
+  - querystringParser
+  - useSemicolonDelimiter
+
+```js
+const { readFileSync } = require('node:fs')
+const Fastify = require('fastify')
+
+const fastify = Fastify({
+  https: {
+    allowHTTP1: true,
+    key: readFileSync('./fastify.key'),
+    cert: readFileSync('./fastify.cert')
+  },
+  logger: { level: 'trace'},
+  routerOptions: {
+    ignoreTrailingSlash: true,
+    maxParamLength: 200,
+    caseSensitive: true,
+  },
+  trustProxy: '127.0.0.1,192.168.1.1/24',
+})
+
+console.log(fastify.initialConfig)
+/*
+will log :
+{
+  https: { allowHTTP1: true },
+  routerOptions: {
+    caseSensitive: true,
+    ignoreTrailingSlash: true,
+    maxParamLength: 200
+  }
+}
+*/
+
+fastify.register(async (instance, opts) => {
+  instance.get('/', async (request, reply) => {
+    return instance.initialConfig
+    /*
+    will return :
+    {
+      https: { allowHTTP1: true },
+      routerOptions: {
+        caseSensitive: true,
+        ignoreTrailingSlash: true,
+        maxParamLength: 200
+      }
+    }
+    */
+  })
+
+  instance.get('/error', async (request, reply) => {
+    // will throw an error because initialConfig is read-only
+    // and can not be modified
+    instance.initialConfig.https.allowHTTP1 = false
+
+    return instance.initialConfig
+  })
+})
+
+// Start listening.
+fastify.listen({ port: 3000 }, (err) => {
+  if (err) {
+    fastify.log.error(err)
+    process.exit(1)
+  }
+})
+```