fastify 4.14.1 → 4.15.0

package/README.md

@@ -304,6 +304,8 @@ listed in alphabetical order.
   <https://twitter.com/ayoubelkh>, <https://www.npmjs.com/~ayoubelk>
 * [__Denis Fäcke__](https://github.com/SerayaEryn),
   <https://twitter.com/serayaeryn>, <https://www.npmjs.com/~serayaeryn>
+* [__Carlos Fuentes__](https://github.com/metcoder95),
+  <https://twitter.com/metcoder95>, <https://www.npmjs.com/~metcoder95>
 * [__Rafael Gonzaga__](https://github.com/rafaelgss),
   <https://twitter.com/_rafaelgss>, <https://www.npmjs.com/~rafaelgss>
 * [__Vincent Le Goff__](https://github.com/zekth)
@@ -327,6 +329,8 @@ listed in alphabetical order.
   <https://twitter.com/delvedor>, <https://www.npmjs.com/~delvedor>
 * [__Ayoub El Khattabi__](https://github.com/AyoubElk),
   <https://twitter.com/ayoubelkh>, <https://www.npmjs.com/~ayoubelk>
+* [__Carlos Fuentes__](https://github.com/metcoder95),
+  <https://twitter.com/metcoder95>, <https://www.npmjs.com/~metcoder95>
 * [__Vincent Le Goff__](https://github.com/zekth)
 * [__Salman Mitha__](https://github.com/salmanm),
   <https://www.npmjs.com/~salmanm>
@@ -338,7 +342,7 @@ listed in alphabetical order.
 * [__Rafael Gonzaga__](https://github.com/rafaelgss),
   <https://twitter.com/_rafaelgss>, <https://www.npmjs.com/~rafaelgss>
 * [__Simone Busoli__](https://github.com/simoneb),
-  <https://twitter.com/simonebu>, <https://www.npmjs.com/~simoneb>  
+  <https://twitter.com/simonebu>, <https://www.npmjs.com/~simoneb>
 
 ### Great Contributors
 Great contributors on a specific area in the Fastify ecosystem will be invited

package/docs/Reference/Errors.md

@@ -281,6 +281,12 @@ A callback for a hook timed out
 
 The logger accepts either a `'stream'` or a `'file'` as the destination.
 
+#### FST_ERR_LOG_INVALID_LOGGER
+<a id="FST_ERR_LOG_INVALID_LOGGER"></a>
+
+The logger should have all these methods: `'info'`, `'error'`,
+`'debug'`, `'fatal'`, `'warn'`, `'trace'`, `'child'`.
+
 #### FST_ERR_REP_INVALID_PAYLOAD_TYPE
 <a id="FST_ERR_REP_INVALID_PAYLOAD_TYPE"></a>
 

package/docs/Reference/Server.md

@@ -1545,35 +1545,61 @@ a custom constraint strategy with the same name.
 #### printRoutes
 <a id="print-routes"></a>
 
-`fastify.printRoutes()`: Prints the representation of the internal radix tree
-used by the router, useful for debugging. Alternatively, `fastify.printRoutes({
-commonPrefix: false })` can be used to print the flattened routes tree.
+`fastify.printRoutes()`: Fastify router builds a tree of routes for each HTTP
+method. If you call the prettyPrint without specifying an HTTP method, it will
+merge all the trees into one and print it. The merged tree doesn't represent the
+internal router structure. **Don't use it for debugging.**
 
 *Remember to call it inside or after a `ready` call.*
 
 ```js
 fastify.get('/test', () => {})
 fastify.get('/test/hello', () => {})
-fastify.get('/hello/world', () => {})
-fastify.get('/helicopter', () => {})
+fastify.get('/testing', () => {})
+fastify.get('/testing/:param', () => {})
+fastify.put('/update', () => {})
 
 fastify.ready(() => {
   console.log(fastify.printRoutes())
   // └── /
   //     ├── test (GET)
-  //     │   └── /hello (GET)
-  //     └── hel
-  //         ├── lo/world (GET)
-  //         └── licopter (GET)
+  //     │   ├── /hello (GET)
+  //     │   └── ing (GET)
+  //     │       └── /
+  //     │           └── :param (GET)
+  //     └── update (PUT)
+})
+```
 
-  console.log(fastify.printRoutes({ commonPrefix: false }))
-  // └── / (-)
-  //     ├── test (GET)
-  //     │   └── /hello (GET)
-  //     ├── hello/world (GET)
-  //     └── helicopter (GET)
+If you want to print the internal router tree, you should specify the `method`
+param. Printed tree will represent the internal router structure.
+**You can use it for debugging.**
 
-})
+```js
+  console.log(fastify.printRoutes({ method: 'GET' }))
+  // └── /
+  //     └── test (GET)
+  //         ├── /hello (GET)
+  //         └── ing (GET)
+  //             └── /
+  //                 └── :param (GET)
+
+  console.log(fastify.printRoutes({ method: 'PUT' }))
+  // └── /
+  //     └── update (PUT)
+```
+
+`fastify.printRoutes({ commonPrefix: false })` will print compressed trees. This
+might useful when you have a large number of routes with common prefixes.
+It doesn't represent the internal router structure. **Don't use it for debugging.**
+
+```js
+  console.log(fastify.printRoutes({ commonPrefix: false }))
+  // ├── /test (GET)
+  // │   ├── /hello (GET)
+  // │   └── ing (GET)
+  // │       └── /:param (GET)
+  // └── /update (PUT)
 ```
 
 `fastify.printRoutes({ includeMeta: (true | []) })` will display properties from
@@ -1583,26 +1609,51 @@ A shorthand option, `fastify.printRoutes({ includeHooks: true })` will include
 all [hooks](./Hooks.md).
 
 ```js
-  console.log(fastify.printRoutes({ includeHooks: true, includeMeta: ['metaProperty'] }))
+  fastify.get('/test', () => {})
+  fastify.get('/test/hello', () => {})
+
+  const onTimeout = () => {}
+
+  fastify.addHook('onRequest', () => {})
+  fastify.addHook('onTimeout', onTimeout)
+
+  console.log(fastify.printRoutes({ includeHooks: true, includeMeta: ['errorHandler'] }))
   // └── /
-  //     ├── test (GET)
-  //     │   • (onRequest) ["anonymous()","namedFunction()"]
-  //     │   • (metaProperty) "value"
-  //     │   └── /hello (GET)
-  //     └── hel
-  //         ├── lo/world (GET)
-  //         │   • (onTimeout) ["anonymous()"]
-  //         └── licopter (GET)
+  //     └── test (GET)
+  //         • (onTimeout) ["onTimeout()"]
+  //         • (onRequest) ["anonymous()"]
+  //         • (errorHandler) "defaultErrorHandler()"
+  //         test (HEAD)
+  //         • (onTimeout) ["onTimeout()"]
+  //         • (onRequest) ["anonymous()"]
+  //         • (onSend) ["headRouteOnSendHandler()"]
+  //         • (errorHandler) "defaultErrorHandler()"
+  //         └── /hello (GET)
+  //             • (onTimeout) ["onTimeout()"]
+  //             • (onRequest) ["anonymous()"]
+  //             • (errorHandler) "defaultErrorHandler()"
+  //             /hello (HEAD)
+  //             • (onTimeout) ["onTimeout()"]
+  //             • (onRequest) ["anonymous()"]
+  //             • (onSend) ["headRouteOnSendHandler()"]
+  //             • (errorHandler) "defaultErrorHandler()"
 
   console.log(fastify.printRoutes({ includeHooks: true }))
   // └── /
-  //     ├── test (GET)
-  //     │   • (onRequest) ["anonymous()","namedFunction()"]
-  //     │   └── /hello (GET)
-  //     └── hel
-  //         ├── lo/world (GET)
-  //         │   • (onTimeout) ["anonymous()"]
-  //         └── licopter (GET)
+  //     └── test (GET)
+  //         • (onTimeout) ["onTimeout()"]
+  //         • (onRequest) ["anonymous()"]
+  //         test (HEAD)
+  //         • (onTimeout) ["onTimeout()"]
+  //         • (onRequest) ["anonymous()"]
+  //         • (onSend) ["headRouteOnSendHandler()"]
+  //         └── /hello (GET)
+  //             • (onTimeout) ["onTimeout()"]
+  //             • (onRequest) ["anonymous()"]
+  //             /hello (HEAD)
+  //             • (onTimeout) ["onTimeout()"]
+  //             • (onRequest) ["anonymous()"]
+  //             • (onSend) ["headRouteOnSendHandler()"]
 ```
 
 #### printPlugins

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.14.1'
+const VERSION = '4.15.0'
 
 const Avvio = require('avvio')
 const http = require('http')

package/lib/contentTypeParser.js

@@ -396,10 +396,18 @@ function ParserListItem (contentType) {
   // we pre-calculate all the needed information
   // before content-type comparsion
   const parsed = safeParseContentType(contentType)
-  this.type = parsed.type
+  this.isEssence = contentType.indexOf(';') === -1
+  // we should not allow empty string for parser list item
+  // because it would become a match-all handler
+  if (this.isEssence === false && parsed.type === '') {
+    // handle semicolon or empty string
+    const tmp = contentType.split(';')[0]
+    this.type = tmp === '' ? contentType : tmp
+  } else {
+    this.type = parsed.type
+  }
   this.parameters = parsed.parameters
   this.parameterKeys = Object.keys(parsed.parameters)
-  this.isEssence = contentType.indexOf(';') === -1
 }
 
 // used in ContentTypeParser.remove

package/lib/errors.js

@@ -177,6 +177,11 @@ const codes = {
     'Cannot specify both logger.stream and logger.file options'
   ),
 
+  FST_ERR_LOG_INVALID_LOGGER: createError(
+    'FST_ERR_LOG_INVALID_LOGGER',
+    "Invalid logger object provided. The logger instance should have these functions(s): '%s'."
+  ),
+
   /**
    * reply
   */

package/lib/logger.js

@@ -9,17 +9,17 @@
 const nullLogger = require('abstract-logging')
 const pino = require('pino')
 const { serializersSym } = pino.symbols
-const { FST_ERR_LOG_INVALID_DESTINATION } = require('./errors')
+const {
+  FST_ERR_LOG_INVALID_DESTINATION,
+  FST_ERR_LOG_INVALID_LOGGER
+} = require('./errors')
 
-function createPinoLogger (opts, stream) {
-  stream = stream || opts.stream
-  delete opts.stream
-
-  if (stream && opts.file) {
+function createPinoLogger (opts) {
+  if (opts.stream && opts.file) {
     throw new FST_ERR_LOG_INVALID_DESTINATION()
   } else if (opts.file) {
     // we do not have stream
-    stream = pino.destination(opts.file)
+    opts.stream = pino.destination(opts.file)
     delete opts.file
   }
 
@@ -39,7 +39,7 @@ function createPinoLogger (opts, stream) {
     opts.logger = prevLogger
     opts.genReqId = prevGenReqId
   } else {
-    logger = pino(opts, stream)
+    logger = pino(opts, opts.stream)
   }
 
   return logger
@@ -70,50 +70,60 @@ function now () {
 }
 
 function createLogger (options) {
-  if (isValidLogger(options.logger)) {
+  if (!options.logger) {
+    const logger = nullLogger
+    logger.child = () => logger
+    return { logger, hasLogger: false }
+  }
+
+  if (validateLogger(options.logger)) {
     const logger = createPinoLogger({
       logger: options.logger,
       serializers: Object.assign({}, serializers, options.logger.serializers)
     })
     return { logger, hasLogger: true }
-  } else if (!options.logger) {
-    const logger = nullLogger
-    logger.child = () => logger
-    return { logger, hasLogger: false }
-  } else {
-    const localLoggerOptions = {}
-    if (Object.prototype.toString.call(options.logger) === '[object Object]') {
-      Reflect.ownKeys(options.logger).forEach(prop => {
-        Object.defineProperty(localLoggerOptions, prop, {
-          value: options.logger[prop],
-          writable: true,
-          enumerable: true,
-          configurable: true
-        })
-      })
-    }
-    localLoggerOptions.level = localLoggerOptions.level || 'info'
-    localLoggerOptions.serializers = Object.assign({}, serializers, localLoggerOptions.serializers)
-    options.logger = localLoggerOptions
-    const logger = createPinoLogger(options.logger)
-    return { logger, hasLogger: true }
   }
-}
 
-function isValidLogger (logger) {
-  if (!logger) {
-    return false
+  const localLoggerOptions = {}
+  if (Object.prototype.toString.call(options.logger) === '[object Object]') {
+    Reflect.ownKeys(options.logger).forEach(prop => {
+      Object.defineProperty(localLoggerOptions, prop, {
+        value: options.logger[prop],
+        writable: true,
+        enumerable: true,
+        configurable: true
+      })
+    })
   }
+  localLoggerOptions.level = localLoggerOptions.level || 'info'
+  localLoggerOptions.serializers = Object.assign({}, serializers, localLoggerOptions.serializers)
+  options.logger = localLoggerOptions
+  const logger = createPinoLogger(options.logger)
+  return { logger, hasLogger: true }
+}
 
-  let result = true
+/**
+ * Determines if a provided logger object meets the requirements
+ * of a Fastify compatible logger.
+ *
+ * @param {object} logger Object to validate.
+ *
+ * @returns {boolean} `true` when the logger meets the requirements.
+ *
+ * @throws {FST_ERR_LOG_INVALID_LOGGER} When the logger object is
+ * missing required methods.
+ */
+function validateLogger (logger) {
   const methods = ['info', 'error', 'debug', 'fatal', 'warn', 'trace', 'child']
-  for (let i = 0; i < methods.length; i += 1) {
-    if (!logger[methods[i]] || typeof logger[methods[i]] !== 'function') {
-      result = false
-      break
-    }
+  const missingMethods = methods.filter(method => !logger[method] || typeof logger[method] !== 'function')
+
+  if (!missingMethods.length) {
+    return true
+  } else if (missingMethods.length === methods.length) {
+    return false
+  } else {
+    throw FST_ERR_LOG_INVALID_LOGGER(missingMethods.join(','))
   }
-  return result
 }
 
 module.exports = {

package/lib/route.js

@@ -513,7 +513,6 @@ function handleOnRequestAbortHooksErrors (reply, err) {
   if (err) {
     reply.log.error({ err }, 'onRequestAborted hook failed')
   }
-  reply[kReplyIsError] = true
 }
 
 function handleTimeout () {

package/lib/validation.js

@@ -80,18 +80,26 @@ function compileSchemasForValidation (context, compile, isCustom) {
       })
     }
     context[headersSchema] = compile({ schema: headersSchemaLowerCase, method, url, httpPart: 'headers' })
+  } else if (Object.hasOwnProperty.call(schema, 'headers')) {
+    throw new Error('headers schema is undefined')
   }
 
   if (schema.body) {
     context[bodySchema] = compile({ schema: schema.body, method, url, httpPart: 'body' })
+  } else if (Object.hasOwnProperty.call(schema, 'body')) {
+    throw new Error('body schema is undefined')
   }
 
   if (schema.querystring) {
     context[querystringSchema] = compile({ schema: schema.querystring, method, url, httpPart: 'querystring' })
+  } else if (Object.hasOwnProperty.call(schema, 'querystring')) {
+    throw new Error('querystring schema is undefined')
   }
 
   if (schema.params) {
     context[paramsSchema] = compile({ schema: schema.params, method, url, httpPart: 'params' })
+  } else if (Object.hasOwnProperty.call(schema, 'params')) {
+    throw new Error('params schema is undefined')
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.14.1",
+  "version": "4.15.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -8,6 +8,7 @@
   "scripts": {
     "bench": "branchcmp -r 2 -g -s \"npm run benchmark\"",
     "benchmark": "npx concurrently -k -s first \"node ./examples/benchmark/simple.js\" \"npx autocannon -c 100 -d 30 -p 10 localhost:3000/\"",
+    "build:validation": "node build/build-error-serializer.js && node build/build-validation.js",
     "coverage": "npm run unit -- --cov --coverage-report=html",
     "coverage:ci": "npm run unit -- --cov --coverage-report=html --no-browser --no-check-coverage -R terse",
     "coverage:ci-check-coverage": "nyc check-coverage --branches 100 --functions 100 --lines 100 --statements 100",
@@ -17,10 +18,11 @@
     "lint:markdown": "markdownlint-cli2",
     "lint:standard": "standard | snazzy",
     "lint:typescript": "eslint -c types/.eslintrc.json types/**/*.d.ts test/types/**/*.test-d.ts",
-    "prepublishOnly": "PREPUBLISH=true tap --no-check-coverage test/build/**.test.js",
+    "prepublishOnly": "PREPUBLISH=true tap --no-check-coverage test/build/**.test.js && npm run test:validator:integrity",
     "test": "npm run lint && npm run unit && npm run test:typescript",
     "test:ci": "npm run unit -- -R terse --cov --coverage-report=lcovonly && npm run test:typescript",
     "test:report": "npm run lint && npm run unit:report && npm run test:typescript",
+    "test:validator:integrity": "npm run build:validation && git diff --quiet --ignore-all-space --ignore-blank-lines --ignore-cr-at-eol lib/error-serializer.js && git diff --quiet --ignore-all-space --ignore-blank-lines --ignore-cr-at-eol lib/configValidator.js",
     "test:typescript": "tsc test/types/import.ts && tsd",
     "test:watch": "npm run unit -- -w --no-coverage-report -R terse",
     "unit": "tap",
@@ -117,6 +119,11 @@
       "name": "Luis Orbaiceta",
       "email": "luisorbaiceta@gmail.com",
       "url": "https://luisorbaiceta.com"
+    },
+    {
+      "name": "Carlos Fuentes",
+      "email": "me@metcoder.dev",
+      "url": "https://metcoder.dev"
     }
   ],
   "license": "MIT",
@@ -164,7 +171,7 @@
     "split2": "^4.1.0",
     "standard": "^17.0.0",
     "tap": "^16.3.0",
-    "tsd": "^0.25.0",
+    "tsd": "^0.26.0",
     "typescript": "^4.8.3",
     "undici": "^5.10.0",
     "vary": "^1.1.2",
@@ -173,11 +180,11 @@
   "dependencies": {
     "@fastify/ajv-compiler": "^3.5.0",
     "@fastify/error": "^3.0.0",
-    "@fastify/fast-json-stringify-compiler": "^4.1.0",
+    "@fastify/fast-json-stringify-compiler": "^4.2.0",
     "abstract-logging": "^2.0.1",
     "avvio": "^8.2.0",
     "fast-content-type-parse": "^1.0.0",
-    "find-my-way": "^7.3.0",
+    "find-my-way": "^7.6.0",
     "light-my-request": "^5.6.1",
     "pino": "^8.5.0",
     "process-warning": "^2.0.0",

package/test/content-parser.test.js

@@ -649,3 +649,104 @@ test('content-type regexp list should be cloned when plugin override', async t =
     t.same(payload, 'png')
   }
 })
+
+test('allow partial content-type - essence check', async t => {
+  t.plan(1)
+
+  const fastify = Fastify()
+  fastify.removeAllContentTypeParsers()
+  fastify.addContentTypeParser('json', function (request, body, done) {
+    t.pass('should be called')
+    done(null, body)
+  })
+
+  fastify.post('/', async () => {
+    return 'ok'
+  })
+
+  await fastify.inject({
+    method: 'POST',
+    path: '/',
+    headers: {
+      'content-type': 'application/json; foo=bar; charset=utf8'
+    },
+    body: ''
+  })
+
+  await fastify.inject({
+    method: 'POST',
+    path: '/',
+    headers: {
+      'content-type': 'image/jpeg'
+    },
+    body: ''
+  })
+})
+
+test('allow partial content-type - not essence check', async t => {
+  t.plan(1)
+
+  const fastify = Fastify()
+  fastify.removeAllContentTypeParsers()
+  fastify.addContentTypeParser('json;', function (request, body, done) {
+    t.pass('should be called')
+    done(null, body)
+  })
+
+  fastify.post('/', async () => {
+    return 'ok'
+  })
+
+  await fastify.inject({
+    method: 'POST',
+    path: '/',
+    headers: {
+      'content-type': 'application/json; foo=bar; charset=utf8'
+    },
+    body: ''
+  })
+
+  await fastify.inject({
+    method: 'POST',
+    path: '/',
+    headers: {
+      'content-type': 'image/jpeg'
+    },
+    body: ''
+  })
+})
+
+test('edge case content-type - ;', async t => {
+  t.plan(1)
+
+  const fastify = Fastify()
+  fastify.removeAllContentTypeParsers()
+  fastify.addContentTypeParser(';', function (request, body, done) {
+    t.fail('should not be called')
+    done(null, body)
+  })
+
+  fastify.post('/', async () => {
+    return 'ok'
+  })
+
+  await fastify.inject({
+    method: 'POST',
+    path: '/',
+    headers: {
+      'content-type': 'application/json; foo=bar; charset=utf8'
+    },
+    body: ''
+  })
+
+  await fastify.inject({
+    method: 'POST',
+    path: '/',
+    headers: {
+      'content-type': 'image/jpeg'
+    },
+    body: ''
+  })
+
+  t.pass('end')
+})

package/test/hooks.test.js

@@ -3413,7 +3413,7 @@ test('onRequestAbort should be triggered', t => {
   const fastify = Fastify()
   let order = 0
 
-  t.plan(9)
+  t.plan(7)
   t.teardown(() => fastify.close())
 
   fastify.addHook('onRequestAbort', function (req, done) {
@@ -3424,8 +3424,7 @@ test('onRequestAbort should be triggered', t => {
   })
 
   fastify.addHook('onError', function hook (request, reply, error, done) {
-    t.same(error, { hello: 'world' }, 'onError should be called')
-    t.ok(request.raw.aborted, 'request should be aborted')
+    t.fail('onError should not be called')
     done()
   })
 

package/test/logger.test.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const { test, teardown, before } = require('tap')
-const helper = require('./helper')
 const http = require('http')
 const stream = require('stream')
 const split = require('split2')
@@ -13,6 +12,9 @@ const fs = require('fs')
 const sget = require('simple-get').concat
 const dns = require('dns')
 
+const helper = require('./helper')
+const { FST_ERR_LOG_INVALID_LOGGER } = require('../lib/errors')
+
 const files = []
 let count = 0
 let localhost
@@ -268,6 +270,34 @@ test('can use external logger instance with custom serializer', t => {
   })
 })
 
+test('should throw in case the external logger provided does not have a child method', t => {
+  t.plan(1)
+  const loggerInstance = {
+    info: console.info,
+    error: console.error,
+    debug: console.debug,
+    fatal: console.error,
+    warn: console.warn,
+    trace: console.trace
+  }
+
+  t.throws(
+    () => Fastify({ logger: loggerInstance }),
+    FST_ERR_LOG_INVALID_LOGGER,
+    "Invalid logger object provided. The logger instance should have these functions(s): 'child'."
+  )
+})
+
+test('should throw in case a partially matching logger is provided', t => {
+  t.plan(1)
+
+  t.throws(
+    () => Fastify({ logger: console }),
+    FST_ERR_LOG_INVALID_LOGGER,
+    "Invalid logger object provided. The logger instance should have these functions(s): 'fatal,child'."
+  )
+})
+
 test('expose the logger', t => {
   t.plan(2)
   let fastify = null

package/test/pretty-print.test.js

@@ -15,7 +15,8 @@ test('pretty print - static routes', t => {
   fastify.ready(() => {
     const tree = fastify.printRoutes()
 
-    const expected = `└── /
+    const expected = `\
+└── /
     ├── test (GET)
     │   └── /hello (GET)
     └── hello/world (GET)
@@ -26,6 +27,41 @@ test('pretty print - static routes', t => {
   })
 })
 
+test('pretty print - internal tree - static routes', t => {
+  t.plan(4)
+
+  const fastify = Fastify({ exposeHeadRoutes: false })
+  fastify.get('/test', () => {})
+  fastify.get('/test/hello', () => {})
+  fastify.get('/hello/world', () => {})
+
+  fastify.put('/test', () => {})
+  fastify.put('/test/foo', () => {})
+
+  fastify.ready(() => {
+    const getTree = fastify.printRoutes({ method: 'GET' })
+    const expectedGetTree = `\
+└── /
+    ├── test (GET)
+    │   └── /hello (GET)
+    └── hello/world (GET)
+`
+
+    t.equal(typeof getTree, 'string')
+    t.equal(getTree, expectedGetTree)
+
+    const putTree = fastify.printRoutes({ method: 'PUT' })
+    const expectedPutTree = `\
+└── /
+    └── test (PUT)
+        └── /foo (PUT)
+`
+
+    t.equal(typeof putTree, 'string')
+    t.equal(putTree, expectedPutTree)
+  })
+})
+
 test('pretty print - parametric routes', t => {
   t.plan(2)
 
@@ -37,10 +73,13 @@ test('pretty print - parametric routes', t => {
   fastify.ready(() => {
     const tree = fastify.printRoutes()
 
-    const expected = `└── /
+    const expected = `\
+└── /
     ├── test (GET)
-    │   └── /:hello (GET)
-    └── hello/:world (GET)
+    │   └── /
+    │       └── :hello (GET)
+    └── hello/
+        └── :world (GET)
 `
 
     t.equal(typeof tree, 'string')
@@ -48,6 +87,44 @@ test('pretty print - parametric routes', t => {
   })
 })
 
+test('pretty print - internal tree - parametric routes', t => {
+  t.plan(4)
+
+  const fastify = Fastify({ exposeHeadRoutes: false })
+  fastify.get('/test', () => {})
+  fastify.get('/test/:hello', () => {})
+  fastify.get('/hello/:world', () => {})
+
+  fastify.put('/test', () => {})
+  fastify.put('/test/:hello', () => {})
+
+  fastify.ready(() => {
+    const getTree = fastify.printRoutes({ method: 'GET' })
+    const expectedGetTree = `\
+└── /
+    ├── test (GET)
+    │   └── /
+    │       └── :hello (GET)
+    └── hello/
+        └── :world (GET)
+`
+
+    t.equal(typeof getTree, 'string')
+    t.equal(getTree, expectedGetTree)
+
+    const putTree = fastify.printRoutes({ method: 'PUT' })
+    const expectedPutTree = `\
+└── /
+    └── test (PUT)
+        └── /
+            └── :hello (PUT)
+`
+
+    t.equal(typeof putTree, 'string')
+    t.equal(putTree, expectedPutTree)
+  })
+})
+
 test('pretty print - mixed parametric routes', t => {
   t.plan(2)
 
@@ -60,11 +137,12 @@ test('pretty print - mixed parametric routes', t => {
   fastify.ready(() => {
     const tree = fastify.printRoutes()
 
-    const expected = `└── /test (GET)
-    └── /
-        └── :hello (GET)
-            :hello (POST)
-            └── /world (GET)
+    const expected = `\
+└── /
+    └── test (GET)
+        └── /
+            └── :hello (GET, POST)
+                └── /world (GET)
 `
 
     t.equal(typeof tree, 'string')
@@ -83,10 +161,13 @@ test('pretty print - wildcard routes', t => {
   fastify.ready(() => {
     const tree = fastify.printRoutes()
 
-    const expected = `└── /
+    const expected = `\
+└── /
     ├── test (GET)
-    │   └── /* (GET)
-    └── hello/* (GET)
+    │   └── /
+    │       └── * (GET)
+    └── hello/
+        └── * (GET)
 `
 
     t.equal(typeof tree, 'string')
@@ -94,6 +175,44 @@ test('pretty print - wildcard routes', t => {
   })
 })
 
+test('pretty print - internal tree - wildcard routes', t => {
+  t.plan(4)
+
+  const fastify = Fastify({ exposeHeadRoutes: false })
+  fastify.get('/test', () => {})
+  fastify.get('/test/*', () => {})
+  fastify.get('/hello/*', () => {})
+
+  fastify.put('/*', () => {})
+  fastify.put('/test/*', () => {})
+
+  fastify.ready(() => {
+    const getTree = fastify.printRoutes({ method: 'GET' })
+    const expectedGetTree = `\
+└── /
+    ├── test (GET)
+    │   └── /
+    │       └── * (GET)
+    └── hello/
+        └── * (GET)
+`
+
+    t.equal(typeof getTree, 'string')
+    t.equal(getTree, expectedGetTree)
+
+    const putTree = fastify.printRoutes({ method: 'PUT' })
+    const expectedPutTree = `\
+└── /
+    ├── test/
+    │   └── * (PUT)
+    └── * (PUT)
+`
+
+    t.equal(typeof putTree, 'string')
+    t.equal(putTree, expectedPutTree)
+  })
+})
+
 test('pretty print - empty plugins', t => {
   t.plan(2)
 
@@ -134,17 +253,15 @@ test('pretty print - commonPrefix', t => {
     const radixTree = fastify.printRoutes()
     const flatTree = fastify.printRoutes({ commonPrefix: false })
 
-    const radixExpected = `└── /
-    ├── hel
-    │   ├── lo (GET)
-    │   │   lo (HEAD)
-    │   └── icopter (GET)
-    │       icopter (HEAD)
-    └── hello (PUT)
+    const radixExpected = `\
+└── /
+    └── hel
+        ├── lo (GET, HEAD, PUT)
+        └── icopter (GET, HEAD)
 `
-    const flatExpected = `└── / (-)
-    ├── helicopter (GET, HEAD)
-    └── hello (GET, HEAD, PUT)
+    const flatExpected = `\
+├── /hello (GET, HEAD, PUT)
+└── /helicopter (GET, HEAD)
 `
     t.equal(typeof radixTree, 'string')
     t.equal(typeof flatTree, 'string')
@@ -170,49 +287,64 @@ test('pretty print - includeMeta, includeHooks', t => {
     const flatTree = fastify.printRoutes({ commonPrefix: false, includeHooks: true, includeMeta: ['errorHandler'] })
     const hooksOnly = fastify.printRoutes({ commonPrefix: false, includeHooks: true })
 
-    const radixExpected = `└── /
-    ├── hel
-    │   ├── lo (GET)
-    │   │   • (onTimeout) ["onTimeout()"]
-    │   │   • (onRequest) ["anonymous()"]
-    │   │   • (errorHandler) "defaultErrorHandler()"
-    │   │   lo (HEAD)
-    │   │   • (onTimeout) ["onTimeout()"]
-    │   │   • (onRequest) ["anonymous()"]
-    │   │   • (onSend) ["headRouteOnSendHandler()"]
-    │   │   • (errorHandler) "defaultErrorHandler()"
-    │   └── icopter (GET)
-    │       • (onTimeout) ["onTimeout()"]
-    │       • (onRequest) ["anonymous()"]
-    │       • (errorHandler) "defaultErrorHandler()"
-    │       icopter (HEAD)
-    │       • (onTimeout) ["onTimeout()"]
-    │       • (onRequest) ["anonymous()"]
-    │       • (onSend) ["headRouteOnSendHandler()"]
-    │       • (errorHandler) "defaultErrorHandler()"
-    └── hello (PUT)
-        • (onTimeout) ["onTimeout()"]
-        • (onRequest) ["anonymous()"]
-        • (errorHandler) "defaultErrorHandler()"
+    const radixExpected = `\
+└── /
+    └── hel
+        ├── lo (GET, PUT)
+        │   • (onTimeout) ["onTimeout()"]
+        │   • (onRequest) ["anonymous()"]
+        │   • (errorHandler) "defaultErrorHandler()"
+        │   lo (HEAD)
+        │   • (onTimeout) ["onTimeout()"]
+        │   • (onRequest) ["anonymous()"]
+        │   • (onSend) ["headRouteOnSendHandler()"]
+        │   • (errorHandler) "defaultErrorHandler()"
+        └── icopter (GET)
+            • (onTimeout) ["onTimeout()"]
+            • (onRequest) ["anonymous()"]
+            • (errorHandler) "defaultErrorHandler()"
+            icopter (HEAD)
+            • (onTimeout) ["onTimeout()"]
+            • (onRequest) ["anonymous()"]
+            • (onSend) ["headRouteOnSendHandler()"]
+            • (errorHandler) "defaultErrorHandler()"
 `
-    const flatExpected = `└── / (-)
-    ├── helicopter (GET, HEAD)
-    │   • (onTimeout) ["onTimeout()"]
-    │   • (onRequest) ["anonymous()"]
-    │   • (errorHandler) "defaultErrorHandler()"
-    └── hello (GET, HEAD, PUT)
-        • (onTimeout) ["onTimeout()"]
-        • (onRequest) ["anonymous()"]
-        • (errorHandler) "defaultErrorHandler()"
+    const flatExpected = `\
+├── /hello (GET, PUT)
+│   • (onTimeout) ["onTimeout()"]
+│   • (onRequest) ["anonymous()"]
+│   • (errorHandler) "defaultErrorHandler()"
+│   /hello (HEAD)
+│   • (onTimeout) ["onTimeout()"]
+│   • (onRequest) ["anonymous()"]
+│   • (onSend) ["headRouteOnSendHandler()"]
+│   • (errorHandler) "defaultErrorHandler()"
+└── /helicopter (GET)
+    • (onTimeout) ["onTimeout()"]
+    • (onRequest) ["anonymous()"]
+    • (errorHandler) "defaultErrorHandler()"
+    /helicopter (HEAD)
+    • (onTimeout) ["onTimeout()"]
+    • (onRequest) ["anonymous()"]
+    • (onSend) ["headRouteOnSendHandler()"]
+    • (errorHandler) "defaultErrorHandler()"
 `
 
-    const hooksOnlyExpected = `└── / (-)
-    ├── helicopter (GET, HEAD)
-    │   • (onTimeout) ["onTimeout()"]
-    │   • (onRequest) ["anonymous()"]
-    └── hello (GET, HEAD, PUT)
-        • (onTimeout) ["onTimeout()"]
-        • (onRequest) ["anonymous()"]
+    const hooksOnlyExpected = `\
+├── /hello (GET, PUT)
+│   • (onTimeout) ["onTimeout()"]
+│   • (onRequest) ["anonymous()"]
+│   /hello (HEAD)
+│   • (onTimeout) ["onTimeout()"]
+│   • (onRequest) ["anonymous()"]
+│   • (onSend) ["headRouteOnSendHandler()"]
+└── /helicopter (GET)
+    • (onTimeout) ["onTimeout()"]
+    • (onRequest) ["anonymous()"]
+    /helicopter (HEAD)
+    • (onTimeout) ["onTimeout()"]
+    • (onRequest) ["anonymous()"]
+    • (onSend) ["headRouteOnSendHandler()"]
 `
     t.equal(typeof radixTree, 'string')
     t.equal(typeof flatTree, 'string')

package/test/schema-feature.test.js

@@ -253,6 +253,91 @@ test('Should not change the input schemas', t => {
   })
 })
 
+test('Should throw if the schema body is undefined', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.get('/:id', {
+    handler: echoParams,
+    schema: {
+      body: undefined
+    }
+  })
+
+  fastify.ready(err => {
+    t.equal(err.code, 'FST_ERR_SCH_VALIDATION_BUILD')
+    t.equal(err.message, 'Failed building the validation schema for GET: /:id, due to error body schema is undefined')
+  })
+})
+
+test('Should throw if the schema headers is undefined', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.get('/:id', {
+    handler: echoParams,
+    schema: {
+      headers: undefined
+    }
+  })
+
+  fastify.ready(err => {
+    t.equal(err.code, 'FST_ERR_SCH_VALIDATION_BUILD')
+    t.equal(err.message, 'Failed building the validation schema for GET: /:id, due to error headers schema is undefined')
+  })
+})
+
+test('Should throw if the schema params is undefined', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.get('/:id', {
+    handler: echoParams,
+    schema: {
+      params: undefined
+    }
+  })
+
+  fastify.ready(err => {
+    t.equal(err.code, 'FST_ERR_SCH_VALIDATION_BUILD')
+    t.equal(err.message, 'Failed building the validation schema for GET: /:id, due to error params schema is undefined')
+  })
+})
+
+test('Should throw if the schema query is undefined', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.get('/:id', {
+    handler: echoParams,
+    schema: {
+      querystring: undefined
+    }
+  })
+
+  fastify.ready(err => {
+    t.equal(err.code, 'FST_ERR_SCH_VALIDATION_BUILD')
+    t.equal(err.message, 'Failed building the validation schema for GET: /:id, due to error querystring schema is undefined')
+  })
+})
+
+test('Should throw if the schema query is undefined', t => {
+  t.plan(2)
+  const fastify = Fastify()
+
+  fastify.get('/:id', {
+    handler: echoParams,
+    schema: {
+      querystring: undefined
+    }
+  })
+
+  fastify.ready(err => {
+    t.equal(err.code, 'FST_ERR_SCH_VALIDATION_BUILD')
+    t.equal(err.message, 'Failed building the validation schema for GET: /:id, due to error querystring schema is undefined')
+  })
+})
+
 test('First level $ref', t => {
   t.plan(2)
   const fastify = Fastify()

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

@@ -284,6 +284,8 @@ expectType<string>(server.printRoutes({ includeHooks: true, commonPrefix: false,
 
 expectType<string>(server.printRoutes({ includeMeta: ['key1', Symbol('key2')] }))
 
+expectType<string>(server.printRoutes({ method: 'GET' }))
+
 expectType<string>(server.printRoutes())
 
 server.decorate<(x: string) => void>('test', function (x: string): void {

package/types/errors.d.ts

@@ -20,6 +20,7 @@ export type FastifyErrorCodes = Record<
 'FST_ERR_MISSING_MIDDLEWARE' |
 'FST_ERR_HOOK_TIMEOUT' |
 'FST_ERR_LOG_INVALID_DESTINATION' |
+'FST_ERR_LOG_INVALID_LOGGER' |
 'FST_ERR_REP_INVALID_PAYLOAD_TYPE' |
 'FST_ERR_REP_ALREADY_SENT' |
 'FST_ERR_REP_SENT_VALUE'|

package/types/instance.d.ts

@@ -20,10 +20,11 @@ import {
   FastifyTypeProvider,
   FastifyTypeProviderDefault
 } from './type-provider'
-import { ContextConfigDefault, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault } from './utils'
+import { HTTPMethods, ContextConfigDefault, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault } from './utils'
 import { AddressInfo } from 'net'
 
 export interface PrintRoutesOptions {
+  method?: HTTPMethods;
   includeMeta?: boolean | (string | symbol)[]
   commonPrefix?: boolean
   includeHooks?: boolean