fastify 3.4.1 → 3.7.0

package/docs/ContentTypeParser.md

@@ -28,6 +28,9 @@ fastify.addContentTypeParser('application/jsoff', async function (request, paylo
 
   return res
 })
+
+// Can use default JSON/Text parser for different content Types
+fastify.addContentTypeParser('text/json', { parseAs: 'string' }, fastify.getDefaultJsonParser('ignore', 'ignore'))
 ```
 
 You can also use the `hasContentTypeParser` API to find if a specific content type parser already exists.

package/docs/Decorators.md

@@ -55,6 +55,8 @@ fastify.get('/', (req, reply) => {
 })
 ```
 
+Note that it is important to keep initial shape of decorated field as close as possible to the value intended to be set dynamically in the future. Initialize a decorator as a `''` if the intended value is a string, and as `null` if it will be an object or a function.
+
 See
 [JavaScript engine fundamentals: Shapes and Inline Caches](https://web.archive.org/web/20200201163000/https://mathiasbynens.be/notes/shapes-ics)
 for more information on this topic.

package/docs/Ecosystem.md

@@ -17,6 +17,7 @@ Plugins maintained by the fastify team are listed under [Core](#core) while plug
 - [`fastify-compress`](https://github.com/fastify/fastify-compress) Fastify compression utils.
 - [`fastify-cookie`](https://github.com/fastify/fastify-cookie) Parse and set cookie headers.
 - [`fastify-cors`](https://github.com/fastify/fastify-cors) Enables the use of CORS in a Fastify application.
+- [`fastify-csrf`](https://github.com/fastify/fastify-csrf) A plugin for adding [CSRF](https://en.wikipedia.org/wiki/Cross-site_request_forgery) protection to Fastify.
 - [`fastify-elasticsearch`](https://github.com/fastify/fastify-elasticsearch) Plugin to share the same ES client.
 - [`fastify-env`](https://github.com/fastify/fastify-env) Load and check configuration.
 - [`fastify-etag`](https://github.com/fastify/fastify-etag) Automatically generate etags for HTTP responses.
@@ -65,7 +66,6 @@ Plugins maintained by the fastify team are listed under [Core](#core) while plug
 - [`fastify-cloudevents`](https://github.com/smartiniOnGitHub/fastify-cloudevents) Fastify plugin to generate and forward Fastify events in the Cloudevents format.
 - [`fastify-cockroachdb`](https://github.com/alex-ppg/fastify-cockroachdb) Fastify plugin to connect to a CockroachDB PostgreSQL instance via the Sequelize ORM.
 - [`fastify-couchdb`](https://github.com/nigelhanlon/fastify-couchdb) Fastify plugin to add CouchDB support via [nano](https://github.com/apache/nano).
-- [`fastify-csrf`](https://github.com/Tarang11/fastify-csrf) A csrf plugin for Fastify.
 - [`fastify-decorators`](https://github.com/L2jLiga/fastify-decorators) Fastify plugin that provides the set of TypeScript decorators.
 - [`fastify-dynamodb`](https://github.com/matrus2/fastify-dynamodb) AWS DynamoDB plugin for Fastify. It exposes [AWS.DynamoDB.DocumentClient()](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html) object.
 - [`fastify-dynareg`](https://github.com/greguz/fastify-dynareg) Dynamic plugin register for Fastify.
@@ -128,6 +128,7 @@ Plugins maintained by the fastify team are listed under [Core](#core) while plug
 - [`fastify-rbac`](https://gitlab.com/m03geek/fastify-rbac) Fastify role-based access control plugin.
 - [`fastify-register-routes`](https://github.com/israeleriston/fastify-register-routes) Plugin to automatically load routes from a specified path and optionally limit loaded file names by a regular expression.
 - [`fastify-response-time`](https://github.com/lolo32/fastify-response-time) Add `X-Response-Time` header at each request for Fastify, in milliseconds.
+- [`fastify-response-caching`](https://github.com/codeaholicguy/fastify-response-caching) A Fastify plugin for caching the response.
 - [`fastify-reverse-routes`](https://github.com/dimonnwc3/fastify-reverse-routes) Fastify reverse routes plugin, allows to defined named routes and build path using name and parameters.
 - [`fastify-rob-config`](https://github.com/jeromemacias/fastify-rob-config) Fastify Rob-Config integration.
 - [`fastify-schema-constraint`](https://github.com/Eomm/fastify-schema-constraint) Choose the JSON schema to use based on request parameters.

package/docs/Lifecycle.md

@@ -10,7 +10,7 @@ Incoming Request
         │
         └─▶ Instance Logger
              │
-       404 ◀─┴─▶ onRequest Hook
+   4**/5** ◀─┴─▶ onRequest Hook
                   │
         4**/5** ◀─┴─▶ preParsing Hook
                         │
@@ -20,7 +20,7 @@ Incoming Request
                                   │
                             415 ◀─┴─▶ Validation
                                         │
-                                  400 ◀─┴─▶ preHandler Hook
+                              4**/5** ◀─┴─▶ preHandler Hook
                                               │
                                     4**/5** ◀─┴─▶ User Handler
                                                     │

package/docs/Logging.md

@@ -159,7 +159,7 @@ const fastify = Fastify({
           headers: request.headers,
           hostname: request.hostname,
           remoteAddress: request.ip,
-          remotePort: request.connection.remotePort
+          remotePort: request.socket.remotePort
         }
       }
     }

package/docs/Reply.md

@@ -15,6 +15,7 @@
   - [.callNotFound()](#callnotfound)
   - [.getResponseTime()](#getresponsetime)
   - [.type(contentType)](#typecontenttype)
+  - [.raw](#raw)
   - [.serializer(func)](#serializerfunc)
   - [.sent](#sent)
   - [.send(data)](#senddata)
@@ -207,6 +208,23 @@ reply
 
 See [`.send()`](#send) for more information on sending different types of values.
 
+<a name="raw"></a>
+### .raw
+This is the [`http.ServerResponse`](https://nodejs.org/dist/latest/docs/api/http.html#http_class_http_serverresponse) from Node core. While you're using the fastify `Reply` object, the use of `Reply.raw` functions is at your own risk as you're skipping all the fastify
+logic of handling the http response. eg:
+
+```js
+app.get('/cookie-2', (req, reply) => {
+  reply.setCookie('session', 'value', { secure: false }) // this will not be used
+
+  // in this case we are using only the nodejs http server response object
+  reply.raw.writeHead(200, { 'Content-Type': 'text/plain' })
+  reply.raw.write('ok')
+  reply.raw.end()
+})
+```
+Another example of the misuse of `Reply.raw` is explained in [Reply.md#getheaders](Reply.md#getheaders).
+
 <a name="sent"></a>
 ### .sent
 

package/docs/Request.md

@@ -14,12 +14,15 @@ Request is a core Fastify object containing the following fields:
 - `ip` - the IP address of the incoming request
 - `ips` - an array of the IP addresses in the `X-Forwarded-For` header of the incoming request (only when the [`trustProxy`](Server.md#factory-trust-proxy) option is enabled)
 - `hostname` - the hostname of the incoming request
+- `protocol` - the protocol of the incoming request (`https` or `http`)
 - `method` - the method of the incoming request
 - `url` - the url of the incoming request
 - `routerMethod` - the method defined for the router that is handling the request
 - `routerPath` - 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` - the underlying connection of the incoming request
+- `connection` - Deprecated, use `socket` instead. The underlying connection of the incoming request.
+- `socket` - the underlying connection of the incoming request
+
 
 ```js
 fastify.post('/:params', options, function (request, reply) {
@@ -32,6 +35,7 @@ fastify.post('/:params', options, function (request, reply) {
   console.log(request.ip)
   console.log(request.ips)
   console.log(request.hostname)
+  console.log(request.protocol)
   request.log.info('some info')
 })
 ```

package/docs/Routes.md

@@ -51,7 +51,7 @@ They need to be in
 * `onSend(request, reply, payload, done)`: a [function](Hooks.md#route-hooks) called right before a response is sent, it could also be an array of functions.
 * `onResponse(request, reply, done)`: a [function](Hooks.md#onresponse) called when a response has been sent, so you will not be able to send more data to the client. It could also be an array of functions.
 * `handler(request, reply)`: the function that will handle this request. The [Fastify server](Server.md) will be bound to `this` when the handler is called. Note: using an arrow function will break the binding of `this`.
-* `errorHandler(error, request, reply)`: a custom error handler for the scope of the request. Overrides the default error global handler, and anything set by [`setErrorHandler`](Server.md#setErrorHandler), for requests to the route.
+* `errorHandler(error, request, reply)`: a custom error handler for the scope of the request. Overrides the default error global handler, and anything set by [`setErrorHandler`](Server.md#setErrorHandler), for requests to the route. To access the default handler, you can access `instance.errorHandler`. Note that this will point to fastify's default `errorHandler` only if a plugin hasn't overridden it already.
 * `validatorCompiler({ schema, method, url, httpPart })`: function that builds schemas for request validations. See the [Validation and Serialization](Validation-and-Serialization.md#schema-validator) documentation.
 * `serializerCompiler({ { schema, method, url, httpStatus } })`: function that builds schemas for response serialization. See the [Validation and Serialization](Validation-and-Serialization.md#schema-serializer) documentation.
 * `schemaErrorFormatter(errors, dataVar)`: function that formats the errors from the validation compiler. See the [Validation and Serialization](Validation-and-Serialization.md#error-handling) documentation. Overrides the global schema error formatter handler, and anything set by `setSchemaErrorFormatter`, for requests to the route.
@@ -360,7 +360,7 @@ const fastify = Fastify({
           headers: req.headers,
           hostname: req.hostname,
           remoteAddress: req.ip,
-          remotePort: req.connection.remotePort
+          remotePort: req.socket.remotePort
         }
       }
     }

package/docs/Server.md

@@ -293,13 +293,14 @@ const fastify = Fastify({ trustProxy: true })
 
 For more examples refer to [proxy-addr](https://www.npmjs.com/package/proxy-addr) package.
 
-You may access the `ip`, `ips`, and `hostname` values on the [`request`](Request.md) object.
+You may access the `ip`, `ips`, `hostname` and `protocol` values on the [`request`](Request.md) object.
 
 ```js
 fastify.get('/', (request, reply) => {
   console.log(request.ip)
   console.log(request.ips)
   console.log(request.hostname)
+  console.log(request.protocol)
 })
 ```
 
@@ -478,7 +479,7 @@ const fastify = require('fastify')({
 <a name="rewrite-url"></a>
 ### `rewriteUrl`
 
-Set a sync callback function that must return a string that allows rewriting urls. 
+Set a sync callback function that must return a string that allows rewriting urls.
 
 > Rewriting a url will modify the `url` property of the `req` object
 
@@ -742,6 +743,10 @@ Important: If you have to deal with nested plugins the name differs with the usa
 #### log
 The logger instance, check [here](Logging.md).
 
+<a name="version"></a>
+#### version
+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.
+
 <a name="inject"></a>
 #### inject
 Fake http injection (for testing purposes) [here](Testing.md#inject).
@@ -833,17 +838,19 @@ fastify.register(function (instance, options, done) {
 <a name="set-error-handler"></a>
 #### setErrorHandler
 
-`fastify.setErrorHandler(handler(error, request, reply))`: Set a function that will be called whenever an error happens. The handler is fully encapsulated, so different plugins can set different error handlers. *async-await* is supported as well.<br>
+`fastify.setErrorHandler(handler(error, request, reply))`: Set a function that will be called whenever an error happens. 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.<br>
 *Note: If the error `statusCode` is less than 400, Fastify will automatically set it at 500 before calling the error handler.*
 
 ```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 and that logs the error with respect to its `statusCode`:
+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
 var statusCode = error.statusCode
@@ -876,6 +883,50 @@ fastify.ready(() => {
 })
 ```
 
+<a name="addContentTypeParser"></a>
+#### addContentTypeParser
+
+`fastify.addContentTypeParser(content-type, options, parser)` is used to pass 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 or string array.
+
+```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 <a href="https://github.com/fastify/secure-json-parse#api">`secure-json-parse` documentation</a> for more information.
+
+fastify.addContentTypeParser('text/json', { asString: true }, fastify.getDefaultJsonParser('ignore', 'ignore'))
+```
+
+<a name="getDefaultJsonParser"></a>
+#### getDefaultJsonParser
+
+`fastify.getDefaultJsonParser(onProtoPoisoning, onConstructorPoisoning)` takes two arguments. First argument is ProtoType poisoning configuration and second argument is constructor poisoning configuration. See the <a href="https://github.com/fastify/secure-json-parse#api">`secure-json-parse` documentation</a> for more information.
+
+
+<a name="defaultTextParser"></a>
+#### defaultTextParser
+
+`fastify.defaultTextParser()` can be used to parse content as plain text.
+
+```js
+fastify.addContentTypeParser('text/json', { asString: true }, fastify.defaultTextParser())
+```
+
+<a name="errorHandler"></a>
+#### errorHandler
+
+`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, response)
+  }
+}, handler)
+```
+
 <a name="initial-config"></a>
 #### initialConfig
 

package/docs/TypeScript.md

@@ -10,6 +10,7 @@ The type system was changed in Fastify version 3. The new type system introduces
 
 > Plugins may or may not include typings. See [Plugins](#plugins) for more information. We encourage users to send pull requests to improve typings support.
 
+🚨 Don't foget to install `@types/node`
 
 ## Learn By Example
 
@@ -243,7 +244,7 @@ One of Fastify's most distinguishable features is its extensive plugin ecosystem
   ```bash
   npm init -y
   npm i fastify fastify-plugin
-  npm i -D typescript
+  npm i -D typescript @types/node
   ```
 2. Add a `build` script to the `"scripts"` section and `'index.d.ts'` to the `"types"` section of the `package.json` file:
   ```json

package/docs/Validation-and-Serialization.md

@@ -163,13 +163,19 @@ const bodyJsonSchema = {
 }
 
 const queryStringJsonSchema = {
-  name: { type: 'string' },
-  excitement: { type: 'integer' }
+  type: 'object',
+  properties: {
+    name: { type: 'string' },
+    excitement: { type: 'integer' }
+  }
 }
 
 const paramsJsonSchema = {
-  par1: { type: 'string' },
-  par2: { type: 'number' }
+  type: 'object',
+  properties: {
+    par1: { type: 'string' },
+    par2: { type: 'number' }
+  }
 }
 
 const headersJsonSchema = {
@@ -198,7 +204,7 @@ fastify.post('/the/url', { schema }, handler)
 
 You can provide a list of plugins you want to use with Ajv:
 
-> Refer to [`ajv options`](Server.md#factory-ajv) to check plugins format
+> Refer to [`ajv options`](Server.md#ajv) to check plugins format
 
 ```js
 const fastify = require('fastify')({

package/examples/simple.mjs

@@ -0,0 +1,27 @@
+// works on Node v14.13.0+
+import { fastify } from '../fastify.js'
+
+const app = fastify({
+  logger: false
+})
+
+const schema = {
+  schema: {
+    response: {
+      200: {
+        type: 'object',
+        properties: {
+          hello: {
+            type: 'string'
+          }
+        }
+      }
+    }
+  }
+}
+
+app.get('/', schema, async function (req, reply) {
+  return { hello: 'world' }
+})
+
+app.listen(3000).catch(console.error)

package/fastify.js

@@ -4,6 +4,8 @@ const Avvio = require('avvio')
 const http = require('http')
 const querystring = require('querystring')
 let lightMyRequest
+let version
+let versionLoaded = false
 
 const {
   kAvvioBoot,
@@ -24,7 +26,8 @@ const {
   kState,
   kOptions,
   kPluginNameChain,
-  kSchemaErrorFormatter
+  kSchemaErrorFormatter,
+  kErrorHandler
 } = require('./lib/symbols.js')
 
 const { createServer } = require('./lib/server')
@@ -56,6 +59,21 @@ const onBadUrlContext = {
   onError: []
 }
 
+function defaultErrorHandler (error, request, reply) {
+  if (reply.statusCode >= 500) {
+    reply.log.error(
+      { req: request, res: reply, err: error },
+      error && error.message
+    )
+  } else if (reply.statusCode >= 400) {
+    reply.log.info(
+      { res: reply, err: error },
+      error && error.message
+    )
+  }
+  reply.send(error)
+}
+
 function fastify (options) {
   // Options validations
   options = options || {}
@@ -159,6 +177,7 @@ function fastify (options) {
     [kSchemas]: schemas,
     [kValidatorCompiler]: null,
     [kSchemaErrorFormatter]: options.schemaErrorFormatter,
+    [kErrorHandler]: defaultErrorHandler,
     [kSerializerCompiler]: null,
     [kReplySerializerDefault]: null,
     [kContentTypeParser]: new ContentTypeParser(
@@ -218,6 +237,8 @@ function fastify (options) {
     // custom parsers
     addContentTypeParser: ContentTypeParser.helpers.addContentTypeParser,
     hasContentTypeParser: ContentTypeParser.helpers.hasContentTypeParser,
+    getDefaultJsonParser: ContentTypeParser.defaultParsers.getDefaultJsonParser,
+    defaultTextParser: ContentTypeParser.defaultParsers.defaultTextParser,
     // Fastify architecture methods (initialized by Avvio)
     register: null,
     after: null,
@@ -255,13 +276,26 @@ function fastify (options) {
       }
     },
     prefix: {
-      get: function () { return this[kRoutePrefix] }
+      get () { return this[kRoutePrefix] }
     },
     validatorCompiler: {
-      get: function () { return this[kValidatorCompiler] }
+      get () { return this[kValidatorCompiler] }
     },
     serializerCompiler: {
-      get: function () { return this[kSerializerCompiler] }
+      get () { return this[kSerializerCompiler] }
+    },
+    version: {
+      get () {
+        if (versionLoaded === false) {
+          version = loadVersion()
+        }
+        return version
+      }
+    },
+    errorHandler: {
+      get () {
+        return this[kErrorHandler]
+      }
     }
   })
 
@@ -549,7 +583,7 @@ function fastify (options) {
   function setErrorHandler (func) {
     throwIfAlreadyStarted('Cannot call "setErrorHandler" when fastify instance is already started!')
 
-    this._errorHandler = func
+    this[kErrorHandler] = func.bind(this)
     return this
   }
 }
@@ -581,6 +615,20 @@ function wrapRouting (httpHandler, { rewriteUrl, logger }) {
   }
 }
 
+function loadVersion () {
+  versionLoaded = true
+  const fs = require('fs')
+  const path = require('path')
+  try {
+    const pkgPath = path.join(__dirname, 'package.json')
+    fs.accessSync(pkgPath, fs.constants.R_OK)
+    const pkg = JSON.parse(fs.readFileSync(pkgPath))
+    return pkg.name === 'fastify' ? pkg.version : undefined
+  } catch (e) {
+    return undefined
+  }
+}
+
 /**
  * These export configurations enable JS and TS developers
  * to consumer fastify in whatever way best suits their needs.
@@ -592,6 +640,6 @@ function wrapRouting (httpHandler, { rewriteUrl, logger }) {
  * - `import fastify from 'fastify'`
  * - `import fastify, { TSC_definition } from 'fastify'`
  */
-fastify.fastify = fastify
-fastify.default = fastify
 module.exports = fastify
+module.exports.fastify = fastify
+module.exports.default = fastify

package/lib/contentTypeParser.js

@@ -279,4 +279,8 @@ module.exports.helpers = {
   addContentTypeParser,
   hasContentTypeParser
 }
+module.exports.defaultParsers = {
+  getDefaultJsonParser,
+  defaultTextParser: defaultPlainTextParser
+}
 module.exports[kTestInternals] = { rawBody }

package/lib/context.js

@@ -17,7 +17,7 @@ function Context (schema, handler, Reply, Request, contentTypeParser, config, er
   this.preHandler = null
   this.onResponse = null
   this.config = config
-  this.errorHandler = errorHandler || defaultErrorHandler
+  this.errorHandler = errorHandler
   this._middie = null
   this._parserOptions = { limit: bodyLimit || null }
   this.logLevel = logLevel
@@ -28,21 +28,6 @@ function Context (schema, handler, Reply, Request, contentTypeParser, config, er
   this.schemaErrorFormatter = schemaErrorFormatter || defaultSchemaErrorFormatter
 }
 
-function defaultErrorHandler (error, request, reply) {
-  if (reply.statusCode >= 500) {
-    reply.log.error(
-      { req: request, res: reply, err: error },
-      error && error.message
-    )
-  } else if (reply.statusCode >= 400) {
-    reply.log.info(
-      { res: reply, err: error },
-      error && error.message
-    )
-  }
-  reply.send(error)
-}
-
 function defaultSchemaErrorFormatter (errors, dataVar) {
   var text = ''
   var separator = ', '

package/lib/errors.js

@@ -171,8 +171,8 @@ const codes = {
   /**
    * wrapThenable
    */
-  FST_ERR_PROMISE_NOT_FULLFILLED: createError(
-    'FST_ERR_PROMISE_NOT_FULLFILLED',
+  FST_ERR_PROMISE_NOT_FULFILLED: createError(
+    'FST_ERR_PROMISE_NOT_FULFILLED',
     "Promise may not be fulfilled with 'undefined' when statusCode is not 204"
   ),
 
@@ -211,6 +211,14 @@ const codes = {
   FST_ERR_REOPENED_SERVER: createError(
     'FST_ERR_REOPENED_SERVER',
     'Fastify is already listening'
+  ),
+
+  /**
+   * plugin
+   */
+  FST_ERR_PLUGIN_VERSION_MISMATCH: createError(
+    'FST_ERR_PLUGIN_VERSION_MISMATCH',
+    "fastify-plugin: %s - expected '%s' fastify version, '%s' is installed"
   )
 }
 

package/lib/fourOhFour.js

@@ -15,7 +15,8 @@ const {
   kBodyLimit,
   kLogLevel,
   kFourOhFourContext,
-  kHooks
+  kHooks,
+  kErrorHandler
 } = require('./symbols.js')
 const { lifecycleHooks } = require('./hooks')
 const fourOhFourContext = {
@@ -28,7 +29,7 @@ const fourOhFourContext = {
 /**
  * Each fastify instance have a:
  * kFourOhFourLevelInstance: point to a fastify instance that has the 404 handler setted
- * kCanSetNotFoundHandler: bool to track if the 404 handler has alredy been set
+ * kCanSetNotFoundHandler: bool to track if the 404 handler has already been set
  * kFourOhFour: the singleton instance of this 404 module
  * kFourOhFourContext: the context in the reply object where the handler will be executed
  */
@@ -124,7 +125,7 @@ function fourOhFour (options) {
       this[kRequest],
       this[kContentTypeParser],
       opts.config || {},
-      this._errorHandler,
+      this[kErrorHandler],
       this[kBodyLimit],
       this[kLogLevel]
     )

package/lib/logger.js

@@ -53,7 +53,7 @@ const serializers = {
       version: req.headers['accept-version'],
       hostname: req.hostname,
       remoteAddress: req.ip,
-      remotePort: req.connection.remotePort
+      remotePort: req.socket.remotePort
     }
   },
   err: pino.stdSerializers.err,

package/lib/pluginUtils.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const semver = require('semver')
 const assert = require('assert')
 const registeredPlugins = Symbol.for('registered-plugin')
 const {
@@ -7,6 +8,7 @@ const {
   kRequest,
   kTestInternals
 } = require('./symbols.js')
+const { FST_ERR_PLUGIN_VERSION_MISMATCH } = require('./errors')
 
 function getMeta (fn) {
   return fn[Symbol.for('plugin-meta')]
@@ -84,6 +86,16 @@ function _checkDecorators (instance, decorators) {
   })
 }
 
+function checkVersion (fn) {
+  const meta = getMeta(fn)
+  if (!meta) return
+
+  const requiredVersion = meta.fastify
+  if (!requiredVersion) return
+
+  if (!semver.satisfies(this.version, requiredVersion)) throw new FST_ERR_PLUGIN_VERSION_MISMATCH(meta.name, requiredVersion, this.version)
+}
+
 function registerPluginName (fn) {
   const meta = getMeta(fn)
   if (!meta) return
@@ -95,6 +107,9 @@ function registerPluginName (fn) {
 
 function registerPlugin (fn) {
   registerPluginName.call(this, fn)
+  if (this.version !== undefined) {
+    checkVersion.call(this, fn)
+  }
   checkDecorators.call(this, fn)
   checkDependencies.call(this, fn)
   return shouldSkipOverride(fn)

package/lib/reply.js

@@ -303,9 +303,9 @@ Reply.prototype.getResponseTime = function () {
 // - https://github.com/fastify/fastify/issues/1864 for the discussions
 // - https://promisesaplus.com/ for the definition of thenable
 // - https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Promise/then for the signature
-Reply.prototype.then = function (fullfilled, rejected) {
+Reply.prototype.then = function (fulfilled, rejected) {
   if (this.sent) {
-    fullfilled()
+    fulfilled()
     return
   }
 
@@ -317,7 +317,7 @@ Reply.prototype.then = function (fullfilled, rejected) {
         rejected(err)
       }
     } else {
-      fullfilled()
+      fulfilled()
     }
   })
 }