fastify 4.3.0 → 4.4.0

package/docs/Guides/Ecosystem.md

@@ -112,6 +112,14 @@ section.
 - [`@fastify/swagger`](https://github.com/fastify/fastify-swagger) Plugin for
   serving Swagger/OpenAPI documentation for Fastify, supporting dynamic
   generation.
+- [`@fastify/type-provider-json-schema-to-ts`](https://github.com/fastify/fastify-type-provider-json-schema-to-ts)
+  Fastify
+  [type provider](https://www.fastify.io/docs/latest/Reference/Type-Providers/)
+  for [json-schema-to-ts](https://github.com/ThomasAribart/json-schema-to-ts). 
+- [`@fastify/type-provider-typebox`](https://github.com/fastify/fastify-type-provider-typebox)
+  Fastify
+  [type provider](https://www.fastify.io/docs/latest/Reference/Type-Providers/) 
+  for [Typebox](https://github.com/sinclairzx81/typebox).
 - [`@fastify/under-pressure`](https://github.com/fastify/under-pressure) Measure
   process load with automatic handling of _"Service Unavailable"_ plugin for
   Fastify.
@@ -147,6 +155,9 @@ section.
 - [`@immobiliarelabs/fastify-sentry`](https://github.com/immobiliare/fastify-sentry)
   Sentry errors handler that just works! Install, add your DSN and you're good
   to go!
+- [`@mateonunez/fastify-lyra`](https://github.com/mateonunez/fastify-lyra)
+  A plugin to implement [Lyra](https://github.com/nearform/lyra) search engine 
+  on Fastify
 - [`@mgcrea/fastify-graceful-exit`](https://github.com/mgcrea/fastify-graceful-exit)
   A plugin to close the server gracefully
 - [`@mgcrea/fastify-request-logger`](https://github.com/mgcrea/fastify-request-logger)
@@ -215,6 +226,8 @@ section.
   to add [boom](https://github.com/hapijs/boom) support.
 - [`fastify-bree`](https://github.com/climba03003/fastify-bree) Fastify plugin
   to add [bree](https://github.com/breejs/bree) support.
+- [`fastify-bugsnag`](https://github.com/ZigaStrgar/fastify-bugsnag) Fastify plugin
+  to add support for [Bugsnag](https://www.bugsnag.com/) error reporting.
 - [`fastify-casbin`](https://github.com/nearform/fastify-casbin) Casbin support
   for Fastify.
 - [`fastify-casbin-rest`](https://github.com/nearform/fastify-casbin-rest)
@@ -328,6 +341,8 @@ section.
   authentication for Fastify-based web apps.
 - [`fastify-kafkajs`](https://github.com/kffl/fastify-kafkajs) Fastify plugin
   that adds support for KafkaJS - a modern Apache Kafka client library.
+- [`fastify-keycloak-adapter`](https://github.com/yubinTW/fastify-keycloak-adapter)
+  A keycloak adapter for a Fastify app.
 - [`fastify-knexjs`](https://github.com/chapuletta/fastify-knexjs) Fastify
   plugin for support KnexJS Query Builder.
 - [`fastify-knexjs-mock`](https://github.com/chapuletta/fastify-knexjs-mock)
@@ -508,6 +523,10 @@ section.
   TOTP (e.g. for 2FA).
 - [`fastify-twitch-ebs-tools`](https://github.com/lukemnet/fastify-twitch-ebs-tools)
   Useful functions for Twitch Extension Backend Services (EBS).
+- [`fastify-type-provider-zod`](https://github.com/turkerdev/fastify-type-provider-zod)
+  Fastify 
+  [type provider](https://www.fastify.io/docs/latest/Reference/Type-Providers/) 
+  for [zod](https://github.com/colinhacks/zod).
 - [`fastify-typeorm-plugin`](https://github.com/inthepocket/fastify-typeorm-plugin)
   Fastify plugin to work with TypeORM.
 - [`fastify-vhost`](https://github.com/patrickpissurno/fastify-vhost) Proxy

package/docs/Reference/Hooks.md

@@ -244,6 +244,9 @@ The `onResponse` hook is executed when a response has been sent, so you will not
 be able to send more data to the client. It can however be useful for sending
 data to external services, for example, to gather statistics.
 
+**Note:** setting `disableRequestLogging` to `true` will disable any error log 
+inside the `onResponse` hook. In this case use `try - catch` to log errors. 
+
 ### onTimeout
 
 ```js
@@ -287,7 +290,7 @@ fastify.addHook('preHandler', (request, reply, done) => {
 
 Or if you're using `async/await` you can just throw an error:
 ```js
-fastify.addHook('onResponse', async (request, reply) => {
+fastify.addHook('onRequest', async (request, reply) => {
   throw new Error('Some error')
 })
 ```

package/docs/Reference/Logging.md

@@ -170,7 +170,7 @@ app.addHook('preHandler', function (req, reply, done) {
 You can also supply your own logger instance. Instead of passing configuration
 options, pass the instance. The logger you supply must conform to the Pino
 interface; that is, it must have the following methods: `info`, `error`,
-`debug`, `fatal`, `warn`, `trace`, `child`.
+`debug`, `fatal`, `warn`, `trace`, `silent`, `child` and a string property `level`.
 
 Example:
 

package/docs/Reference/Reply.md

@@ -767,6 +767,7 @@ Fastify natively handles promises and supports async-await.
 
 *Note that in the following examples we are not using reply.send.*
 ```js
+const { promisify } = require('util')
 const delay = promisify(setTimeout)
 
 fastify.get('/promises', options, function (request, reply) {

package/docs/Reference/Routes.md

@@ -32,8 +32,10 @@ fastify.route(options)
 ### Routes options
 <a id="options"></a>
 
-*`method`: currently it supports `'DELETE'`, `'GET'`, `'HEAD'`, `'PATCH'`,
-  `'POST'`, `'PUT'` and `'OPTIONS'`. It could also be an array of methods.
+* `method`: currently it supports `'DELETE'`, `'GET'`, `'HEAD'`, `'PATCH'`,
+  `'POST'`, `'PUT'`, `'OPTIONS'`, `'SEARCH'`, `'TRACE'`, `'PROPFIND'`,
+  `'PROPPATCH'`, `'MKCOL'`, `'COPY'`, `'MOVE'`, `'LOCK'`  and `'UNLOCK'`.
+  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
   need to be in [JSON Schema](https://json-schema.org/) format, check

package/docs/Reference/Server.md

@@ -890,7 +890,7 @@ fastify.ready().then(() => {
 Starts the server and internally waits for the `.ready()` event. The signature
 is `.listen([options][, callback])`. Both the `options` object and the
 `callback` parameters follow the [Node.js
-core][https://nodejs.org/api/net.html#serverlistenoptions-callback] parameter
+core](https://nodejs.org/api/net.html#serverlistenoptions-callback) parameter
 definitions.
 
 By default, the server will listen on the address(es) resolved by `localhost`
@@ -1402,6 +1402,9 @@ handlers. *async-await* is supported as well.
 *Note: If the error `statusCode` is less than 400, Fastify will automatically
 set it at 500 before calling the error handler.*
 
+*Also note* that `setErrorHandler` will ***not*** catch any error inside
+an `onResponse` hook because the response has already been sent to the client.
+
 ```js
 fastify.setErrorHandler(function (error, request, reply) {
   // Log error

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.3.0'
+const VERSION = '4.4.0'
 
 const Avvio = require('avvio')
 const http = require('http')
@@ -34,7 +34,7 @@ const {
 const { createServer, compileValidateHTTPVersion } = require('./lib/server')
 const Reply = require('./lib/reply')
 const Request = require('./lib/request')
-const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS']
+const { supportedMethods } = require('./lib/httpMethods')
 const decorator = require('./lib/decorate')
 const ContentTypeParser = require('./lib/contentTypeParser')
 const SchemaController = require('./lib/schema-controller')

package/lib/handleRequest.js

@@ -18,14 +18,14 @@ function handleRequest (err, request, reply) {
   const method = request.raw.method
   const headers = request.headers
 
-  if (method === 'GET' || method === 'HEAD') {
+  if (method === 'GET' || method === 'HEAD' || method === 'SEARCH') {
     handler(request, reply)
     return
   }
 
   const contentType = headers['content-type']
 
-  if (method === 'POST' || method === 'PUT' || method === 'PATCH') {
+  if (method === 'POST' || method === 'PUT' || method === 'PATCH' || method === 'TRACE') {
     if (contentType === undefined) {
       if (
         headers['transfer-encoding'] === undefined &&

package/lib/httpMethods.js

@@ -0,0 +1,22 @@
+'use strict'
+
+module.exports = {
+  supportedMethods: [
+    'DELETE',
+    'GET',
+    'HEAD',
+    'PATCH',
+    'POST',
+    'PUT',
+    'OPTIONS',
+    'PROPFIND',
+    'PROPPATCH',
+    'MKCOL',
+    'COPY',
+    'MOVE',
+    'LOCK',
+    'UNLOCK',
+    'TRACE',
+    'SEARCH'
+  ]
+}

package/lib/route.js

@@ -4,7 +4,7 @@ const FindMyWay = require('find-my-way')
 const Context = require('./context')
 const handleRequest = require('./handleRequest')
 const { hookRunner, hookIterator, lifecycleHooks } = require('./hooks')
-const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS']
+const { supportedMethods } = require('./httpMethods')
 const { normalizeSchema } = require('./schemas')
 const { parseHeadOnSendHandlers } = require('./headRoute')
 const warning = require('./warnings')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.3.0",
+  "version": "4.4.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -159,7 +159,7 @@
     "json-schema-to-ts": "^2.5.3",
     "JSONStream": "^1.3.5",
     "license-checker": "^25.0.1",
-    "markdownlint-cli2": "^0.4.0",
+    "markdownlint-cli2": "^0.5.0",
     "proxyquire": "^2.1.3",
     "pump": "^3.0.0",
     "self-cert": "^2.0.0",

package/test/copy.test.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('can be created - copy', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'COPY',
+      url: '*',
+      handler: function (req, reply) {
+        reply.code(204).send()
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - copy', t => {
+    t.plan(2)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test.txt`,
+      method: 'COPY',
+      headers: {
+        Destination: '/test2.txt'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 204)
+    })
+  })
+})

package/test/internals/all.test.js

@@ -3,9 +3,15 @@
 const t = require('tap')
 const test = t.test
 const Fastify = require('../..')
-const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS']
+const { supportedMethods } = require('../../lib/httpMethods')
 
 test('fastify.all should add all the methods to the same url', t => {
+  const requirePayload = [
+    'POST',
+    'PUT',
+    'PATCH'
+  ]
+
   t.plan(supportedMethods.length * 2)
 
   const fastify = Fastify()
@@ -22,7 +28,7 @@ test('fastify.all should add all the methods to the same url', t => {
       method
     }
 
-    if (method === 'POST' || method === 'PUT' || method === 'PATCH') {
+    if (requirePayload.includes(method)) {
       options.payload = { hello: 'world' }
     }
 

package/test/internals/reply.test.js

@@ -1044,7 +1044,7 @@ test('reply.hasHeader returns correct values', t => {
 })
 
 test('reply.getHeader returns correct values', t => {
-  t.plan(4)
+  t.plan(5)
 
   const fastify = require('../../')()
 
@@ -1055,6 +1055,9 @@ test('reply.getHeader returns correct values', t => {
     reply.header('x-foo', 'bar')
     t.strictSame(reply.getHeader('x-foo'), 'bar')
 
+    reply.header('x-foo', 42)
+    t.strictSame(reply.getHeader('x-foo'), 42)
+
     reply.header('set-cookie', 'one')
     reply.header('set-cookie', 'two')
     t.strictSame(reply.getHeader('set-cookie'), ['one', 'two'])

package/test/lock.test.js

@@ -0,0 +1,73 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('can be created - lock', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'LOCK',
+      url: '*',
+      handler: function (req, reply) {
+        reply
+          .code(200)
+          .send(`<?xml version="1.0" encoding="utf-8" ?>
+            <D:prop xmlns:D="DAV:">
+              <D:lockdiscovery>
+                <D:activelock>
+                  <D:locktype>
+                    <D:write/>
+                  </D:locktype>
+                  <D:lockscope>
+                    <D:exclusive/>
+                  </D:lockscope>
+                  <D:depth>infinity</D:depth>
+                  <D:owner>
+                    <D:href>http://example.org/~ejw/contact.html</D:href>
+                  </D:owner>
+                  <D:timeout>Second-604800</D:timeout>
+                  <D:locktoken>
+                    <D:href>urn:uuid:e71d4fae-5dec-22d6-fea5-00a0c91e6be4</:href>
+                  </D:locktoken>
+                  <D:lockroot>
+                    <D:href>http://example.com/workspace/webdav/proposal.oc</D:href>
+                  </D:lockroot>
+                </D:activelock>
+              </D:lockdiscovery>
+            </D:prop>`
+          )
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - lock', t => {
+    t.plan(3)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test/a.txt`,
+      body: `<?xml version="1.0" encoding="utf-8" ?>
+        <D:lockinfo xmlns:D='DAV:'>
+          <D:lockscope> <D:exclusive/> </D:lockscope>
+          <D:locktype> <D:write/> </D:locktype>
+          <D:owner>
+            <D:href>http://example.org/~ejw/contact.html</D:href>
+          </D:owner>
+        </D:lockinfo> `,
+      method: 'LOCK'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 200)
+      t.equal(response.headers['content-length'], '' + body.length)
+    })
+  })
+})

package/test/mkcol.test.js

@@ -0,0 +1,38 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('can be created - mkcol', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'MKCOL',
+      url: '*',
+      handler: function (req, reply) {
+        reply.code(201).send()
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - mkcol', t => {
+    t.plan(2)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test/`,
+      method: 'MKCOL'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 201)
+    })
+  })
+})

package/test/move.test.js

@@ -0,0 +1,45 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('shorthand - move', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'MOVE',
+      url: '*',
+      handler: function (req, reply) {
+        const destination = req.headers.destination
+        reply.code(201)
+          .header('location', destination)
+          .send()
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - move', t => {
+    t.plan(3)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test.txt`,
+      method: 'MOVE',
+      headers: {
+        Destination: '/test2.txt'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 201)
+      t.equal(response.headers.location, '/test2.txt')
+    })
+  })
+})

package/test/propfind.test.js

@@ -0,0 +1,108 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('can be created - propfind', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'PROPFIND',
+      url: '*',
+      handler: function (req, reply) {
+        return reply.code(207)
+          .send(`<?xml version="1.0" encoding="utf-8"?>
+            <D:multistatus xmlns:D="DAV:">
+              <D:response xmlns:lp1="DAV:">
+                <D:href>/</D:href>
+                <D:propstat>
+                  <D:prop>
+                    <lp1:resourcetype>
+                      <D:collection/>
+                    </lp1:resourcetype>
+                    <lp1:creationdate>2022-04-13T12:35:30Z</lp1:creationdate>
+                    <lp1:getlastmodified>Wed, 13 Apr 2022 12:35:30 GMT</lp1:getlastmodified>
+                    <lp1:getetag>"e0-5dc8869b53ef1"</lp1:getetag>
+                    <D:supportedlock>
+                      <D:lockentry>
+                        <D:lockscope>
+                          <D:exclusive/>
+                        </D:lockscope>
+                        <D:locktype>
+                          <D:write/>
+                        </D:locktype>
+                      </D:lockentry>
+                      <D:lockentry>
+                        <D:lockscope>
+                          <D:shared/>
+                        </D:lockscope>
+                        <D:locktype>
+                          <D:write/>
+                        </D:locktype>
+                      </D:lockentry>
+                    </D:supportedlock>
+                    <D:lockdiscovery/>
+                    <D:getcontenttype>httpd/unix-directory</D:getcontenttype>
+                  </D:prop>
+                  <D:status>HTTP/1.1 200 OK</D:status>
+                </D:propstat>
+              </D:response>
+            </D:multistatus>`
+          )
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - propfind', t => {
+    t.plan(3)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/`,
+      method: 'PROPFIND'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 207)
+      t.equal(response.headers['content-length'], '' + body.length)
+    })
+  })
+
+  test('request with other path - propfind', t => {
+    t.plan(3)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test`,
+      method: 'PROPFIND'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 207)
+      t.equal(response.headers['content-length'], '' + body.length)
+    })
+  })
+
+  test('request with body - propfind', t => {
+    t.plan(3)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test`,
+      body: `<?xml version="1.0" encoding="utf-8" ?>
+        <D:propfind xmlns:D="DAV:">
+          <D:prop xmlns:R="http://ns.example.com/boxschema/">
+            <R:bigbox/> <R:author/> <R:DingALing/> <R:Random/>
+          </D:prop>
+        </D:propfind>
+      `,
+      method: 'PROPFIND'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 207)
+      t.equal(response.headers['content-length'], '' + body.length)
+    })
+  })
+})

package/test/proppatch.test.js

@@ -0,0 +1,78 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('shorthand - proppatch', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'PROPPATCH',
+      url: '*',
+      handler: function (req, reply) {
+        reply
+          .code(207)
+          .send(`<?xml version="1.0" encoding="utf-8" ?>
+            <D:multistatus xmlns:D="DAV:"
+              xmlns:Z="http://ns.example.com/standards/z39.50/">
+              <D:response>
+                <D:href>http://www.example.com/bar.html</D:href>
+                <D:propstat>
+                  <D:prop>
+                    <Z:Authors/>
+                  </D:prop>
+                  <D:status>HTTP/1.1 424 Failed Dependency</D:status>
+                </D:propstat>
+                <D:propstat>
+                  <D:prop>
+                    <Z:Copyright-Owner/>
+                  </D:prop>
+                  <D:status>HTTP/1.1 409 Conflict</D:status>
+                </D:propstat>
+                <D:responsedescription> Copyright Owner cannot be deleted or altered.</D:responsedescription>
+              </D:response>
+            </D:multistatus>`
+          )
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - proppatch', t => {
+    t.plan(3)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test/a.txt`,
+      body: `<?xml version="1.0" encoding="utf-8" ?>
+        <D:propertyupdate xmlns:D="DAV:"
+          xmlns:Z="http://ns.example.com/standards/z39.50/">
+          <D:set>
+            <D:prop>
+              <Z:Authors>
+                <Z:Author>Jim Whitehead</Z:Author>
+                <Z:Author>Roy Fielding</Z:Author>
+              </Z:Authors>
+            </D:prop>
+          </D:set>
+          <D:remove>
+            <D:prop>
+              <Z:Copyright-Owner/>
+            </D:prop>
+          </D:remove>
+        </D:propertyupdate>`,
+      method: 'PROPPATCH'
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 207)
+      t.equal(response.headers['content-length'], '' + body.length)
+    })
+  })
+})

package/test/search.test.js

@@ -0,0 +1,100 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const fastify = require('..')()
+
+const schema = {
+  schema: {
+    response: {
+      '2xx': {
+        type: 'object',
+        properties: {
+          hello: {
+            type: 'string'
+          }
+        }
+      }
+    }
+  }
+}
+
+const querySchema = {
+  schema: {
+    querystring: {
+      type: 'object',
+      properties: {
+        hello: {
+          type: 'integer'
+        }
+      }
+    }
+  }
+}
+
+const paramsSchema = {
+  schema: {
+    params: {
+      type: 'object',
+      properties: {
+        foo: {
+          type: 'string'
+        },
+        test: {
+          type: 'integer'
+        }
+      }
+    }
+  }
+}
+
+test('shorthand - search', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'SEARCH',
+      url: '/',
+      schema,
+      handler: function (request, reply) {
+        reply.code(200).send({ hello: 'world' })
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('shorthand - search params', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'SEARCH',
+      url: '/params/:foo/:test',
+      paramsSchema,
+      handler: function (request, reply) {
+        reply.code(200).send(request.params)
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+test('shorthand - get, querystring schema', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'SEARCH',
+      url: '/query',
+      querySchema,
+      handler: function (request, reply) {
+        reply.code(200).send(request.query)
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})

package/test/trace.test.js

@@ -0,0 +1,21 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const fastify = require('..')()
+
+test('shorthand - trace', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'TRACE',
+      url: '/',
+      handler: function (request, reply) {
+        reply.code(200).send('TRACE OK')
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})

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

@@ -1,4 +1,4 @@
-import { expectError, expectType } from 'tsd'
+import { expectDeprecated, expectError, expectType } from 'tsd'
 import fastify, {
   FastifyLogFn,
   LogLevel,
@@ -24,13 +24,10 @@ class Foo {}
   expectType<void>(fastify<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance>().log[logLevel as LogLevel](new Foo()))
 })
 
-/*
-// TODO make pino export BaseLogger again
 interface CustomLogger extends FastifyBaseLogger {
   customMethod(msg: string, ...args: unknown[]): void;
 }
 
-//   // ToDo https://github.com/pinojs/pino/issues/1100
 class CustomLoggerImpl implements CustomLogger {
   level = 'info'
   customMethod (msg: string, ...args: unknown[]) { console.log(msg, args) }
@@ -60,7 +57,6 @@ CustomLoggerImpl
 >({ logger: customLogger })
 
 expectType<CustomLoggerImpl>(serverWithCustomLogger.log)
-*/
 
 const serverWithPino = fastify<
 Server,
@@ -213,6 +209,9 @@ const passPinoOption = fastify({
 
 expectType<FastifyBaseLogger>(passPinoOption.log)
 
+// FastifyLoggerInstance is deprecated
+expectDeprecated({} as FastifyLoggerInstance)
+
 const childParent = fastify().log
 // we test different option variant here
 expectType<FastifyLoggerInstance>(childParent.child({}, { level: 'info' }))

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

@@ -1,4 +1,4 @@
-import { expectType, expectError } from 'tsd'
+import { expectType, expectError, expectAssignable } from 'tsd'
 import fastify, { RouteHandlerMethod, RouteHandler, RawRequestDefaultExpression, FastifyContext, FastifyContextConfig, FastifyRequest, FastifyReply } from '../../fastify'
 import { RawServerDefault, RawReplyDefaultExpression, ContextConfigDefault } from '../../types/utils'
 import { FastifyLoggerInstance } from '../../types/logger'
@@ -6,6 +6,8 @@ import { RouteGenericInterface } from '../../types/route'
 import { FastifyInstance } from '../../types/instance'
 import { Buffer } from 'buffer'
 
+type DefaultSerializationFunction = (payload: {[key: string]: unknown}) => string
+
 const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectType<RawReplyDefaultExpression>(reply.raw)
   expectType<FastifyContext<ContextConfigDefault>>(reply.context)
@@ -19,7 +21,7 @@ const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectType<((payload?: unknown) => FastifyReply)>(reply.send)
   expectType<(key: string, value: any) => FastifyReply>(reply.header)
   expectType<(values: {[key: string]: any}) => FastifyReply>(reply.headers)
-  expectType<(key: string) => string | undefined>(reply.getHeader)
+  expectType<(key: string) => number | string | string[] | undefined>(reply.getHeader)
   expectType<() => { [key: string]: number | string | string[] | undefined }>(reply.getHeaders)
   expectType<(key: string) => void>(reply.removeHeader)
   expectType<(key: string) => boolean>(reply.hasHeader)
@@ -32,6 +34,11 @@ const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectType<(payload: any) => string | ArrayBuffer | Buffer>(reply.serialize)
   expectType<(fulfilled: () => void, rejected: (err: Error) => void) => void>(reply.then)
   expectType<FastifyInstance>(reply.server)
+  expectAssignable<((httpStatus: string) => DefaultSerializationFunction)>(reply.getSerializationFunction)
+  expectAssignable<((schema: {[key: string]: unknown}) => DefaultSerializationFunction)>(reply.getSerializationFunction)
+  expectAssignable<((schema: {[key: string]: unknown}, httpStatus?: string) => DefaultSerializationFunction)>(reply.compileSerializationSchema)
+  expectAssignable<((input: {[key: string]: unknown}, schema: {[key: string]: unknown}, httpStatus?: string) => unknown)>(reply.serializeInput)
+  expectAssignable<((input: {[key: string]: unknown}, httpStatus: string) => unknown)>(reply.serializeInput)
 }
 
 interface ReplyPayload {
@@ -40,6 +47,14 @@ interface ReplyPayload {
   };
 }
 
+interface ReplyUnion {
+  Reply: {
+    success: boolean;
+  } | {
+    error: string;
+  }
+}
+
 const typedHandler: RouteHandler<ReplyPayload> = async (request, reply) => {
   expectType<((payload?: ReplyPayload['Reply']) => FastifyReply<RawServerDefault, RawRequestDefaultExpression<RawServerDefault>, RawReplyDefaultExpression<RawServerDefault>, ReplyPayload>)>(reply.send)
 }
@@ -53,9 +68,35 @@ server.get<ReplyPayload>('/get-generic-send', async function handler (request, r
 server.get<ReplyPayload>('/get-generic-return', async function handler (request, reply) {
   return { test: false }
 })
-expectError(server.get<ReplyPayload>('/get-generic-return-error', async function handler (request, reply) {
+expectError(server.get<ReplyPayload>('/get-generic-send-error', async function handler (request, reply) {
   reply.send({ foo: 'bar' })
 }))
 expectError(server.get<ReplyPayload>('/get-generic-return-error', async function handler (request, reply) {
   return { foo: 'bar' }
 }))
+server.get<ReplyUnion>('/get-generic-union-send', async function handler (request, reply) {
+  if (0 as number === 0) {
+    reply.send({ success: true })
+  } else {
+    reply.send({ error: 'error' })
+  }
+})
+server.get<ReplyUnion>('/get-generic-union-return', async function handler (request, reply) {
+  if (0 as number === 0) {
+    return { success: true }
+  } else {
+    return { error: 'error' }
+  }
+})
+expectError(server.get<ReplyUnion>('/get-generic-union-send-error-1', async function handler (request, reply) {
+  reply.send({ successes: true })
+}))
+expectError(server.get<ReplyUnion>('/get-generic-union-send-error-2', async function handler (request, reply) {
+  reply.send({ error: 500 })
+}))
+expectError(server.get<ReplyUnion>('/get-generic-union-return-error-1', async function handler (request, reply) {
+  return { successes: true }
+}))
+expectError(server.get<ReplyUnion>('/get-generic-union-return-error-2', async function handler (request, reply) {
+  return { error: 500 }
+}))

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

@@ -1,4 +1,4 @@
-import { expectType } from 'tsd'
+import { expectAssignable, expectType } from 'tsd'
 import pino from 'pino'
 import fastify, {
   RouteHandler,
@@ -21,7 +21,6 @@ import { FastifyRequest } from '../../types/request'
 import { FastifyReply } from '../../types/reply'
 import { FastifyInstance } from '../../types/instance'
 import { RouteGenericInterface } from '../../types/route'
-import { ResolveFastifyReplyReturnType, ResolveFastifyRequestType } from '../../types/type-provider'
 
 interface RequestBody {
   content: string;
@@ -55,6 +54,9 @@ type CustomRequest = FastifyRequest<{
   Headers: RequestHeaders;
 }>
 
+type HTTPRequestPart = 'body' | 'query' | 'querystring' | 'params' | 'headers'
+type ExpectedGetValidationFunction = (input: {[key: string]: unknown}) => boolean
+
 interface CustomLoggerInterface extends FastifyLoggerInstance {
   foo: FastifyLogFn; // custom severity logger method
 }
@@ -83,6 +85,10 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<RawRequestDefaultExpression['socket']>(request.socket)
   expectType<Error & { validation: any; validationContext: string } | undefined>(request.validationError)
   expectType<FastifyInstance>(request.server)
+  expectAssignable<(httpPart: HTTPRequestPart) => ExpectedGetValidationFunction>(request.getValidationFunction)
+  expectAssignable<(schema: {[key: string]: unknown}) => ExpectedGetValidationFunction>(request.getValidationFunction)
+  expectAssignable<(input: {[key: string]: unknown}, schema: {[key: string]: unknown}, httpPart?: HTTPRequestPart) => boolean>(request.validateInput)
+  expectAssignable<(input: {[key: string]: unknown}, httpPart?: HTTPRequestPart) => boolean>(request.validateInput)
 }
 
 const getHandlerWithCustomLogger: RouteHandlerMethod<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, RouteGenericInterface, ContextConfigDefault, FastifySchema, FastifyTypeProviderDefault, CustomLoggerInterface> = function (request, _reply) {
@@ -128,17 +134,6 @@ server.put('/put', putHandler)
 
 const customLogger: CustomLoggerInterface = {
   level: 'info',
-  version: '5.0',
-  useOnlyCustomLevels: false,
-  useLevelLabels: false,
-  levels: { labels: [], values: {} },
-  eventNames: () => [],
-  listenerCount: (eventName: string | symbol) => 0,
-  bindings: () => ({}),
-  flush: () => () => {},
-  customLevels: { foo: 1 },
-  isLevelEnabled: () => false,
-  levelVal: 0,
   silent: () => { },
   info: () => { },
   warn: () => { },
@@ -147,21 +142,7 @@ const customLogger: CustomLoggerInterface = {
   trace: () => { },
   debug: () => { },
   foo: () => { }, // custom severity logger method
-  on: (event, listener) => customLogger,
-  emit: (event, listener) => false,
-  off: (event, listener) => customLogger,
-  addListener: (event, listener) => customLogger,
-  prependListener: (event, listener) => customLogger,
-  prependOnceListener: (event, listener) => customLogger,
-  removeListener: (event, listener) => customLogger,
-  removeAllListeners: (event) => customLogger,
-  setMaxListeners: (n) => customLogger,
-  getMaxListeners: () => 0,
-  listeners: () => [],
-  rawListeners: () => [],
-  once: (event, listener) => customLogger,
-  child: () => customLogger as pino.Logger<never>,
-  setBindings: (bindings) => { }
+  child: () => customLogger as pino.Logger<never>
 }
 
 const serverWithCustomLogger = fastify({ logger: customLogger })

package/test/types/type-provider.test-d.ts

@@ -391,7 +391,9 @@ expectError(server.withTypeProvider<JsonSchemaToTsProvider>().get(
 // https://github.com/fastify/fastify/issues/4088
 expectError(server.withTypeProvider<JsonSchemaToTsProvider>().get('/', {
   schema: {
-    response: { type: 'string' }
+    response: {
+      200: { type: 'string' }
+    }
   } as const
 }, (_, res) => {
   return { foo: 555 }

package/test/unlock.test.js

@@ -0,0 +1,41 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const fastify = require('..')()
+
+test('can be created - unlock', t => {
+  t.plan(1)
+  try {
+    fastify.route({
+      method: 'UNLOCK',
+      url: '*',
+      handler: function (req, reply) {
+        reply.code(204).send()
+      }
+    })
+    t.pass()
+  } catch (e) {
+    t.fail()
+  }
+})
+
+fastify.listen({ port: 0 }, err => {
+  t.error(err)
+  t.teardown(() => { fastify.close() })
+
+  test('request - unlock', t => {
+    t.plan(2)
+    sget({
+      url: `http://localhost:${fastify.server.address().port}/test/a.txt`,
+      method: 'UNLOCK',
+      headers: {
+        'Lock-Token': 'urn:uuid:a515cfa4-5da4-22e1-f5b5-00a0451e6bf7'
+      }
+    }, (err, response, body) => {
+      t.error(err)
+      t.equal(response.statusCode, 204)
+    })
+  })
+})

package/types/logger.d.ts

@@ -19,13 +19,16 @@ export type Bindings = pino.Bindings
 
 export type ChildLoggerOptions = pino.ChildLoggerOptions
 
-export type FastifyLoggerInstance = pino.Logger
-// TODO make pino export BaseLogger again
-// export type FastifyBaseLogger = pino.BaseLogger & {
-export type FastifyBaseLogger = pino.Logger & {
+export type FastifyBaseLogger = pino.BaseLogger & {
   child(bindings: Bindings, options?: ChildLoggerOptions): FastifyBaseLogger
 }
 
+// TODO delete FastifyLoggerInstance in the next major release. It seems that it is enough to have only FastifyBaseLogger.
+/**
+ * @deprecated Use FastifyBaseLogger instead
+ */
+export type FastifyLoggerInstance = FastifyBaseLogger
+
 export interface FastifyLoggerStreamDestination {
   write(msg: string): void;
 }

package/types/reply.d.ts

@@ -38,7 +38,7 @@ export interface FastifyReply<
   send(payload?: ReplyType): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
   header(key: string, value: any): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
   headers(values: {[key: string]: any}): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
-  getHeader(key: string): string | undefined;
+  getHeader(key: string): number | string | string[] | undefined;
   getHeaders(): {
     // Node's `getHeaders()` can return numbers and arrays, so they're included here as possible types.
     [key: string]: number | string | string[] | undefined;
@@ -54,10 +54,11 @@ export interface FastifyReply<
   type(contentType: string): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
   serializer(fn: (payload: any) => string): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
   serialize(payload: any): string | ArrayBuffer | Buffer;
-  getSerializationFunction(httpStatus: string): (payload: any) => string;
-  getSerializationFunction(schema: {[key: string]: any}): (payload: any) => string;
-  compileSerializationSchema(schema: {[key: string]: any}, httpStatus?: string): (payload: any) => string;
-  serializeInput(input: any, schema: {[key: string]: any}, httpStatus?: string): string
-  serializeInput(input: any, httpStatus: string): string
+  // Serialization Methods
+  getSerializationFunction(httpStatus: string): (payload: {[key: string]: unknown}) => string;
+  getSerializationFunction(schema: {[key: string]: unknown}): (payload: {[key: string]: unknown}) => string;
+  compileSerializationSchema(schema: {[key: string]: unknown}, httpStatus?: string): (payload: {[key: string]: unknown}) => string;
+  serializeInput(input: {[key: string]: unknown}, schema: {[key: string]: unknown}, httpStatus?: string): string;
+  serializeInput(input: {[key: string]: unknown}, httpStatus: string): unknown;
   then(fulfilled: () => void, rejected: (err: Error) => void): void;
 }

package/types/request.d.ts

@@ -64,8 +64,8 @@ export interface FastifyRequest<RouteGeneric extends RouteGenericInterface = Rou
   getValidationFunction(httpPart: HTTPRequestPart): (input: any) => boolean
   getValidationFunction(schema: {[key: string]: any}): (input: any) => boolean
   compileValidationSchema(schema: {[key: string]: any}, httpPart?: HTTPRequestPart): (input: any) => boolean
-  validate(input: any, schema: {[key: string]: any}, httpPart?: HTTPRequestPart): boolean
-  validate(input: any, httpPart?: HTTPRequestPart): boolean
+  validateInput(input: any, schema: {[key: string]: any}, httpPart?: HTTPRequestPart): boolean
+  validateInput(input: any, httpPart?: HTTPRequestPart): boolean
 
   // Prefer `socket` over deprecated `connection` property in node 13.0.0 or higher
   // @deprecated

package/types/type-provider.d.ts

@@ -60,15 +60,6 @@ export interface ResolveFastifyRequestType<TypeProvider extends FastifyTypeProvi
 // FastifyReplyType
 // -----------------------------------------------------------------------------------------------
 
-// Tests if the user has specified a generic argument for Reply
-type UseReplyFromRouteGeneric<RouteGeneric extends RouteGenericInterface> = keyof RouteGeneric['Reply'] extends never ? false : true
-
-// Tests if the user has specified a response schema.
-type UseReplyFromSchemaCompiler<SchemaCompiler extends FastifySchema> = keyof SchemaCompiler['response'] extends never ? false : true
-
-// Resolves the Reply type from the generic argument
-type ResolveReplyFromRouteGeneric<RouteGeneric extends RouteGenericInterface> = RouteGeneric['Reply']
-
 // Resolves the Reply type by taking a union of response status codes
 type ResolveReplyFromSchemaCompiler<TypeProvider extends FastifyTypeProvider, SchemaCompiler extends FastifySchema> = {
   [K in keyof SchemaCompiler['response']]: CallTypeProvider<TypeProvider, SchemaCompiler['response'][K]>
@@ -80,11 +71,7 @@ export type FastifyReplyType<Reply = unknown> = Reply
 // Resolves the Reply type either via generic argument or from response schema. This type uses a different
 // resolution strategy to Requests where the Reply will infer a union of each status code type specified
 // by the user. The Reply can be explicitly overriden by users providing a generic Reply type on the route.
-export type ResolveFastifyReplyType<TypeProvider extends FastifyTypeProvider, SchemaCompiler extends FastifySchema, RouteGeneric extends RouteGenericInterface> = FastifyReplyType<
-UseReplyFromRouteGeneric<RouteGeneric> extends true ? ResolveReplyFromRouteGeneric<RouteGeneric> :
-  UseReplyFromSchemaCompiler<SchemaCompiler> extends true ? ResolveReplyFromSchemaCompiler<TypeProvider, SchemaCompiler> :
-    unknown
->
+export type ResolveFastifyReplyType<TypeProvider extends FastifyTypeProvider, SchemaCompiler extends FastifySchema, RouteGeneric extends RouteGenericInterface> = UndefinedToUnknown<KeysOf<RouteGeneric['Reply']> extends never ? ResolveReplyFromSchemaCompiler<TypeProvider, SchemaCompiler> : RouteGeneric['Reply']>
 
 // -----------------------------------------------------------------------------------------------
 // FastifyReplyReturnType

package/types/utils.d.ts

@@ -5,7 +5,8 @@ import * as https from 'https'
 /**
  * Standard HTTP method strings
  */
-export type HTTPMethods = 'DELETE' | 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'OPTIONS'
+export type HTTPMethods = 'DELETE' | 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'OPTIONS' |
+'PROPFIND' | 'PROPPATCH' | 'MKCOL' | 'COPY' | 'MOVE' | 'LOCK' | 'UNLOCK' | 'TRACE' | 'SEARCH'
 
 /**
  * A union type of the Node.js server types from the http, https, and http2 modules.