fastify 5.0.0-alpha.2 → 5.0.0-alpha.4

package/README.md

@@ -307,8 +307,6 @@ listed in alphabetical order.
   <https://twitter.com/serayaeryn>, <https://www.npmjs.com/~serayaeryn>
 * [__Carlos Fuentes__](https://github.com/metcoder95),
   <https://twitter.com/metcoder95>, <https://www.npmjs.com/~metcoder95>
-* [__Rafael Gonzaga__](https://github.com/rafaelgss),
-  <https://twitter.com/_rafaelgss>, <https://www.npmjs.com/~rafaelgss>
 * [__Vincent Le Goff__](https://github.com/zekth)
 * [__Luciano Mammino__](https://github.com/lmammino),
   <https://twitter.com/loige>, <https://www.npmjs.com/~lmammino>
@@ -371,6 +369,8 @@ to join this group by Lead Maintainers.
   <https://twitter.com/NathanWoltman>, <https://www.npmjs.com/~nwoltman>
 * [__Ethan Arrowood__](https://github.com/Ethan-Arrowood/),
   <https://twitter.com/arrowoodtech>, <https://www.npmjs.com/~ethan_arrowood>
+* [__Rafael Gonzaga__](https://github.com/rafaelgss),
+  <https://twitter.com/_rafaelgss>, <https://www.npmjs.com/~rafaelgss>
 
 ## Hosted by
 

package/SPONSORS.md

@@ -14,6 +14,8 @@ _Be the first!_
 ## Tier 3
 
 - [Mercedes-Benz Group](https://github.com/mercedes-benz)
+- [Val Town, Inc.](https://opencollective.com/valtown)
+- [Handsontable - JavaScript Data Grid](https://handsontable.com/docs/react-data-grid/?utm_source=Fastify_GH&utm_medium=sponsorship&utm_campaign=library_sponsorship_2024)
 
 ## Tier 2
 

package/build/build-validation.js

@@ -32,7 +32,6 @@ const defaultInitOptions = {
   caseSensitive: true,
   allowUnsafeRegex: false,
   disableRequestLogging: false,
-  jsonShorthand: true,
   ignoreTrailingSlash: false,
   ignoreDuplicateSlashes: false,
   maxParamLength: 100,
@@ -94,7 +93,6 @@ const schema = {
       type: 'boolean',
       default: false
     },
-    jsonShorthand: { type: 'boolean', default: defaultInitOptions.jsonShorthand },
     maxParamLength: { type: 'integer', default: defaultInitOptions.maxParamLength },
     onProtoPoisoning: { type: 'string', default: defaultInitOptions.onProtoPoisoning },
     onConstructorPoisoning: { type: 'string', default: defaultInitOptions.onConstructorPoisoning },
@@ -104,16 +102,6 @@ const schema = {
     http2SessionTimeout: { type: 'integer', default: defaultInitOptions.http2SessionTimeout },
     exposeHeadRoutes: { type: 'boolean', default: defaultInitOptions.exposeHeadRoutes },
     useSemicolonDelimiter: { type: 'boolean', default: defaultInitOptions.useSemicolonDelimiter },
-    // deprecated style of passing the versioning constraint
-    versioning: {
-      type: 'object',
-      additionalProperties: true,
-      required: ['storage', 'deriveVersion'],
-      properties: {
-        storage: { },
-        deriveVersion: { }
-      }
-    },
     constraints: {
       type: 'object',
       additionalProperties: {
@@ -122,9 +110,9 @@ const schema = {
         additionalProperties: true,
         properties: {
           name: { type: 'string' },
-          storage: { },
-          validate: { },
-          deriveConstraint: { }
+          storage: {},
+          validate: {},
+          deriveConstraint: {}
         }
       }
     }

package/docs/Guides/Ecosystem.md

@@ -159,6 +159,8 @@ section.
 
 #### [Community](#community)
 
+- [`@aaroncadillac/crudify-mongo`](https://github.com/aaroncadillac/crudify-mongo)
+  A simple way to add a crud in your fastify project.
 - [`@applicazza/fastify-nextjs`](https://github.com/applicazza/fastify-nextjs)
   Alternate Fastify and Next.js integration.
 - [`@blastorg/fastify-aws-dynamodb-cache`](https://github.com/blastorg/fastify-aws-dynamodb-cache)
@@ -213,6 +215,8 @@ section.
   Fast sodium-based crypto for @mgcrea/fastify-session
 - [`@mgcrea/pino-pretty-compact`](https://github.com/mgcrea/pino-pretty-compact)
   A custom compact pino-base prettifier
+- [`@pybot/fastify-autoload`](https://github.com/kunal097/fastify-autoload)
+  Plugin to generate routes automatically with valid json content
 - [`@scalar/fastify-api-reference`](https://github.com/scalar/scalar/tree/main/packages/fastify-api-reference)
   Beautiful OpenAPI/Swagger API references for Fastify
 - [`@trubavuong/fastify-seaweedfs`](https://github.com/trubavuong/fastify-seaweedfs)

package/docs/Guides/Getting-Started.md

@@ -450,8 +450,6 @@ Data validation is extremely important and a core concept of the framework.
 To validate incoming requests, Fastify uses [JSON
 Schema](https://json-schema.org/).
 
-(JTD schemas are loosely supported, but `jsonShorthand` must be disabled first)
-
 Let's look at an example demonstrating validation for routes:
 ```js
 /**

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

@@ -6,6 +6,30 @@ Before migrating to v4, please ensure that you have fixed all deprecation
 warnings from v3. All v3 deprecations have been removed and they will no longer
 work after upgrading.
 
+## Codemods
+### Fastify v4 Codemods
+
+To help with the upgrade, we’ve worked with the team at codemod.com to
+publish codemods that will automatically update your code to many of 
+the new APIs and patterns in Fastify v4.
+Run the following codemods to automatically update your code for Fastify v4 migration:
+
+```
+npx codemod@latest fastify/4/migration-recipe
+```
+
+This will run the following codemods from the Fastify Codemod repository:
+
+- **fastify/4/remove-app-use**
+- **fastify/4/reply-raw-access**
+- **fastify/4/wrap-routes-plugin**
+- **fastify/4/await-register-calls**
+
+Each of these codemods automates the changes listed in the v4 migration guide.
+For a complete list of available Fastify codemods and further details, 
+see the [codemod registry](https://codemod.com/registry?q=fastify).
+
+
 ## Breaking Changes
 
 ### Error handling composition ([#3261](https://github.com/fastify/fastify/pull/3261))
@@ -55,11 +79,23 @@ If you need to use middleware, use
 continue to be maintained.
 However, it is strongly recommended that you migrate to Fastify's [hooks](../Reference/Hooks.md).
 
+> **Note**: Codemod remove `app.use()` with:
+>
+> ```bash
+> npx codemod@latest fastify/4/remove-app-use
+> ```
+
 ### `reply.res` moved to `reply.raw`
 
 If you previously used the `reply.res` attribute to access the underlying Request
 object you will now need to use `reply.raw`.
 
+> **Note**: Codemod `reply.res` to `reply.raw` with:
+>
+> ```bash
+> npx codemod@latest fastify/4/reply-raw-access
+> ```
+
 ### Need to `return reply` to signal a "fork" of the promise chain
 
 In some situations, like when a response is sent asynchronously or when you are
@@ -105,6 +141,11 @@ As a result, if you specify an `onRoute` hook in a plugin you should now either:
     done();
   });
   ```
+> **Note**: Codemod synchronous route definitions with:
+>
+> ```bash
+> npx codemod@latest fastify/4/wrap-routes-plugin
+> ```
 
 * use `await register(...)`
 
@@ -130,6 +171,13 @@ As a result, if you specify an `onRoute` hook in a plugin you should now either:
   });
   ```
 
+> **Note**: Codemod 'await register(...)' with:
+>
+> ```bash
+> npx codemod@latest fastify/4/await-register-calls
+> ```
+
+
 ### Optional URL parameters
 
 If you've already used any implicitly optional parameters, you'll get a 404

package/docs/Guides/Recommendations.md

@@ -212,17 +212,19 @@ server {
 # server group via port 3000.
 server {
   # This listen directive asks NGINX to accept requests
-  # coming to any address, port 443, with SSL, and HTTP/2
-  # if possible.
-  listen 443 ssl http2 default_server;
-  listen [::]:443 ssl http2 default_server;
+  # coming to any address, port 443, with SSL.
+  listen 443 ssl default_server;
+  listen [::]:443 ssl default_server;
 
   # With a server_name directive you can also ask NGINX to
   # use this server block only with matching server name(s)
-  # listen 443 ssl http2;
-  # listen [::]:443 ssl http2;
+  # listen 443 ssl;
+  # listen [::]:443 ssl;
   # server_name example.tld;
 
+  # Enable HTTP/2 support
+  http2 on;
+
   # Your SSL/TLS certificate (chain) and secret key in the PEM format
   ssl_certificate /path/to/fullchain.pem;
   ssl_certificate_key /path/to/private.pem;

package/docs/Reference/Errors.md

@@ -20,7 +20,6 @@
     - [FST_ERR_SCHEMA_ERROR_FORMATTER_NOT_FN](#fst_err_schema_error_formatter_not_fn)
     - [FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_OBJ](#fst_err_ajv_custom_options_opt_not_obj)
     - [FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_ARR](#fst_err_ajv_custom_options_opt_not_arr)
-    - [FST_ERR_VERSION_CONSTRAINT_NOT_STR](#fst_err_version_constraint_not_str)
     - [FST_ERR_CTP_ALREADY_PRESENT](#fst_err_ctp_already_present)
     - [FST_ERR_CTP_INVALID_TYPE](#fst_err_ctp_invalid_type)
     - [FST_ERR_CTP_EMPTY_TYPE](#fst_err_ctp_empty_type)
@@ -293,7 +292,6 @@ Below is a table with all the error codes that Fastify uses.
 | <a id="fst_err_schema_error_formatter_not_fn">FST_ERR_SCHEMA_ERROR_FORMATTER_NOT_FN</a> | SchemaErrorFormatter option wrongly specified. | SchemaErrorFormatter option should be a non async function. | [#4554](https://github.com/fastify/fastify/pull/4554) |
 | <a id="fst_err_ajv_custom_options_opt_not_obj">FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_OBJ</a> | ajv.customOptions wrongly specified. | ajv.customOptions option should be an object. | [#4554](https://github.com/fastify/fastify/pull/4554) |
 | <a id="fst_err_ajv_custom_options_opt_not_arr">FST_ERR_AJV_CUSTOM_OPTIONS_OPT_NOT_ARR</a> | ajv.plugins option wrongly specified. | ajv.plugins option should be an array. | [#4554](https://github.com/fastify/fastify/pull/4554) |
-| <a id="fst_err_version_constraint_not_str">FST_ERR_VERSION_CONSTRAINT_NOT_STR</a> | Version constraint wrongly specified. | Version constraint should be a string. | [#4554](https://github.com/fastify/fastify/pull/4554) |
 | <a id="fst_err_ctp_already_present">FST_ERR_CTP_ALREADY_PRESENT</a> | The parser for this content type was already registered. | Use a different content type or delete the already registered parser. | [#1168](https://github.com/fastify/fastify/pull/1168) |
 | <a id="fst_err_ctp_invalid_type">FST_ERR_CTP_INVALID_TYPE</a> | `Content-Type` wrongly specified | The `Content-Type` should be a string. | [#1168](https://github.com/fastify/fastify/pull/1168) |
 | <a id="fst_err_ctp_empty_type">FST_ERR_CTP_EMPTY_TYPE</a> | `Content-Type` is an empty string. | `Content-Type` cannot be an empty string. | [#1168](https://github.com/fastify/fastify/pull/1168) |

package/docs/Reference/Hooks.md

@@ -828,13 +828,6 @@ consider creating a custom [Plugin](./Plugins.md) instead.
 
 ## Diagnostics Channel Hooks
 
-> **Note:** The `diagnostics_channel` is currently experimental on Node.js, so
-> its API is subject to change even in semver-patch releases of Node.js. As some
-> versions of Node.js are supported by Fastify where `diagnostics_channel` is
-> unavailable, or with an incomplete feature set, the hook uses the
-> [dc-polyfill](https://www.npmjs.com/package/dc-polyfill) package to provide a
-> polyfill.
-
 One [`diagnostics_channel`](https://nodejs.org/api/diagnostics_channel.html)
 publish event, `'fastify.initialization'`, happens at initialization time. The
 Fastify instance is passed into the hook as a property of the object passed in.
@@ -848,7 +841,7 @@ tools first" fashion.
 
 ```js
 const tracer = /* retrieved from elsewhere in the package */
-const dc = require('node:diagnostics_channel') // or require('dc-polyfill')
+const dc = require('node:diagnostics_channel')
 const channel = dc.channel('fastify.initialization')
 const spans = new WeakMap()
 
@@ -867,6 +860,9 @@ channel.subscribe(function ({ fastify }) {
 })
 ```
 
+> **Note:** The TracingChannel class API is currently experimental and may undergo
+> breaking changes even in semver-patch releases of Node.js.
+
 Five other events are published on a per-request basis following the
 [Tracing Channel](https://nodejs.org/api/diagnostics_channel.html#class-tracingchannel)
 nomenclature. The list of the channel names and the event they receive is:
@@ -895,7 +891,7 @@ associated with the request's failure.
 These events can be received like so:
 
 ```js
-const dc = require('node:diagnostics_channel') // or require('dc-polyfill')
+const dc = require('node:diagnostics_channel')
 const channel = dc.channel('tracing:fastify.request.handler:start')
 channel.subscribe((msg) => {
   console.log(msg.request, msg.reply)

package/docs/Reference/Logging.md

@@ -140,7 +140,7 @@ const fastify = require('fastify')({
         return {
           method: request.method,
           url: request.url,
-          path: request.routerPath,
+          path: request.routeOptions.url,
           parameters: request.params,
           // Including the headers in the log could be in violation
           // of privacy laws, e.g. GDPR. You should use the "redact" option to

package/docs/Reference/Reply.md

@@ -92,7 +92,6 @@ since the request was received by Fastify.
   from Node core.
 - `.log` - The logger instance of the incoming request.
 - `.request` - The incoming request.
-- `.context` - Deprecated, access the [Request's context](./Request.md) property.
 
 ```js
 fastify.get('/', options, function (request, reply) {
@@ -104,14 +103,6 @@ fastify.get('/', options, function (request, reply) {
 })
 ```
 
-Additionally, `Reply` provides access to the context of the request:
-
-```js
-fastify.get('/', {config: {foo: 'bar'}}, function (request, reply) {
-  reply.send('handler config.foo = ' + reply.context.config.foo)
-})
-```
-
 ### .code(statusCode)
 <a id="code"></a>
 
@@ -700,8 +691,9 @@ As noted above, streams are considered to be pre-serialized, so they will be
 sent unmodified without response validation.
 
 ```js
+const fs = require('node:fs')
+
 fastify.get('/streams', function (request, reply) {
-  const fs = require('node:fs')
   const stream = fs.createReadStream('some-file', 'utf8')
   reply.header('Content-Type', 'application/octet-stream')
   reply.send(stream)
@@ -709,8 +701,9 @@ fastify.get('/streams', function (request, reply) {
 ```
 When using async-await you will need to return or await the reply object:
 ```js
+const fs = require('node:fs')
+
 fastify.get('/streams', async function (request, reply) {
-  const fs = require('node:fs')
   const stream = fs.createReadStream('some-file', 'utf8')
   reply.header('Content-Type', 'application/octet-stream')
   return reply.send(stream)
@@ -728,6 +721,7 @@ sent unmodified without response validation.
 
 ```js
 const fs = require('node:fs')
+
 fastify.get('/streams', function (request, reply) {
   fs.readFile('some-file', (err, fileBuffer) => {
     reply.send(err || fileBuffer)
@@ -738,6 +732,7 @@ fastify.get('/streams', function (request, reply) {
 When using async-await you will need to return or await the reply object:
 ```js
 const fs = require('node:fs')
+
 fastify.get('/streams', async function (request, reply) {
   fs.readFile('some-file', (err, fileBuffer) => {
     reply.send(err || fileBuffer)
@@ -757,6 +752,7 @@ will be sent unmodified without response validation.
 
 ```js
 const fs = require('node:fs')
+
 fastify.get('/streams', function (request, reply) {
   const typedArray = new Uint16Array(10)
   reply.send(typedArray)
@@ -773,6 +769,7 @@ 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')
@@ -797,6 +794,7 @@ 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)

package/docs/Reference/Request.md

@@ -31,23 +31,12 @@ Request is a core Fastify object containing the following fields:
 - `url` - the URL of the incoming request
 - `originalUrl` - similar to `url`, this allows you to access the 
   original `url` in case of internal re-routing 
-- `routerMethod` - Deprecated, use `request.routeOptions.method` instead. The
-  method defined for the router that is handling the request
-- `routerPath` - Deprecated, use `request.routeOptions.url` instead. The
-  path pattern defined for the router that is handling the request
 - `is404` - true if request is being handled by 404 handler, false if it is not
-- `connection` - Deprecated, use `socket` instead. The underlying connection of
-  the incoming request.
 - `socket` - the underlying connection of the incoming request
 - `context` - Deprecated, use `request.routeOptions.config` instead.
 A Fastify internal object. You should not use
 it directly or modify it. It is useful to access one special key:	
   - `context.config` - The route [`config`](./Routes.md#routes-config) object.
-- `routeSchema` - Deprecated, use `request.routeOptions.schema` instead. The
-  scheme definition set for the router that is handling the request
-- `routeConfig` - Deprecated, use `request.routeOptions.config` instead. The
-  route [`config`](./Routes.md#routes-config) 
-  object.
 - `routeOptions` - The route [`option`](./Routes.md#routes-options) object
   - `bodyLimit` - either server limit or route limit
   - `config` - the [`config`](./Routes.md#routes-config) object for this route

package/docs/Reference/Routes.md

@@ -32,10 +32,9 @@ fastify.route(options)
 ### Routes options
 <a id="options"></a>
 
-* `method`: currently it supports `'DELETE'`, `'GET'`, `'HEAD'`, `'PATCH'`,
-  `'POST'`, `'PUT'`, `'OPTIONS'`, `'SEARCH'`, `'TRACE'`, `'PROPFIND'`,
-  `'PROPPATCH'`, `'MKCOL'`, `'COPY'`, `'MOVE'`, `'LOCK'`, `'UNLOCK'`, 
-  `'REPORT'` and `'MKCALENDAR'`.
+* `method`: currently it supports `GET`, `HEAD`, `TRACE`, `DELETE`,
+  `OPTIONS`, `PATCH`, `PUT` and `POST`. To accept more methods,
+  the [`addHttpMethod`](./Server.md#addHttpMethod) must be used.
   It could also be an array of methods.
 * `url`: the path of the URL to match this route (alias: `path`).
 * `schema`: an object containing the schemas for the request and response. They
@@ -190,24 +189,6 @@ The above route declaration is more *Hapi*-like, but if you prefer an
 
 `fastify.patch(path, [options], handler)`
 
-`fastify.propfind(path, [options], handler)`
-
-`fastify.proppatch(path, [options], handler)`
-
-`fastify.mkcol(path, [options], handler)`
-
-`fastify.copy(path, [options], handler)`
-
-`fastify.move(path, [options], handler)`
-
-`fastify.lock(path, [options], handler)`
-
-`fastify.unlock(path, [options], handler)`
-
-`fastify.trace(path, [options], handler)`
-
-`fastify.search(path, [options], handler)`
-
 Example:
 ```js
 const opts = {
@@ -633,7 +614,7 @@ retrieve it in the handler.
 const fastify = require('fastify')()
 
 function handler (req, reply) {
-  reply.send(reply.context.config.output)
+  reply.send(reply.routeOptions.config.output)
 }
 
 fastify.get('/en', { config: { output: 'hello world!' } }, handler)

package/docs/Reference/Server.md

@@ -26,7 +26,6 @@ describes the properties available in that options object.
   - [`logger`](#logger)
   - [`disableRequestLogging`](#disablerequestlogging)
   - [`serverFactory`](#serverfactory)
-  - [`jsonShorthand`](#jsonshorthand)
   - [`caseSensitive`](#casesensitive)
   - [`allowUnsafeRegex`](#allowunsaferegex)
   - [`requestIdHeader`](#requestidheader)
@@ -68,6 +67,7 @@ describes the properties available in that options object.
     - [log](#log)
     - [version](#version)
     - [inject](#inject)
+    - [addHttpMethod](#addHttpMethod)
     - [addSchema](#addschema)
     - [getSchemas](#getschemas)
     - [getSchema](#getschema)
@@ -270,6 +270,8 @@ fastify.get('///foo//bar//', function (req, reply) {
 ### `maxParamLength`
 <a id="factory-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
@@ -440,45 +442,6 @@ 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.
 
-
-### `jsonShorthand`
-<a id="schema-json-shorthand"></a>
-
-+ Default: `true`
-
-By default, Fastify will automatically infer the root properties
-of JSON Schemas if it does not find valid root properties according to the JSON
-Schema spec. If you wish to implement your own schema validation compiler, to 
-parse schemas as JTD instead of JSON Schema for example, then you can explicitly
-set this option to `false` to make sure the schemas you receive are unmodified
-and are not being treated internally as JSON Schema.
-
-Fastify does not throw on invalid schemas so if this option is set to `false`
-in an existing project, check that none of your existing schemas become
-invalid as a result, as they will be treated as catch-alls.
-
-```js
-const AjvJTD = require('ajv/dist/jtd'/* only valid for AJV v7+ */)
-const ajv = new AjvJTD({
-  // This would let you throw at start for invalid JTD schema objects
-  allErrors: process.env.NODE_ENV === 'development'
-})
-const fastify = Fastify({ jsonShorthand: false })
-fastify.setValidatorCompiler(({ schema }) => {
-  return ajv.compile(schema)
-})
-fastify.post('/', {
-  schema: {
-    body: {
-      properties: {
-        foo: { type: 'uint8' }
-      }
-    }
-  },
-  handler (req, reply) { reply.send({ ok: 1 }) }
-})
-```
-
 ### `caseSensitive`
 <a id="factory-case-sensitive"></a>
 
@@ -1305,6 +1268,33 @@ used by plugins.
 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` and `POST` 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).
+
+```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
+})
+```
+
+
 #### addSchema
 <a id="add-schema"></a>
 

package/docs/Reference/Type-Providers.md

@@ -154,8 +154,8 @@ fastify.register(pluginWithJsonSchema)
 fastify.register(pluginWithTypebox)
 ```
 
-It's also important to mention that once the types don't propagate globally,
-_currently_ is not possible to avoid multiple registrations on routes when
+It's also important to mention that since the types don't propagate globally,
+_currently_ it is not possible to avoid multiple registrations on routes when
 dealing with several scopes, see below:
 
 ```ts

package/docs/Reference/TypeScript.md

@@ -210,24 +210,23 @@ And a `zod` wrapper by a third party called [`fastify-type-provider-zod`](https:
 They simplify schema validation setup and you can read more about them in [Type
 Providers](./Type-Providers.md) page.
 
-Below is how to setup schema validation using _vanilla_ `typebox` and
-`json-schema-to-ts` packages.
+Below is how to setup schema validation using the `typebox`,
+`json-schema-to-typescript`, and `json-schema-to-ts` packages without type
+providers.
 
 #### TypeBox
 
-A useful library for building types and a schema at once is
-[TypeBox](https://www.npmjs.com/package/@sinclair/typebox) along with 
-[fastify-type-provider-typebox](https://github.com/fastify/fastify-type-provider-typebox).
-With TypeBox you define your schema within your code and use them
-directly as types or schemas as you need them.
+A useful library for building types and a schema at once is [TypeBox](https://www.npmjs.com/package/@sinclair/typebox).
+With TypeBox you define your schema within your code and use them directly as
+types or schemas as you need them.
 
 When you want to use it for validation of some payload in a fastify route you
 can do it as follows:
 
-1. Install `typebox` and `fastify-type-provider-typebox` in your project.
+1. Install `typebox` in your project.
 
     ```bash
-    npm i @sinclair/typebox @fastify/type-provider-typebox
+    npm i @sinclair/typebox
     ```
 
 2. Define the schema you need with `Type` and create the respective type  with
@@ -248,10 +247,9 @@ can do it as follows:
 
     ```typescript
     import Fastify from 'fastify'
-    import { TypeBoxTypeProvider } from '@fastify/type-provider-typebox'
     // ...
 
-    const fastify = Fastify().withTypeProvider<TypeBoxTypeProvider>()
+    const fastify = Fastify()
 
     fastify.post<{ Body: UserType, Reply: UserType }>(
       '/',
@@ -271,12 +269,12 @@ can do it as follows:
     )
     ```
 
-#### Schemas in JSON Files
+#### json-schema-to-typescript
 
-In the last example we used interfaces to define the types for the request
-querystring and headers. Many users will already be using JSON Schemas to define
-these properties, and luckily there is a way to transform existing JSON Schemas
-into TypeScript interfaces!
+In the last example we used Typebox to define the types and schemas for our
+route. Many users will already be using JSON Schemas to define these properties,
+and luckily there is a way to transform existing JSON Schemas into TypeScript
+interfaces!
 
 1. If you did not complete the 'Getting Started' example, go back and follow
    steps 1-4 first.
@@ -596,7 +594,7 @@ your plugin.
    }
 
    module.exports = fp(myPlugin, {
-     fastify: '3.x',
+     fastify: '5.x',
      name: 'my-plugin' // this is used by fastify-plugin to derive the property name
    })
    ```
@@ -1137,7 +1135,7 @@ RawRequestDefaultExpression<http2.Http2Server> // -> http2.Http2ServerRequest
 
 #### Reply
 
-##### fastify.FastifyReply< [RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>
+##### fastify.FastifyReply<[RequestGeneric][FastifyRequestGenericInterface], [RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [ContextConfig][ContextConfigGeneric]>
 [src](https://github.com/fastify/fastify/blob/main/types/reply.d.ts#L32)
 
 This interface contains the custom properties that Fastify adds to the standard