fastify 4.28.1 → 4.29.0

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/docs/Guides/Migration-Guide-V4.md

@@ -6,6 +6,34 @@ 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](https://github.com/codemod-com/codemod) to
+publish codemods that will automatically update your code to many of 
+the new APIs and patterns in Fastify v4.
+
+Run the following 
+[migration recipe](https://go.codemod.com/fastify-4-migration-recipe) to 
+automatically update your code to Fastify v4:
+
+```
+npx codemod@latest fastify/4/migration-recipe
+```
+
+This will run the following codemods:
+
+- [`fastify/4/remove-app-use`](https://go.codemod.com/fastify-4-remove-app-use)
+- [`fastify/4/reply-raw-access`](https://go.codemod.com/fastify-4-reply-raw-access)
+- [`fastify/4/wrap-routes-plugin`](https://go.codemod.com/fastify-4-wrap-routes-plugin)
+- [`fastify/4/await-register-calls`](https://go.codemod.com/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 [Codemod Registry](https://go.codemod.com/fastify).
+
+
 ## Breaking Changes
 
 ### Error handling composition ([#3261](https://github.com/fastify/fastify/pull/3261))
@@ -55,11 +83,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 +145,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 +175,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/Reference/Routes.md

@@ -43,7 +43,8 @@ fastify.route(options)
   [here](./Validation-and-Serialization.md) for more info.
 
   * `body`: validates the body of the request if it is a POST, PUT, PATCH,
-    TRACE, SEARCH, PROPFIND, PROPPATCH or LOCK method.
+    TRACE, SEARCH, PROPFIND, PROPPATCH, COPY, MOVE, MKCOL, REPORT, MKCALENDAR
+    or LOCK method.
   * `querystring` or `query`: validates the querystring. This can be a complete
     JSON Schema object, with the property `type` of `object` and `properties`
     object of parameters, or simply the values of what would be contained in the

package/docs/Reference/Server.md

@@ -272,6 +272,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

package/docs/Reference/Validation-and-Serialization.md

@@ -235,6 +235,28 @@ const schema = {
 fastify.post('/the/url', { schema }, handler)
 ```
 
+For `body` schema, it is further possible to differentiate the schema per content
+type by nesting the schemas inside `content` property. The schema validation
+will be applied based on the `Content-Type` header in the request.
+
+```js
+fastify.post('/the/url', {
+  schema: {
+    body: {
+      content: {
+        'application/json': {
+          schema: { type: 'object' }
+        },
+        'text/plain': {
+          schema: { type: 'string' }
+        }
+        // Other content types will not be validated
+      }
+    }
+  }
+}, handler)
+```
+
 *Note that Ajv will try to [coerce](https://ajv.js.org/coercion.html) the values
 to the types specified in your schema `type` keywords, both to pass the
 validation and to use the correctly typed data afterwards.*

package/docs/Reference/Warnings.md

@@ -25,6 +25,7 @@
     - [FSTDEP019](#FSTDEP019)
     - [FSTDEP020](#FSTDEP020)
     - [FSTDEP021](#FSTDEP021)
+    - [FSTDEP022](#FSTDEP022)
 
 
 ## Warnings
@@ -92,3 +93,4 @@ Deprecation codes are further supported by the Node.js CLI options:
 | <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) |
 | <a id="FSTDEP021">FSTDEP021</a> | The `reply.redirect()` method has a new signature: `reply.redirect(url: string, code?: number)`. It will be enforced in `fastify@v5`'. | [#5483](https://github.com/fastify/fastify/pull/5483) |
+| <a id="FSTDEP022">FSTDEP022</a> | You are using the deprecated json shorthand schema on route %s. Specify full object schema instead. It will be removed in `fastify@v5` | [#5483](https://github.com/fastify/fastify/pull/0000) |

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.28.1'
+const VERSION = '4.29.0'
 
 const Avvio = require('avvio')
 const http = require('node:http')
@@ -671,7 +671,7 @@ function fastify (options) {
     }
 
     if (name === 'onClose') {
-      this.onClose(fn)
+      this.onClose(fn.bind(this))
     } else if (name === 'onReady' || name === 'onListen' || name === 'onRoute') {
       this[kHooks].add(name, fn)
     } else {

package/lib/handleRequest.js

@@ -28,7 +28,8 @@ function handleRequest (err, request, reply) {
   const contentType = headers['content-type']
 
   if (method === 'POST' || method === 'PUT' || method === 'PATCH' || method === 'TRACE' || method === 'SEARCH' ||
-    method === 'PROPFIND' || method === 'PROPPATCH' || method === 'LOCK' || method === 'REPORT' || method === 'MKCALENDAR') {
+    method === 'PROPFIND' || method === 'PROPPATCH' || method === 'LOCK' || method === 'COPY' || method === 'MOVE' ||
+    method === 'MKCOL' || method === 'REPORT' || method === 'MKCALENDAR') {
     if (contentType === undefined) {
       if (
         headers['transfer-encoding'] === undefined &&

package/lib/reply.js

@@ -602,14 +602,30 @@ function onSendEnd (reply, payload) {
     reply.header('Trailer', header.trim())
   }
 
-  // since Response contain status code, we need to update before
-  // any action that used statusCode
-  const isResponse = toString.call(payload) === '[object Response]'
-  if (isResponse) {
+  // since Response contain status code, headers and body,
+  // we need to update the status, add the headers and use it's body as payload
+  // before continuing
+  if (toString.call(payload) === '[object Response]') {
     // https://developer.mozilla.org/en-US/docs/Web/API/Response/status
     if (typeof payload.status === 'number') {
       reply.code(payload.status)
     }
+
+    // https://developer.mozilla.org/en-US/docs/Web/API/Response/headers
+    if (typeof payload.headers === 'object' && typeof payload.headers.forEach === 'function') {
+      for (const [headerName, headerValue] of payload.headers) {
+        reply.header(headerName, headerValue)
+      }
+    }
+
+    // https://developer.mozilla.org/en-US/docs/Web/API/Response/body
+    if (payload.body !== null) {
+      if (payload.bodyUsed) {
+        throw new FST_ERR_REP_RESPONSE_BODY_CONSUMED()
+      }
+    }
+    // Keep going, body is either null or ReadableStream
+    payload = payload.body
   }
   const statusCode = res.statusCode
 
@@ -656,26 +672,6 @@ function onSendEnd (reply, payload) {
     return
   }
 
-  // Response
-  if (isResponse) {
-    // https://developer.mozilla.org/en-US/docs/Web/API/Response/headers
-    if (typeof payload.headers === 'object' && typeof payload.headers.forEach === 'function') {
-      for (const [headerName, headerValue] of payload.headers) {
-        reply.header(headerName, headerValue)
-      }
-    }
-
-    // https://developer.mozilla.org/en-US/docs/Web/API/Response/body
-    if (payload.body != null) {
-      if (payload.bodyUsed) {
-        throw new FST_ERR_REP_RESPONSE_BODY_CONSUMED()
-      }
-      // Response.body always a ReadableStream
-      sendWebStream(payload.body, res, reply)
-    }
-    return
-  }
-
   if (typeof payload !== 'string' && !Buffer.isBuffer(payload)) {
     throw new FST_ERR_REP_INVALID_PAYLOAD_TYPE(typeof payload)
   }
@@ -726,7 +722,7 @@ function sendStream (payload, res, reply) {
       if (res.headersSent || reply.request.raw.aborted === true) {
         if (!errorLogged) {
           errorLogged = true
-          logStreamError(reply.log, err, res)
+          logStreamError(reply.log, err, reply)
         }
         res.destroy()
       } else {

package/lib/route.js

@@ -366,7 +366,7 @@ function buildRouting (options) {
         // any route insertion error created by fastify can be safely ignore
         // because it only duplicate route for head
         if (!context[kRouteByFastify]) {
-          const isDuplicatedRoute = error.message.includes(`Method '${opts.method}' already declared for route '${opts.url}'`)
+          const isDuplicatedRoute = error.message.includes(`Method '${opts.method}' already declared for route`)
           if (isDuplicatedRoute) {
             throw new FST_ERR_DUPLICATED_ROUTE(opts.method, opts.url)
           }
@@ -407,7 +407,7 @@ function buildRouting (options) {
           fourOhFour.setContext(this, context)
 
           if (opts.schema) {
-            context.schema = normalizeSchema(context.schema, this.initialConfig)
+            context.schema = normalizeSchema(opts, context.schema, this.initialConfig)
 
             const schemaController = this[kSchemaController]
             if (!opts.validatorCompiler && (opts.schema.body || opts.schema.headers || opts.schema.querystring || opts.schema.params)) {

package/lib/schemas.js

@@ -4,6 +4,9 @@ const fastClone = require('rfdc')({ circles: false, proto: true })
 const { kSchemaVisited, kSchemaResponse } = require('./symbols')
 const kFluentSchema = Symbol.for('fluent-schema-object')
 
+const {
+  FSTDEP022
+} = require('./warnings')
 const {
   FST_ERR_SCH_MISSING_ID,
   FST_ERR_SCH_ALREADY_PRESENT,
@@ -54,7 +57,7 @@ function isCustomSchemaPrototype (schema) {
   return typeof schema === 'object' && Object.getPrototypeOf(schema) !== Object.prototype
 }
 
-function normalizeSchema (routeSchemas, serverOptions) {
+function normalizeSchema (opts, routeSchemas, serverOptions) {
   if (routeSchemas[kSchemaVisited]) {
     return routeSchemas
   }
@@ -73,7 +76,20 @@ function normalizeSchema (routeSchemas, serverOptions) {
   for (const key of SCHEMAS_SOURCE) {
     const schema = routeSchemas[key]
     if (schema && !isCustomSchemaPrototype(schema)) {
-      routeSchemas[key] = getSchemaAnyway(schema, serverOptions.jsonShorthand)
+      if (key === 'body' && schema.content) {
+        const contentProperty = schema.content
+        const keys = Object.keys(contentProperty)
+        for (let i = 0; i < keys.length; i++) {
+          const contentType = keys[i]
+          const contentSchema = contentProperty[contentType].schema
+          if (!contentSchema) {
+            throw new FST_ERR_SCH_CONTENT_MISSING_SCHEMA(contentType)
+          }
+          routeSchemas.body.content[contentType].schema = getSchemaAnyway(opts.url, contentSchema, serverOptions.jsonShorthand)
+        }
+        continue
+      }
+      routeSchemas[key] = getSchemaAnyway(opts.url, schema, serverOptions.jsonShorthand)
     }
   }
 
@@ -95,7 +111,7 @@ function normalizeSchema (routeSchemas, serverOptions) {
             if (keys.length === 1) { break }
             throw new FST_ERR_SCH_CONTENT_MISSING_SCHEMA(mediaName)
           }
-          routeSchemas.response[code].content[mediaName].schema = getSchemaAnyway(contentProperty[mediaName].schema, serverOptions.jsonShorthand)
+          routeSchemas.response[code].content[mediaName].schema = getSchemaAnyway(opts.url, contentProperty[mediaName].schema, serverOptions.jsonShorthand)
           if (i === keys.length - 1) {
             hasContentMultipleContentTypes = true
           }
@@ -103,7 +119,7 @@ function normalizeSchema (routeSchemas, serverOptions) {
       }
 
       if (!hasContentMultipleContentTypes) {
-        routeSchemas.response[code] = getSchemaAnyway(routeSchemas.response[code], serverOptions.jsonShorthand)
+        routeSchemas.response[code] = getSchemaAnyway(opts.url, routeSchemas.response[code], serverOptions.jsonShorthand)
       }
     }
   }
@@ -129,9 +145,10 @@ function generateFluentSchema (schema) {
   }
 }
 
-function getSchemaAnyway (schema, jsonShorthand) {
+function getSchemaAnyway (url, schema, jsonShorthand) {
   if (!jsonShorthand || schema.$ref || schema.oneOf || schema.allOf || schema.anyOf || schema.$merge || schema.$patch) return schema
   if (!schema.type && !schema.properties) {
+    FSTDEP022(url)
     return {
       type: 'object',
       properties: schema

package/lib/server.js

@@ -72,7 +72,8 @@ function createServer (options, httpHandler) {
     } else {
       host = listenOptions.host
     }
-    if (Object.prototype.hasOwnProperty.call(listenOptions, 'host') === false) {
+    if (Object.prototype.hasOwnProperty.call(listenOptions, 'host') === false ||
+      listenOptions.host == null) {
       listenOptions.host = host
     }
     if (host === 'localhost') {

package/lib/validation.js

@@ -87,7 +87,17 @@ function compileSchemasForValidation (context, compile, isCustom) {
   }
 
   if (schema.body) {
-    context[bodySchema] = compile({ schema: schema.body, method, url, httpPart: 'body' })
+    const contentProperty = schema.body.content
+    if (contentProperty) {
+      const contentTypeSchemas = {}
+      for (const contentType of Object.keys(contentProperty)) {
+        const contentSchema = contentProperty[contentType].schema
+        contentTypeSchemas[contentType] = compile({ schema: contentSchema, method, url, httpPart: 'body', contentType })
+      }
+      context[bodySchema] = contentTypeSchemas
+    } else {
+      context[bodySchema] = compile({ schema: schema.body, method, url, httpPart: 'body' })
+    }
   } else if (Object.prototype.hasOwnProperty.call(schema, 'body')) {
     FSTWRN001('body', method, url)
   }
@@ -140,7 +150,18 @@ function validate (context, request, execution) {
   }
 
   if (runExecution || !execution.skipBody) {
-    const body = validateParam(context[bodySchema], request, 'body')
+    let validatorFunction = null
+    if (typeof context[bodySchema] === 'function') {
+      validatorFunction = context[bodySchema]
+    } else if (context[bodySchema]) {
+      // TODO: add request.contentType and reuse it here
+      const contentType = request.headers['content-type']?.split(';', 1)[0]
+      const contentSchema = context[bodySchema][contentType]
+      if (contentSchema) {
+        validatorFunction = contentSchema
+      }
+    }
+    const body = validateParam(validatorFunction, request, 'body')
     if (body) {
       if (typeof body.then !== 'function') {
         return wrapValidationError(body, 'body', context.schemaErrorFormatter)

package/lib/warnings.js

@@ -87,6 +87,11 @@ const FSTDEP021 = createDeprecation({
   message: 'The `reply.redirect()` method has a new signature: `reply.redirect(url: string, code?: number)`. It will be enforced in `fastify@v5`'
 })
 
+const FSTDEP022 = createDeprecation({
+  code: 'FSTDEP021',
+  message: 'You are using the deprecated json shorthand schema on route %s. Specify full object schema instead. It will be removed in `fastify@v5`'
+})
+
 const FSTWRN001 = createWarning({
   name: 'FastifyWarning',
   code: 'FSTWRN001',
@@ -119,6 +124,7 @@ module.exports = {
   FSTDEP019,
   FSTDEP020,
   FSTDEP021,
+  FSTDEP022,
   FSTWRN001,
   FSTWRN002
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.28.1",
+  "version": "4.29.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",

package/test/close.test.js

@@ -10,11 +10,14 @@ const split = require('split2')
 const { sleep } = require('./helper')
 
 test('close callback', t => {
-  t.plan(4)
+  t.plan(7)
   const fastify = Fastify()
   fastify.addHook('onClose', onClose)
   function onClose (instance, done) {
+    t.type(fastify, this)
     t.type(fastify, instance)
+    t.equal(fastify, this)
+    t.equal(fastify, instance)
     done()
   }
 

package/test/copy.test.js

@@ -12,7 +12,10 @@ test('can be created - copy', t => {
       method: 'COPY',
       url: '*',
       handler: function (req, reply) {
-        reply.code(204).send()
+        reply.code(204)
+          .header('location', req.headers.destination)
+          .header('body', req.body.toString())
+          .send()
       }
     })
     t.pass()
@@ -26,15 +29,19 @@ fastify.listen({ port: 0 }, err => {
   t.teardown(() => { fastify.close() })
 
   test('request - copy', t => {
-    t.plan(2)
+    t.plan(4)
     sget({
       url: `http://localhost:${fastify.server.address().port}/test.txt`,
       method: 'COPY',
       headers: {
-        Destination: '/test2.txt'
-      }
-    }, (err, response, body) => {
+        destination: '/test2.txt',
+        'Content-Type': 'text/plain'
+      },
+      body: '/test3.txt'
+    }, (err, response) => {
       t.error(err)
+      t.equal(response.headers.location, '/test2.txt')
+      t.equal(response.headers.body, '/test3.txt')
       t.equal(response.statusCode, 204)
     })
   })

package/test/internals/validation.test.js

@@ -63,7 +63,7 @@ test('build schema - output schema', t => {
   t.equal(typeof opts[symbols.responseSchema]['201'], 'function')
 })
 
-test('build schema - payload schema', t => {
+test('build schema - body schema', t => {
   t.plan(1)
   const opts = {
     schema: {
@@ -79,6 +79,32 @@ test('build schema - payload schema', t => {
   t.equal(typeof opts[symbols.bodySchema], 'function')
 })
 
+test('build schema - body with multiple content type schemas', t => {
+  t.plan(2)
+  const opts = {
+    schema: {
+      body: {
+        content: {
+          'application/json': {
+            schema: {
+              type: 'object',
+              properties: {
+                hello: { type: 'string' }
+              }
+            }
+          },
+          'text/plain': {
+            schema: { type: 'string' }
+          }
+        }
+      }
+    }
+  }
+  validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
+  t.type(opts[symbols.bodySchema]['application/json'], 'function')
+  t.type(opts[symbols.bodySchema]['text/plain'], 'function')
+})
+
 test('build schema - avoid repeated normalize schema', t => {
   t.plan(3)
   const serverConfig = {
@@ -94,10 +120,10 @@ test('build schema - avoid repeated normalize schema', t => {
       }
     }
   }
-  opts.schema = normalizeSchema(opts.schema, serverConfig)
+  opts.schema = normalizeSchema({}, opts.schema, serverConfig)
   t.not(kSchemaVisited, undefined)
   t.equal(opts.schema[kSchemaVisited], true)
-  t.equal(opts.schema, normalizeSchema(opts.schema, serverConfig))
+  t.equal(opts.schema, normalizeSchema({}, opts.schema, serverConfig))
 })
 
 test('build schema - query schema', t => {
@@ -115,7 +141,7 @@ test('build schema - query schema', t => {
       }
     }
   }
-  opts.schema = normalizeSchema(opts.schema, serverConfig)
+  opts.schema = normalizeSchema({}, opts.schema, serverConfig)
   validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
   t.type(opts[symbols.querystringSchema].schema.type, 'string')
   t.equal(typeof opts[symbols.querystringSchema], 'function')
@@ -133,7 +159,7 @@ test('build schema - query schema abbreviated', t => {
       }
     }
   }
-  opts.schema = normalizeSchema(opts.schema, serverConfig)
+  opts.schema = normalizeSchema({}, opts.schema, serverConfig)
   validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
   t.type(opts[symbols.querystringSchema].schema.type, 'string')
   t.equal(typeof opts[symbols.querystringSchema], 'function')
@@ -168,7 +194,7 @@ test('build schema - querystring schema abbreviated', t => {
       }
     }
   }
-  opts.schema = normalizeSchema(opts.schema, serverConfig)
+  opts.schema = normalizeSchema({}, opts.schema, serverConfig)
   validation.compileSchemasForValidation(opts, ({ schema, method, url, httpPart }) => ajv.compile(schema))
   t.type(opts[symbols.querystringSchema].schema.type, 'string')
   t.equal(typeof opts[symbols.querystringSchema], 'function')
@@ -196,7 +222,7 @@ test('build schema - must throw if querystring and query schema exist', t => {
         }
       }
     }
-    opts.schema = normalizeSchema(opts.schema, serverConfig)
+    opts.schema = normalizeSchema({}, opts.schema, serverConfig)
   } catch (err) {
     t.equal(err.code, 'FST_ERR_SCH_DUPLICATE')
     t.equal(err.message, 'Schema with \'querystring\' already present!')
@@ -354,7 +380,7 @@ test('build schema - mixed schema types are individually skipped or normalized',
   }]
 
   testCases.forEach((testCase) => {
-    const result = normalizeSchema(testCase.schema, { jsonShorthand: true })
+    const result = normalizeSchema({}, testCase.schema, { jsonShorthand: true })
     testCase.assertions(result)
   })
 })

package/test/json-shorthand.test.js

@@ -0,0 +1,131 @@
+'use strict'
+
+const { test } = require('tap')
+const Fastify = require('..')
+const {
+  FSTDEP022
+} = require('../lib/warnings')
+
+test('use of deprecated json shorthand in params should warn', t => {
+  t.plan(3)
+
+  process.removeAllListeners('warning')
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'DeprecationWarning')
+    t.equal(warning.code, FSTDEP022.code)
+  }
+
+  const fastify = Fastify()
+
+  fastify.get('/:id', {
+    schema: {
+      params: {
+        id: { type: 'string' }
+      }
+    }
+  }, (_, reply) => {
+    return reply.code(200).send('')
+  })
+
+  fastify.inject({ method: 'GET', url: '/1' }, (err, res) => {
+    t.error(err)
+
+    process.removeListener('warning', onWarning)
+  })
+
+  FSTDEP022.emitted = false
+})
+
+test('use of deprecated json shorthand in headers should warn', t => {
+  t.plan(3)
+
+  process.removeAllListeners('warning')
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'DeprecationWarning')
+    t.equal(warning.code, FSTDEP022.code)
+  }
+
+  const fastify = Fastify()
+
+  fastify.get('/', {
+    schema: {
+      headers: {
+        hello: { type: 'string' }
+      }
+    }
+  }, (_, reply) => {
+    return reply.code(200).send('')
+  })
+
+  fastify.inject({ method: 'GET', url: '/' }, (err, res) => {
+    t.error(err)
+
+    process.removeListener('warning', onWarning)
+  })
+
+  FSTDEP022.emitted = false
+})
+
+test('use of deprecated json shorthand in querystring should warn', t => {
+  t.plan(3)
+
+  process.removeAllListeners('warning')
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'DeprecationWarning')
+    t.equal(warning.code, FSTDEP022.code)
+  }
+
+  const fastify = Fastify()
+
+  fastify.get('/', {
+    schema: {
+      querystring: {
+        hello: { type: 'string' }
+      }
+    }
+  }, (_, reply) => {
+    return reply.code(200).send('')
+  })
+
+  fastify.inject({ method: 'GET', url: '/', query: { hello: 'world' } }, (err, res) => {
+    t.error(err)
+
+    process.removeListener('warning', onWarning)
+  })
+
+  FSTDEP022.emitted = false
+})
+
+test('use of deprecated json shorthand in body should warn', t => {
+  t.plan(3)
+
+  process.removeAllListeners('warning')
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'DeprecationWarning')
+    t.equal(warning.code, FSTDEP022.code)
+  }
+
+  const fastify = Fastify()
+
+  fastify.post('/', {
+    schema: {
+      body: {
+        hello: { type: 'string' }
+      }
+    }
+  }, (_, reply) => {
+    return reply.code(200).send('')
+  })
+
+  fastify.inject({ method: 'POST', url: '/', body: { hello: 'world' } }, (err, res) => {
+    t.error(err)
+
+    process.removeListener('warning', onWarning)
+  })
+
+  FSTDEP022.emitted = false
+})

package/test/listen.1.test.js

@@ -99,3 +99,39 @@ test('listen after Promise.resolve()', t => {
       })
     })
 })
+
+test('listen works with undefined host', async t => {
+  const doNotWarn = () => {
+    t.fail('should not be deprecated')
+  }
+  process.on('warning', doNotWarn)
+
+  const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
+  t.teardown(() => {
+    fastify.close()
+    process.removeListener('warning', doNotWarn)
+  })
+  await fastify.listen({ host: undefined, port: 0 })
+  const address = fastify.server.address()
+  t.equal(address.address, localhost)
+  t.ok(address.port > 0)
+})
+
+test('listen works with null host', async t => {
+  const doNotWarn = () => {
+    t.fail('should not be deprecated')
+  }
+  process.on('warning', doNotWarn)
+
+  const fastify = Fastify()
+  t.teardown(fastify.close.bind(fastify))
+  t.teardown(() => {
+    fastify.close()
+    process.removeListener('warning', doNotWarn)
+  })
+  await fastify.listen({ host: null, port: 0 })
+  const address = fastify.server.address()
+  t.equal(address.address, localhost)
+  t.ok(address.port > 0)
+})

package/test/mkcol.test.js

@@ -12,7 +12,7 @@ test('can be created - mkcol', t => {
       method: 'MKCOL',
       url: '*',
       handler: function (req, reply) {
-        reply.code(201).send()
+        reply.code(201).header('body', req.body.toString()).send()
       }
     })
     t.pass()
@@ -26,12 +26,15 @@ fastify.listen({ port: 0 }, err => {
   t.teardown(() => { fastify.close() })
 
   test('request - mkcol', t => {
-    t.plan(2)
+    t.plan(3)
     sget({
       url: `http://localhost:${fastify.server.address().port}/test/`,
-      method: 'MKCOL'
-    }, (err, response, body) => {
+      method: 'MKCOL',
+      headers: { 'Content-Type': 'text/plain' },
+      body: '/test.txt'
+    }, (err, response) => {
       t.error(err)
+      t.equal(response.headers.body, '/test.txt')
       t.equal(response.statusCode, 201)
     })
   })

package/test/move.test.js

@@ -12,9 +12,9 @@ test('shorthand - move', t => {
       method: 'MOVE',
       url: '*',
       handler: function (req, reply) {
-        const destination = req.headers.destination
         reply.code(201)
-          .header('location', destination)
+          .header('location', req.headers.destination)
+          .header('body', req.body.toString())
           .send()
       }
     })
@@ -29,17 +29,20 @@ fastify.listen({ port: 0 }, err => {
   t.teardown(() => { fastify.close() })
 
   test('request - move', t => {
-    t.plan(3)
+    t.plan(4)
     sget({
       url: `http://localhost:${fastify.server.address().port}/test.txt`,
       method: 'MOVE',
       headers: {
-        Destination: '/test2.txt'
-      }
-    }, (err, response, body) => {
+        destination: '/test2.txt',
+        'Content-Type': 'text/plain'
+      },
+      body: '/test3.txt'
+    }, (err, response) => {
       t.error(err)
       t.equal(response.statusCode, 201)
       t.equal(response.headers.location, '/test2.txt')
+      t.equal(response.headers.body, '/test3.txt')
     })
   })
 })

package/test/route.8.test.js

@@ -140,3 +140,30 @@ test('using fastify.all when a catchall is defined does not degrade performance'
 
   t.pass()
 })
+
+test('Adding manually HEAD route after GET with the same path throws Fastify duplicated route instance error', t => {
+  t.plan(1)
+
+  const fastify = Fastify()
+
+  fastify.route({
+    method: 'GET',
+    path: '/:param1',
+    handler: (req, reply) => {
+      reply.send({ hello: 'world' })
+    }
+  })
+
+  try {
+    fastify.route({
+      method: 'HEAD',
+      path: '/:param2',
+      handler: (req, reply) => {
+        reply.send({ hello: 'world' })
+      }
+    })
+    t.fail('Should throw fastify duplicated route declaration')
+  } catch (error) {
+    t.equal(error.code, 'FST_ERR_DUPLICATED_ROUTE')
+  }
+})

package/test/schema-feature.test.js

@@ -190,6 +190,27 @@ test('Should throw of the schema does not exists in input', t => {
   })
 })
 
+test('Should throw if schema is missing for content type', t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  fastify.post('/', {
+    handler: echoBody,
+    schema: {
+      body: {
+        content: {
+          'application/json': {}
+        }
+      }
+    }
+  })
+
+  fastify.ready(err => {
+    t.equal(err.code, 'FST_ERR_SCH_CONTENT_MISSING_SCHEMA')
+    t.equal(err.message, "Schema is missing for the content type 'application/json'")
+  })
+})
+
 test('Should throw of the schema does not exists in output', t => {
   t.plan(2)
   const fastify = Fastify()

package/test/schema-validation.test.js

@@ -105,6 +105,142 @@ test('Basic validation test', t => {
   })
 })
 
+test('Different schema per content type', t => {
+  t.plan(12)
+
+  const fastify = Fastify()
+  fastify.addContentTypeParser('application/octet-stream', {
+    parseAs: 'buffer'
+  }, async function (_, payload) {
+    return payload
+  })
+  fastify.post('/', {
+    schema: {
+      body: {
+        content: {
+          'application/json': {
+            schema: schemaArtist
+          },
+          'application/octet-stream': {
+            schema: {} // Skip validation
+          },
+          'text/plain': {
+            schema: { type: 'string' }
+          }
+        }
+      }
+    }
+  }, async function (req, reply) {
+    return reply.send(req.body)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: {
+      name: 'michelangelo',
+      work: 'sculptor, painter, architect and poet'
+    }
+  }, (err, res) => {
+    t.error(err)
+    t.same(JSON.parse(res.payload).name, 'michelangelo')
+    t.equal(res.statusCode, 200)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: { name: 'michelangelo' }
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.json(), { statusCode: 400, code: 'FST_ERR_VALIDATION', error: 'Bad Request', message: "body must have required property 'work'" })
+    t.equal(res.statusCode, 400)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    headers: { 'Content-Type': 'application/octet-stream' },
+    body: Buffer.from('AAAAAAAA')
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'AAAAAAAA')
+    t.equal(res.statusCode, 200)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    headers: { 'Content-Type': 'text/plain' },
+    body: 'AAAAAAAA'
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'AAAAAAAA')
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Skip validation if no schema for content type', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.post('/', {
+    schema: {
+      body: {
+        content: {
+          'application/json': {
+            schema: schemaArtist
+          }
+          // No schema for 'text/plain'
+        }
+      }
+    }
+  }, async function (req, reply) {
+    return reply.send(req.body)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    headers: { 'Content-Type': 'text/plain' },
+    body: 'AAAAAAAA'
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'AAAAAAAA')
+    t.equal(res.statusCode, 200)
+  })
+})
+
+test('Skip validation if no content type schemas', t => {
+  t.plan(3)
+
+  const fastify = Fastify()
+  fastify.post('/', {
+    schema: {
+      body: {
+        content: {
+          // No schemas
+        }
+      }
+    }
+  }, async function (req, reply) {
+    return reply.send(req.body)
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'POST',
+    headers: { 'Content-Type': 'text/plain' },
+    body: 'AAAAAAAA'
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'AAAAAAAA')
+    t.equal(res.statusCode, 200)
+  })
+})
+
 test('External AJV instance', t => {
   t.plan(5)
 

package/test/stream-serializers.test.js

@@ -0,0 +1,37 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const Fastify = require('..')
+const Reply = require('../lib/reply')
+
+test('should serialize reply when response stream is ended', t => {
+  t.plan(3)
+  const stream = require('node:stream')
+  const fastify = Fastify({
+    logger: {
+      serializers: {
+        res (reply) {
+          t.type(reply, Reply)
+          return reply
+        }
+      }
+    }
+  })
+
+  fastify.get('/error', function (req, reply) {
+    const reallyLongStream = new stream.Readable({
+      read: () => { }
+    })
+    reply.code(200).send(reallyLongStream)
+    reply.raw.end(Buffer.from('hello\n'))
+  })
+
+  fastify.inject({
+    url: '/error',
+    method: 'GET'
+  }, (err) => {
+    t.error(err)
+    fastify.close()
+  })
+})

package/test/throw.test.js

@@ -22,9 +22,9 @@ test('Fastify should throw on multiple assignment to the same route', t => {
 
   try {
     fastify.get('/', () => {})
-    t.fail('Should throw on duplicated route declaration')
+    t.fail('Should throw fastify duplicated route declaration')
   } catch (error) {
-    t.equal(error.message, "Method 'GET' already declared for route '/'")
+    t.equal(error.code, 'FST_ERR_DUPLICATED_ROUTE')
   }
 })
 

package/test/types/hooks.test-d.ts

@@ -151,7 +151,8 @@ server.addHook('onListen', function (done) {
   expectAssignable<(err?: NodeJS.ErrnoException) => void>(done)
 })
 
-server.addHook('onClose', (instance, done) => {
+server.addHook('onClose', function (instance, done) {
+  expectType<FastifyInstance>(this)
   expectType<FastifyInstance>(instance)
   expectAssignable<(err?: FastifyError) => void>(done)
   expectAssignable<(err?: NodeJS.ErrnoException) => void>(done)
@@ -236,7 +237,8 @@ server.addHook('onListen', async function () {
   expectType<FastifyInstance>(this)
 })
 
-server.addHook('onClose', async (instance) => {
+server.addHook('onClose', async function (instance) {
+  expectType<FastifyInstance>(this)
   expectType<FastifyInstance>(instance)
 })
 

package/test/types/route.test-d.ts

@@ -19,6 +19,13 @@ declare module '../../fastify' {
   interface FastifyContextConfig {
     foo: string;
     bar: number;
+    includeMessage?: boolean;
+  }
+
+  interface FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider, ContextConfig, Logger, RequestType> {
+    message: ContextConfig extends { includeMessage: true }
+      ? string
+      : null;
   }
 }
 
@@ -36,6 +43,22 @@ const routeHandlerWithReturnValue: RouteHandlerMethod = function (request, reply
   return reply.send()
 }
 
+fastify().get(
+  '/',
+  { config: { foo: 'bar', bar: 100, includeMessage: true } },
+  (req) => {
+    expectType<string>(req.message)
+  }
+)
+
+fastify().get(
+  '/',
+  { config: { foo: 'bar', bar: 100, includeMessage: false } },
+  (req) => {
+    expectType<null>(req.message)
+  }
+)
+
 type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete' | 'options';
 
 ['GET', 'POST', 'PUT', 'PATCH', 'HEAD', 'DELETE', 'OPTIONS'].forEach(method => {

package/test/types/schema.test-d.ts

@@ -20,6 +20,25 @@ expectAssignable<FastifyInstance>(server.get(
   () => { }
 ))
 
+expectAssignable<FastifyInstance>(server.post(
+  '/multiple-content-schema',
+  {
+    schema: {
+      body: {
+        content: {
+          'application/json': {
+            schema: { type: 'object' }
+          },
+          'text/plain': {
+            schema: { type: 'string' }
+          }
+        }
+      }
+    }
+  },
+  () => { }
+))
+
 expectAssignable<FastifyInstance>(server.get(
   '/empty-schema',
   {

package/test/web-api.test.js

@@ -62,6 +62,81 @@ test('should response with a Response', async (t) => {
   t.equal(headers.hello, 'world')
 })
 
+test('should response with a Response 204', async (t) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.send(new Response(null, {
+      status: 204,
+      headers: {
+        hello: 'world'
+      }
+    }))
+  })
+
+  const {
+    statusCode,
+    headers,
+    body
+  } = await fastify.inject({ method: 'GET', path: '/' })
+
+  t.equal(statusCode, 204)
+  t.equal(body, '')
+  t.equal(headers.hello, 'world')
+})
+
+test('should response with a Response 304', async (t) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.send(new Response(null, {
+      status: 304,
+      headers: {
+        hello: 'world'
+      }
+    }))
+  })
+
+  const {
+    statusCode,
+    headers,
+    body
+  } = await fastify.inject({ method: 'GET', path: '/' })
+
+  t.equal(statusCode, 304)
+  t.equal(body, '')
+  t.equal(headers.hello, 'world')
+})
+
+test('should response with a Response without body', async (t) => {
+  t.plan(3)
+
+  const fastify = Fastify()
+
+  fastify.get('/', function (request, reply) {
+    reply.send(new Response(null, {
+      status: 200,
+      headers: {
+        hello: 'world'
+      }
+    }))
+  })
+
+  const {
+    statusCode,
+    headers,
+    body
+  } = await fastify.inject({ method: 'GET', path: '/' })
+
+  t.equal(statusCode, 200)
+  t.equal(body, '')
+  t.equal(headers.hello, 'world')
+})
+
 test('able to use in onSend hook - ReadableStream', async (t) => {
   t.plan(4)
 

package/types/hooks.d.ts

@@ -782,6 +782,7 @@ export interface onCloseHookHandler<
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
 > {
   (
+    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
     instance: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
     done: HookHandlerDoneFunction
   ): void;
@@ -795,6 +796,7 @@ export interface onCloseAsyncHookHandler<
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > {
   (
+    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
     instance: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>
   ): Promise<unknown>;
 }

package/types/route.d.ts

@@ -1,6 +1,6 @@
 import { FastifyError } from '@fastify/error'
 import { ConstraintStrategy } from 'find-my-way'
-import { FastifyRequestContext } from './context'
+import { FastifyContextConfig } from './context'
 import { onErrorMetaHookHandler, onRequestAbortMetaHookHandler, onRequestMetaHookHandler, onResponseMetaHookHandler, onSendMetaHookHandler, onTimeoutMetaHookHandler, preHandlerMetaHookHandler, preParsingMetaHookHandler, preSerializationMetaHookHandler, preValidationMetaHookHandler } from './hooks'
 import { FastifyInstance } from './instance'
 import { FastifyBaseLogger, FastifyChildLoggerFactory, LogLevel } from './logger'
@@ -52,7 +52,7 @@ export interface RouteShorthandOptions<
   serializerCompiler?: FastifySerializerCompiler<NoInferCompat<SchemaCompiler>>;
   bodyLimit?: number;
   logLevel?: LogLevel;
-  config?: Omit<FastifyRequestContext<ContextConfig>['config'], 'url' | 'method'>;
+  config?: FastifyContextConfig & ContextConfig;
   version?: string;
   constraints?: RouteConstraint,
   prefixTrailingSlash?: 'slash'|'no-slash'|'both';

package/test/types/import.js

@@ -1,2 +0,0 @@
-'use strict'
-Object.defineProperty(exports, '__esModule', { value: true })