fastify 4.25.2 → 4.26.0

package/docs/Guides/Getting-Started.md

@@ -55,6 +55,14 @@ fastify.listen({ port: 3000 }, function (err, address) {
 })
 ```
 
+> If you are using ECMAScript Modules (ESM) in your project, be sure to
+> include "type": "module" in your package.json.
+>```js
+>{
+>  "type": "module"
+>}
+>```
+
 Do you prefer to use `async/await`? Fastify supports it out-of-the-box.
 
 ```js
@@ -172,13 +180,14 @@ fastify.listen({ port: 3000 }, function (err, address) {
 })
 ```
 
+
 ```js
 // our-first-route.js
 
 /**
  * Encapsulates the routes
  * @param {FastifyInstance} fastify  Encapsulated Fastify Instance
- * @param {Object} options plugin options, refer to https://www.fastify.dev/docs/latest/Reference/Plugins/#plugin-options
+ * @param {Object} options plugin options, refer to https://fastify.dev/docs/latest/Reference/Plugins/#plugin-options
  */
 async function routes (fastify, options) {
   fastify.get('/', async (request, reply) => {
@@ -186,6 +195,10 @@ async function routes (fastify, options) {
   })
 }
 
+//ESM
+export default routes;
+
+// CommonJs
 module.exports = routes
 ```
 In this example, we used the `register` API, which is the core of the Fastify
@@ -293,7 +306,7 @@ const fastifyPlugin = require('fastify-plugin')
 /**
  * Connects to a MongoDB database
  * @param {FastifyInstance} fastify Encapsulated Fastify Instance
- * @param {Object} options plugin options, refer to https://www.fastify.dev/docs/latest/Reference/Plugins/#plugin-options
+ * @param {Object} options plugin options, refer to https://fastify.dev/docs/latest/Reference/Plugins/#plugin-options
  */
 async function dbConnector (fastify, options) {
   fastify.register(require('@fastify/mongodb'), {
@@ -312,7 +325,7 @@ module.exports = fastifyPlugin(dbConnector)
 /**
  * A plugin that provide encapsulated routes
  * @param {FastifyInstance} fastify encapsulated fastify instance
- * @param {Object} options plugin options, refer to https://www.fastify.dev/docs/latest/Reference/Plugins/#plugin-options
+ * @param {Object} options plugin options, refer to https://fastify.dev/docs/latest/Reference/Plugins/#plugin-options
  */
 async function routes (fastify, options) {
   const collection = fastify.mongo.db.collection('test_collection')

package/docs/Guides/Style-Guide.md

@@ -13,7 +13,7 @@ This guide is for anyone who loves to build with Fastify or wants to contribute
 to our documentation. You do not need to be an expert in writing technical
 documentation. This guide is here to help you.
 
-Visit the [contribute](https://www.fastify.dev/contribute) page on our website or
+Visit the [contribute](https://fastify.dev/contribute) page on our website or
 read the
 [CONTRIBUTING.md](https://github.com/fastify/fastify/blob/main/CONTRIBUTING.md)
 file on GitHub to join our Open Source folks.
@@ -70,12 +70,12 @@ markdown.
 **Example**
 
 ```
-To learn more about hooks, see [Fastify hooks](https://www.fastify.dev/docs/latest/Reference/Hooks/).
+To learn more about hooks, see [Fastify hooks](https://fastify.dev/docs/latest/Reference/Hooks/).
 ```
 
 Result:
 >To learn more about hooks, see [Fastify
->hooks](https://www.fastify.dev/docs/latest/Reference/Hooks/).
+>hooks](https://fastify.dev/docs/latest/Reference/Hooks/).
 
 
 
@@ -224,18 +224,18 @@ hyperlink should look:
 <!-- More like this -->
 
 // Add clear & brief description
-[Fastify Plugins] (https://www.fastify.dev/docs/latest/Plugins/)
+[Fastify Plugins] (https://fastify.dev/docs/latest/Plugins/)
 
 <!--Less like this -->
 
 // incomplete description
-[Fastify] (https://www.fastify.dev/docs/latest/Plugins/)
+[Fastify] (https://fastify.dev/docs/latest/Plugins/)
 
 // Adding title in link brackets
-[](https://www.fastify.dev/docs/latest/Plugins/ "fastify plugin")
+[](https://fastify.dev/docs/latest/Plugins/ "fastify plugin")
 
 // Empty title
-[](https://www.fastify.dev/docs/latest/Plugins/)
+[](https://fastify.dev/docs/latest/Plugins/)
 
 // Adding links localhost URLs instead of using code strings (``)
 [http://localhost:3000/](http://localhost:3000/)

package/docs/Reference/Decorators.md

@@ -101,7 +101,7 @@ console.log(fastify.conf.db)
 ```
 
 The decorated [Fastify server](./Server.md) is bound to `this` in
-route [route](./Routes.md) handlers:
+[route](./Routes.md) handlers:
 
 ```js
 fastify.decorate('db', new DbConnection())

package/docs/Reference/Errors.md

@@ -45,6 +45,7 @@
     - [FST_ERR_LOG_INVALID_DESTINATION](#fst_err_log_invalid_destination)
     - [FST_ERR_LOG_INVALID_LOGGER](#fst_err_log_invalid_logger)
     - [FST_ERR_REP_INVALID_PAYLOAD_TYPE](#fst_err_rep_invalid_payload_type)
+    - [FST_ERR_REP_RESPONSE_BODY_CONSUMED](#fst_err_rep_response_body_consumed)
     - [FST_ERR_REP_ALREADY_SENT](#fst_err_rep_already_sent)
     - [FST_ERR_REP_SENT_VALUE](#fst_err_rep_sent_value)
     - [FST_ERR_SEND_INSIDE_ONERR](#fst_err_send_inside_onerr)
@@ -169,6 +170,65 @@ Some things to consider in your custom error handler:
     internally monitors the error invocation to avoid infinite loops for errors
     thrown in the reply phases of the lifecycle. (those after the route handler)
 
+When utilizing Fastify's custom error handling through [`setErrorHandler`](./Server.md#seterrorhandler),
+you should be aware of how errors are propagated between custom and default
+error handlers.
+
+If a plugin's error handler re-throws an error, and the error is not an 
+instance of [Error](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error)
+(as seen in the `/bad` route in the following example), it will not propagate
+to the parent context error handler. Instead, it will be caught by the default
+error handler.
+
+To ensure consistent error handling, it is recommended to throw instances of 
+`Error`. For instance, in the following example, replacing `throw 'foo'` with
+`throw new Error('foo')` in the `/bad` route ensures that errors propagate through
+the custom error handling chain as intended. This practice helps avoid potential
+pitfalls when working with custom error handling in Fastify.
+
+For example:
+```js
+const Fastify = require('fastify')
+
+// Instantiate the framework
+const fastify = Fastify({
+  logger: true
+})
+
+// Register parent error handler
+fastify.setErrorHandler((error, request, reply) => {
+  reply.status(500).send({ ok: false })
+})
+
+fastify.register((app, options, next) => {
+  // Register child error handler
+  fastify.setErrorHandler((error, request, reply) => {
+    throw error
+  })
+
+  fastify.get('/bad', async () => {
+    // Throws a non-Error type, 'bar'
+    throw 'foo'
+  })
+
+  fastify.get('/good', async () => {
+    // Throws an Error instance, 'bar'
+    throw new Error('bar')
+  })
+
+  next()
+})
+
+// Run the server
+fastify.listen({ port: 3000 }, function (err, address) {
+  if (err) {
+    fastify.log.error(err)
+    process.exit(1)
+  }
+  // Server is listening at ${address}
+})
+```
+
 ### Fastify Error Codes
 <a id="fastify-error-codes"></a>
 
@@ -183,7 +243,7 @@ const errorCodes = require('fastify').errorCodes
 
 For example:
 ```js
-const Fastify = require('./fastify')
+const Fastify = require('fastify')
 
 // Instantiate the framework
 const fastify = Fastify({
@@ -253,6 +313,8 @@ Below is a table with all the error codes that Fastify uses.
 | <a id="fst_err_log_invalid_destination">FST_ERR_LOG_INVALID_DESTINATION</a> | The logger does not accept the specified destination. | Use a `'stream'` or a `'file'` as the destination. | [#1168](https://github.com/fastify/fastify/pull/1168) |
 | <a id="fst_err_log_invalid_logger">FST_ERR_LOG_INVALID_LOGGER</a> | The logger should have all these methods: `'info'`, `'error'`, `'debug'`, `'fatal'`, `'warn'`, `'trace'`, `'child'`. | Use a logger with all the required methods. | [#4520](https://github.com/fastify/fastify/pull/4520) |
 | <a id="fst_err_rep_invalid_payload_type">FST_ERR_REP_INVALID_PAYLOAD_TYPE</a> | Reply payload can be either a `string` or a `Buffer`. | Use a `string` or a `Buffer` for the payload. | [#1168](https://github.com/fastify/fastify/pull/1168) |
+| <a id="fst_err_rep_response_body_consumed">FST_ERR_REP_RESPONSE_BODY_CONSUMED</a> | Using `Response` as reply payload
+but the body is being consumed. | Make sure you don't consume the `Response.body` | [#5286](https://github.com/fastify/fastify/pull/5286) |
 | <a id="fst_err_rep_already_sent">FST_ERR_REP_ALREADY_SENT</a> | A response was already sent. | - | [#1336](https://github.com/fastify/fastify/pull/1336) |
 | <a id="fst_err_rep_sent_value">FST_ERR_REP_SENT_VALUE</a> | The only possible value for `reply.sent` is `true`. | - | [#1336](https://github.com/fastify/fastify/pull/1336) |
 | <a id="fst_err_send_inside_onerr">FST_ERR_SEND_INSIDE_ONERR</a> | You cannot use `send` inside the `onError` hook. | - | [#1348](https://github.com/fastify/fastify/pull/1348) |

package/docs/Reference/Hooks.md

@@ -232,7 +232,7 @@ fastify.addHook('onSend', (request, reply, payload, done) => {
 > `null`.
 
 Note: If you change the payload, you may only change it to a `string`, a
-`Buffer`, a `stream`, or `null`.
+`Buffer`, a `stream`, a `ReadableStream`, a `Response`, or `null`.
 
 
 ### onResponse

package/docs/Reference/Logging.md

@@ -61,9 +61,9 @@ the Fastify instance:
 fastify.log.info('Something important happened!');
 ```
 
-If you want to pass some options to the logger, just pass them to Fastify. You
-can find all available options in the [Pino
-documentation](https://github.com/pinojs/pino/blob/master/docs/api.md#pinooptions-stream).
+If you want to pass some options to the logger, just pass them to Fastify.
+You can find all available options in the
+[Pino documentation](https://github.com/pinojs/pino/blob/master/docs/api.md#options).
 If you want to specify a file destination, use:
 
 ```js

package/docs/Reference/Reply.md

@@ -4,6 +4,7 @@
 - [Reply](#reply)
   - [Introduction](#introduction)
   - [.code(statusCode)](#codestatuscode)
+  - [.elapsedTime](#elapsedtime)
   - [.statusCode](#statuscode)
   - [.server](#server)
   - [.header(key, value)](#headerkey-value)
@@ -32,6 +33,8 @@
     - [Strings](#strings)
     - [Streams](#streams)
     - [Buffers](#buffers)
+    - [ReadableStream](#send-readablestream)
+    - [Response](#send-response)
     - [Errors](#errors)
     - [Type of the final payload](#type-of-the-final-payload)
     - [Async-Await and Promises](#async-await-and-promises)
@@ -46,6 +49,8 @@ object that exposes the following functions and properties:
 - `.code(statusCode)` - Sets the status code.
 - `.status(statusCode)` - An alias for `.code(statusCode)`.
 - `.statusCode` - Read and set the HTTP status code.
+- `.elapsedTime` - Returns the amount of time passed
+since the request was received by Fastify.
 - `.server` - A reference to the fastify instance object.
 - `.header(name, value)` - Sets a response header.
 - `.headers(object)` - Sets all the keys of the object as response headers.
@@ -85,6 +90,8 @@ object that exposes the following functions and properties:
   from Node core.
 - `.log` - The logger instance of the incoming request.
 - `.request` - The incoming request.
+- `.getResponseTime()` - Deprecated, returns the amount of time passed
+since the request was received by Fastify.
 - `.context` - Deprecated, access the [Request's context](./Request.md) property.
 
 ```js
@@ -110,6 +117,19 @@ fastify.get('/', {config: {foo: 'bar'}}, function (request, reply) {
 
 If not set via `reply.code`, the resulting `statusCode` will be `200`.
 
+### .elapsedTime
+<a id="elapsedTime"></a>
+
+Invokes the custom response time getter to calculate the amount of time passed
+since the request was received by Fastify.
+
+Note that unless this function is called in the [`onResponse`
+hook](./Hooks.md#onresponse) it will always return `0`.
+
+```js
+const milliseconds = reply.elapsedTime
+```
+
 ### .statusCode
 <a id="statusCode"></a>
 
@@ -327,7 +347,7 @@ reply.callNotFound()
 <a id="getResponseTime"></a>
 
 Invokes the custom response time getter to calculate the amount of time passed
-since the request was started.
+since the request was received by Fastify.
 
 Note that unless this function is called in the [`onResponse`
 hook](./Hooks.md#onresponse) it will always return `0`.
@@ -336,6 +356,9 @@ hook](./Hooks.md#onresponse) it will always return `0`.
 const milliseconds = reply.getResponseTime()
 ```
 
+*Note: This method is deprecated and will be removed in `fastify@5`.
+Use the [.elapsedTime](#elapsedtime) property instead.*
+
 ### .type(contentType)
 <a id="type"></a>
 
@@ -735,6 +758,52 @@ fastify.get('/streams', function (request, reply) {
 })
 ```
 
+#### ReadableStream
+<a id="send-readablestream"></a>
+
+`ReadableStream` will be treated as a node stream mentioned above,
+the content is considered to be pre-serialized, so they will be 
+sent unmodified without response validation.
+
+```js
+const fs = require('node:fs')
+const { ReadableStream } = require('node:stream/web')
+fastify.get('/streams', function (request, reply) {
+  const stream = fs.createReadStream('some-file')
+  reply.header('Content-Type', 'application/octet-stream')
+  reply.send(ReadableStream.from(stream))
+})
+```
+
+#### Response
+<a id="send-response"></a>
+
+`Response` allows to manage the reply payload, status code and
+headers in one place. The payload provided inside `Response` is
+considered to be pre-serialized, so they will be sent unmodified 
+without response validation.
+
+Plese be aware when using `Response`, the status code and headers
+will not directly reflect to `reply.statusCode` and `reply.getHeaders()`.
+Such behavior is based on `Response` only allow `readonly` status
+code and headers. The data is not allow to be bi-direction editing,
+and may confuse when checking the `payload` in `onSend` hooks.
+
+```js
+const fs = require('node:fs')
+const { ReadableStream } = require('node:stream/web')
+fastify.get('/streams', function (request, reply) {
+  const stream = fs.createReadStream('some-file')
+  const readableStream = ReadableStream.from(stream)
+  const response = new Response(readableStream, {
+    status: 200,
+    headers: { 'content-type': 'application/octet-stream' }
+  })
+  reply.send(response)
+})
+```
+
+
 #### Errors
 <a id="errors"></a>
 

package/docs/Reference/Server.md

@@ -44,6 +44,7 @@ describes the properties available in that options object.
   - [`frameworkErrors`](#frameworkerrors)
   - [`clientErrorHandler`](#clienterrorhandler)
   - [`rewriteUrl`](#rewriteurl)
+  - [`useSemicolonDelimiter`](#usesemicolondelimiter)
 - [Instance](#instance)
   - [Server Methods](#server-methods)
     - [server](#server)
@@ -57,6 +58,7 @@ describes the properties available in that options object.
     - [routing](#routing)
     - [route](#route)
     - [hasRoute](#hasroute)
+    - [findRoute](#findroute)
     - [close](#close)
     - [decorate\*](#decorate)
     - [register](#register)
@@ -82,6 +84,7 @@ describes the properties available in that options object.
     - [setNotFoundHandler](#setnotfoundhandler)
     - [setErrorHandler](#seterrorhandler)
     - [setChildLoggerFactory](#setchildloggerfactory)
+    - [setGenReqId](#setGenReqId)
     - [addConstraintStrategy](#addconstraintstrategy)
     - [hasConstraintStrategy](#hasconstraintstrategy)
     - [printRoutes](#printroutes)
@@ -859,6 +862,31 @@ function rewriteUrl (req) {
 }
 ```
 
+### `useSemicolonDelimiter`
+<a id="use-semicolon-delimiter"></a>
+
++ Default `true`
+
+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 compatiblilty for the need to split on `;`. To disable support for splitting
+on `;` set `useSemicolonDelimiter` to `false`.
+
+```js
+const fastify = require('fastify')({
+  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
+})
+```
+
+
 ## Instance
 
 ### Server Methods
@@ -1148,6 +1176,28 @@ if (routeExists === false) {
 }
 ```
 
+#### 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>
 
@@ -1591,6 +1641,45 @@ const fastify = require('fastify')({
 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>
 
@@ -1920,6 +2009,7 @@ The properties that can currently be exposed are:
 - requestIdHeader
 - requestIdLogLabel
 - http2SessionTimeout
+- useSemicolonDelimiter 
 
 ```js
 const { readFileSync } = require('node:fs')

package/docs/Reference/Warnings.md

@@ -23,6 +23,7 @@
     - [FSTDEP017](#FSTDEP017)
     - [FSTDEP018](#FSTDEP018)
     - [FSTDEP019](#FSTDEP019)
+    - [FSTDEP020](#FSTDEP020)
 
 
 ## Warnings
@@ -75,3 +76,4 @@ Deprecation codes are further supported by the Node.js CLI options:
 | <a id="FSTDEP017">FSTDEP017</a> | You are accessing the deprecated `request.routerPath` property. | Use `request.routeOptions.url`. | [#4470](https://github.com/fastify/fastify/pull/4470) |
 | <a id="FSTDEP018">FSTDEP018</a> | You are accessing the deprecated `request.routerMethod` property. | Use `request.routeOptions.method`. | [#4470](https://github.com/fastify/fastify/pull/4470) |
 | <a id="FSTDEP019">FSTDEP019</a> | You are accessing the deprecated `reply.context` property. | Use `reply.routeOptions.config` or `reply.routeOptions.schema`. | [#5032](https://github.com/fastify/fastify/pull/5032) [#5084](https://github.com/fastify/fastify/pull/5084) |
+| <a id="FSTDEP020">FSTDEP020</a> | You are using the deprecated `reply.getReponseTime()` method. | Use the `reply.elapsedTime` property instead. | [#5263](https://github.com/fastify/fastify/pull/5263) |

package/fastify.d.ts

@@ -14,7 +14,7 @@ import { FastifyRequestContext, FastifyContextConfig, FastifyReplyContext } from
 import { FastifyErrorCodes } from './types/errors'
 import { DoneFuncWithErrOrRes, HookHandlerDoneFunction, RequestPayload, onCloseAsyncHookHandler, onCloseHookHandler, onErrorAsyncHookHandler, onErrorHookHandler, onReadyAsyncHookHandler, onReadyHookHandler, onListenAsyncHookHandler, onListenHookHandler, onRegisterHookHandler, onRequestAsyncHookHandler, onRequestHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler, onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler, preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler, preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler, preValidationHookHandler, onRequestAbortHookHandler, onRequestAbortAsyncHookHandler } from './types/hooks'
 import { FastifyListenOptions, FastifyInstance, PrintRoutesOptions } from './types/instance'
-import { FastifyBaseLogger, FastifyLoggerInstance, FastifyLoggerOptions, PinoLoggerOptions, FastifyLogFn, LogLevel, Bindings, ChildLoggerOptions } from './types/logger'
+import { FastifyBaseLogger, FastifyLoggerInstance, FastifyLoggerOptions, PinoLoggerOptions, FastifyLogFn, LogLevel } from './types/logger'
 import { FastifyPluginCallback, FastifyPluginAsync, FastifyPluginOptions, FastifyPlugin } from './types/plugin'
 import { FastifyRegister, FastifyRegisterOptions, RegisterOptions } from './types/register'
 import { FastifyReply } from './types/reply'
@@ -109,6 +109,7 @@ declare namespace fastify {
     allowUnsafeRegex?: boolean,
     requestIdHeader?: string | false,
     requestIdLogLabel?: string;
+    useSemicolonDelimiter?: boolean,
     jsonShorthand?: boolean;
     genReqId?: (req: RawRequestDefaultExpression<RawServer>) => string,
     trustProxy?: boolean | string | string[] | number | TrustProxyFunction,
@@ -238,4 +239,4 @@ declare function fastify<
 
 // CJS export
 // const fastify = require('fastify')
-export = fastify
+export = fastify

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.25.2'
+const VERSION = '4.26.0'
 
 const Avvio = require('avvio')
 const http = require('node:http')
@@ -28,7 +28,8 @@ const {
   kSchemaErrorFormatter,
   kErrorHandler,
   kKeepAliveConnections,
-  kChildLoggerFactory
+  kChildLoggerFactory,
+  kGenReqId
 } = require('./lib/symbols.js')
 
 const { createServer, compileValidateHTTPVersion } = require('./lib/server')
@@ -42,7 +43,7 @@ const SchemaController = require('./lib/schema-controller')
 const { Hooks, hookRunnerApplication, supportedHooks } = require('./lib/hooks')
 const { createLogger, createChildLogger, defaultChildLoggerFactory } = require('./lib/logger')
 const pluginUtils = require('./lib/pluginUtils')
-const { reqIdGenFactory } = require('./lib/reqIdGenFactory')
+const { getGenReqId, reqIdGenFactory } = require('./lib/reqIdGenFactory')
 const { buildRouting, validateBodyLimitOption } = require('./lib/route')
 const build404 = require('./lib/fourOhFour')
 const getSecuredInitialConfig = require('./lib/initialConfigValidation')
@@ -138,7 +139,6 @@ function fastify (options) {
   options.maxRequestsPerSocket = options.maxRequestsPerSocket || defaultInitOptions.maxRequestsPerSocket
   options.requestTimeout = options.requestTimeout || defaultInitOptions.requestTimeout
   options.logger = logger
-  options.genReqId = genReqId
   options.requestIdHeader = requestIdHeader
   options.requestIdLogLabel = requestIdLogLabel
   options.disableRequestLogging = disableRequestLogging
@@ -181,7 +181,8 @@ function fastify (options) {
       caseSensitive: options.caseSensitive,
       allowUnsafeRegex: options.allowUnsafeRegex || defaultInitOptions.allowUnsafeRegex,
       buildPrettyMeta: defaultBuildPrettyMeta,
-      querystringParser: options.querystringParser
+      querystringParser: options.querystringParser,
+      useSemicolonDelimiter: options.useSemicolonDelimiter ?? defaultInitOptions.useSemicolonDelimiter
     }
   })
 
@@ -247,6 +248,7 @@ function fastify (options) {
     [pluginUtils.kRegisteredPlugins]: [],
     [kPluginNameChain]: ['fastify'],
     [kAvvioBoot]: null,
+    [kGenReqId]: genReqId,
     // routing method
     routing: httpHandler,
     getDefaultRoute: router.getDefaultRoute.bind(router),
@@ -285,6 +287,9 @@ function fastify (options) {
     hasRoute: function _route (options) {
       return router.hasRoute.call(this, { options })
     },
+    findRoute: function _findRoute (options) {
+      return router.findRoute(options)
+    },
     // expose logger instance
     log: logger,
     // type provider
@@ -300,6 +305,8 @@ function fastify (options) {
     setSchemaController,
     setReplySerializer,
     setSchemaErrorFormatter,
+    // set generated request id
+    setGenReqId,
     // custom parsers
     addContentTypeParser: ContentTypeParser.helpers.addContentTypeParser,
     hasContentTypeParser: ContentTypeParser.helpers.hasContentTypeParser,
@@ -396,6 +403,10 @@ function fastify (options) {
       get () {
         return this[kErrorHandler].func
       }
+    },
+    genReqId: {
+      configurable: true,
+      get () { return this[kGenReqId] }
     }
   })
 
@@ -739,7 +750,7 @@ function fastify (options) {
 
   function onBadUrl (path, req, res) {
     if (frameworkErrors) {
-      const id = genReqId(req)
+      const id = getGenReqId(onBadUrlContext.server, req)
       const childLogger = createChildLogger(onBadUrlContext, logger, req, id)
 
       const request = new Request(id, null, req, null, childLogger, onBadUrlContext)
@@ -764,7 +775,7 @@ function fastify (options) {
     return function onAsyncConstraintError (err) {
       if (err) {
         if (frameworkErrors) {
-          const id = genReqId(req)
+          const id = getGenReqId(onBadUrlContext.server, req)
           const childLogger = createChildLogger(onBadUrlContext, logger, req, id)
 
           const request = new Request(id, null, req, null, childLogger, onBadUrlContext)
@@ -868,6 +879,13 @@ function fastify (options) {
       router.routing(req, res, buildAsyncConstraintCallback(isAsync, req, res))
     }
   }
+
+  function setGenReqId (func) {
+    throwIfAlreadyStarted('Cannot call "setGenReqId"!')
+
+    this[kGenReqId] = reqIdGenFactory(this[kOptions].requestIdHeader, func)
+    return this
+  }
 }
 
 fastify.errorCodes = errorCodes