fastify 4.28.0 → 5.0.0-alpha.2

package/test/route-shorthand.test.js

@@ -0,0 +1,60 @@
+'use strict'
+
+const t = require('tap')
+const test = t.test
+const sget = require('simple-get').concat
+const Fastify = require('../fastify')
+const supportedMethods = require('../lib/httpMethods').supportedMethods
+
+test('route-shorthand', t => {
+  t.plan(supportedMethods.length + 1)
+  const test = t.test
+
+  for (const method of supportedMethods) {
+    test(`route-shorthand - ${method.toLowerCase()}`, t => {
+      t.plan(3)
+      const fastify = new Fastify()
+      fastify[method.toLowerCase()]('/', function (req, reply) {
+        t.equal(req.method, method)
+        reply.send()
+      })
+      fastify.listen({ port: 0 }, function (err) {
+        if (err) t.error(err)
+        t.teardown(() => { fastify.close() })
+        sget({
+          method,
+          url: 'http://localhost:' + fastify.server.address().port
+        }, (err, response, body) => {
+          t.error(err)
+          t.equal(response.statusCode, 200)
+        })
+      })
+    })
+  }
+
+  test('route-shorthand - all', t => {
+    t.plan(3 * supportedMethods.length)
+    const fastify = new Fastify()
+    let currentMethod = ''
+    fastify.all('/', function (req, reply) {
+      t.equal(req.method, currentMethod)
+      reply.send()
+    })
+    fastify.listen({ port: 0 }, async function (err) {
+      if (err) t.error(err)
+      t.teardown(() => { fastify.close() })
+      for (const method of supportedMethods) {
+        currentMethod = method
+        await new Promise(resolve => sget({
+          method,
+          url: 'http://localhost:' + fastify.server.address().port
+        }, (err, response, body) => {
+          t.error(err)
+          t.equal(response.statusCode, 200)
+          resolve()
+        })
+        )
+      }
+    })
+  })
+})

package/test/schema-special-usage.test.js

@@ -704,7 +704,7 @@ test('Custom schema object should not trigger FST_ERR_SCH_DUPLICATE', async t =>
 })
 
 test('The default schema compilers should not be called when overwritten by the user', async t => {
-  const Fastify = t.mock('../', {
+  const Fastify = t.mockRequire('../', {
     '@fastify/ajv-compiler': () => {
       t.fail('The default validator compiler should not be called')
     },

package/test/server.test.js

@@ -3,7 +3,7 @@
 const t = require('tap')
 const test = t.test
 const Fastify = require('..')
-const semver = require('semver')
+const sget = require('simple-get').concat
 const undici = require('undici')
 
 test('listen should accept null port', t => {
@@ -72,7 +72,22 @@ test('listen should reject string port', async (t) => {
   }
 })
 
-test('abort signal', { skip: semver.lt(process.version, '16.0.0') }, t => {
+test('Test for hostname and port', t => {
+  const app = Fastify()
+  t.teardown(app.close.bind(app))
+  app.get('/host', (req, res) => {
+    const host = 'localhost:8000'
+    t.equal(req.host, host)
+    t.equal(req.hostname, req.host.split(':')[0])
+    t.equal(req.port, Number(req.host.split(':')[1]))
+    res.send('ok')
+  })
+  app.listen({ port: 8000 }, () => {
+    sget('http://localhost:8000/host', () => { t.end() })
+  })
+})
+
+test('abort signal', t => {
   t.test('listen should not start server', t => {
     t.plan(2)
     function onClose (instance, done) {

package/test/stream.2.test.js

@@ -68,7 +68,7 @@ test('onSend hook stream should work even if payload is not a proper stream', t
     child: () => { return spyLogger }
   }
 
-  const fastify = Fastify({ logger: spyLogger })
+  const fastify = Fastify({ loggerInstance: spyLogger })
   fastify.get('/', function (req, reply) {
     reply.send({ hello: 'world' })
   })

package/test/stream.4.test.js

@@ -3,16 +3,12 @@
 const t = require('tap')
 const test = t.test
 const sget = require('simple-get').concat
-const fs = require('node:fs')
 const errors = require('http-errors')
 const JSONStream = require('JSONStream')
-const send = require('send')
 const Readable = require('node:stream').Readable
 const split = require('split2')
-const semver = require('semver')
 const Fastify = require('..')
 const { kDisableRequestLogging } = require('../lib/symbols.js')
-const { getServerUrl } = require('./helper')
 
 test('Destroying streams prematurely should call abort method', t => {
   t.plan(7)
@@ -183,41 +179,3 @@ test('return a 404 if the stream emits a 404 error', t => {
     })
   })
 })
-
-test('should support send module 200 and 404', { skip: semver.gte(process.versions.node, '17.0.0') }, t => {
-  t.plan(8)
-  const fastify = Fastify()
-
-  fastify.get('/', function (req, reply) {
-    const stream = send(req.raw, __filename)
-    reply.code(200).send(stream)
-  })
-
-  fastify.get('/error', function (req, reply) {
-    const stream = send(req.raw, 'non-existing-file')
-    reply.code(200).send(stream)
-  })
-
-  fastify.listen({ port: 0 }, err => {
-    t.error(err)
-    t.teardown(() => { fastify.close() })
-
-    const url = getServerUrl(fastify)
-
-    sget(url, function (err, response, data) {
-      t.error(err)
-      t.equal(response.headers['content-type'], 'application/javascript; charset=UTF-8')
-      t.equal(response.statusCode, 200)
-
-      fs.readFile(__filename, (err, expected) => {
-        t.error(err)
-        t.equal(expected.toString(), data.toString())
-      })
-    })
-
-    sget(url + '/error', function (err, response) {
-      t.error(err)
-      t.equal(response.statusCode, 404)
-    })
-  })
-})

package/test/stream.5.test.js

@@ -88,7 +88,7 @@ test('reply.send handles aborted requests', t => {
     child: () => { return spyLogger }
   }
   const fastify = Fastify({
-    logger: spyLogger
+    loggerInstance: spyLogger
   })
 
   fastify.get('/', (req, reply) => {
@@ -136,7 +136,7 @@ test('request terminated should not crash fastify', t => {
     child: () => { return spyLogger }
   }
   const fastify = Fastify({
-    logger: spyLogger
+    loggerInstance: spyLogger
   })
 
   fastify.get('/', async (req, reply) => {

package/test/trust-proxy.test.js

@@ -26,9 +26,11 @@ const testRequestValues = (t, req, options) => {
     t.ok(req.ip, 'ip is defined')
     t.equal(req.ip, options.ip, 'gets ip from x-forwarded-for')
   }
-  if (options.hostname) {
-    t.ok(req.hostname, 'hostname is defined')
-    t.equal(req.hostname, options.hostname, 'gets hostname from x-forwarded-host')
+  if (options.host) {
+    t.ok(req.host, 'host is defined')
+    t.equal(req.host, options.host, 'gets host from x-forwarded-host')
+    t.ok(req.hostname)
+    t.equal(req.hostname, options.host, 'gets hostname from x-forwarded-host')
   }
   if (options.ips) {
     t.same(req.ips, options.ips, 'gets ips from x-forwarded-for')
@@ -37,6 +39,10 @@ const testRequestValues = (t, req, options) => {
     t.ok(req.protocol, 'protocol is defined')
     t.equal(req.protocol, options.protocol, 'gets protocol from x-forwarded-proto')
   }
+  if (options.port) {
+    t.ok(req.port, 'port is defined')
+    t.equal(req.port, options.port, 'port is taken from x-forwarded-for or host')
+  }
 }
 
 let localhost
@@ -45,18 +51,18 @@ before(async function () {
 })
 
 test('trust proxy, not add properties to node req', (t) => {
-  t.plan(8)
+  t.plan(14)
   const app = fastify({
     trustProxy: true
   })
   app.get('/trustproxy', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', hostname: 'example.com' })
-    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+    testRequestValues(t, req, { ip: '1.1.1.1', host: 'example.com', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   app.get('/trustproxychain', function (req, reply) {
-    testRequestValues(t, req, { ip: '2.2.2.2', ips: [localhost, '1.1.1.1', '2.2.2.2'] })
-    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+    testRequestValues(t, req, { ip: '2.2.2.2', ips: [localhost, '1.1.1.1', '2.2.2.2'], port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   t.teardown(app.close.bind(app))
@@ -70,14 +76,14 @@ test('trust proxy, not add properties to node req', (t) => {
 })
 
 test('trust proxy chain', (t) => {
-  t.plan(3)
+  t.plan(9)
   const app = fastify({
     trustProxy: [localhost, '192.168.1.1']
   })
 
   app.get('/trustproxychain', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1' })
-    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+    testRequestValues(t, req, { ip: '1.1.1.1', host: 'example.com', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   t.teardown(app.close.bind(app))
@@ -90,13 +96,13 @@ test('trust proxy chain', (t) => {
 })
 
 test('trust proxy function', (t) => {
-  t.plan(3)
+  t.plan(9)
   const app = fastify({
     trustProxy: (address) => address === localhost
   })
   app.get('/trustproxyfunc', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1' })
-    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+    testRequestValues(t, req, { ip: '1.1.1.1', host: 'example.com', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   t.teardown(app.close.bind(app))
@@ -109,13 +115,13 @@ test('trust proxy function', (t) => {
 })
 
 test('trust proxy number', (t) => {
-  t.plan(4)
+  t.plan(10)
   const app = fastify({
     trustProxy: 1
   })
   app.get('/trustproxynumber', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'] })
-    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'], host: 'example.com', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   t.teardown(app.close.bind(app))
@@ -128,13 +134,13 @@ test('trust proxy number', (t) => {
 })
 
 test('trust proxy IP addresses', (t) => {
-  t.plan(4)
+  t.plan(10)
   const app = fastify({
     trustProxy: `${localhost}, 2.2.2.2`
   })
   app.get('/trustproxyipaddrs', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'] })
-    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+    testRequestValues(t, req, { ip: '1.1.1.1', ips: [localhost, '1.1.1.1'], host: 'example.com', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   t.teardown(app.close.bind(app))
@@ -147,21 +153,21 @@ test('trust proxy IP addresses', (t) => {
 })
 
 test('trust proxy protocol', (t) => {
-  t.plan(13)
+  t.plan(31)
   const app = fastify({
     trustProxy: true
   })
   app.get('/trustproxyprotocol', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'lorem' })
-    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'lorem', host: 'example.com', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
   })
   app.get('/trustproxynoprotocol', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'http' })
-    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'http', host: 'example.com', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
   })
   app.get('/trustproxyprotocols', function (req, reply) {
-    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'dolor' })
-    reply.code(200).send({ ip: req.ip, hostname: req.hostname })
+    testRequestValues(t, req, { ip: '1.1.1.1', protocol: 'dolor', host: 'example.com', port: app.server.address().port })
+    reply.code(200).send({ ip: req.ip, host: req.host })
   })
 
   t.teardown(app.close.bind(app))

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

@@ -59,8 +59,6 @@ expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_FORCE_CLOSE_CONNECT
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DUPLICATED_ROUTE)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_BAD_URL)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ASYNC_CONSTRAINT)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_DEFAULT_ROUTE_INVALID_TYPE)
-expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_INVALID_URL)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_OPTIONS_NOT_OBJ)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_DUPLICATED_HANDLER)
 expectAssignable<FastifyErrorConstructor>(errorCodes.FST_ERR_ROUTE_HANDLER_NOT_FN)

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

@@ -11,30 +11,32 @@ import fastify, {
   RawRequestDefaultExpression,
   RouteGenericInterface,
   FastifyErrorCodes,
-  FastifyError
+  FastifyError,
+  SafePromiseLike
 } from '../../fastify'
 import { ErrorObject as AjvErrorObject } from 'ajv'
 import * as http from 'http'
 import * as https from 'https'
 import * as http2 from 'http2'
 import { expectType, expectError, expectAssignable, expectNotAssignable } from 'tsd'
-import { FastifyLoggerInstance } from '../../types/logger'
 import { Socket } from 'net'
 
 // FastifyInstance
 // http server
-expectType<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>>(fastify())
-expectType<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({}))
-expectType<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({ http: {} }))
+expectError<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> & Promise<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>>(fastify())
+expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>>(fastify())
+expectType<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> & SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>>(fastify())
+expectType<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> & SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({}))
+expectType<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse> & SafePromiseLike<FastifyInstance<http.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({ http: {} }))
 // https server
-expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({ https: {} }))
-expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({ https: null }))
+expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({ https: {} }))
+expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({ https: null }))
 // http2 server
-expectType<FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse> & PromiseLike<FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse>>>(fastify({ http2: true, http2SessionTimeout: 1000 }))
-expectType<FastifyInstance<http2.Http2SecureServer, http2.Http2ServerRequest, http2.Http2ServerResponse> & PromiseLike<FastifyInstance<http2.Http2SecureServer, http2.Http2ServerRequest, http2.Http2ServerResponse>>>(fastify({ http2: true, https: {}, http2SessionTimeout: 1000 }))
+expectType<FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse> & SafePromiseLike<FastifyInstance<http2.Http2Server, http2.Http2ServerRequest, http2.Http2ServerResponse>>>(fastify({ http2: true, http2SessionTimeout: 1000 }))
+expectType<FastifyInstance<http2.Http2SecureServer, http2.Http2ServerRequest, http2.Http2ServerResponse> & SafePromiseLike<FastifyInstance<http2.Http2SecureServer, http2.Http2ServerRequest, http2.Http2ServerResponse>>>(fastify({ http2: true, https: {}, http2SessionTimeout: 1000 }))
 expectType<LightMyRequestChain>(fastify({ http2: true, https: {} }).inject())
-expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({ schemaController: {} }))
-expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(
+expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(fastify({ schemaController: {} }))
+expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(
   fastify({
     schemaController: {
       compilersFactory: {}
@@ -92,7 +94,7 @@ expectAssignable<FastifyInstance<http.Server, http.IncomingMessage, http.ServerR
           method: 'GET',
           url: '/',
           version: '1.0.0',
-          hostname: 'localhost',
+          host: 'localhost',
           remoteAddress: '127.0.0.1',
           remotePort: 3000
         }

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

@@ -14,6 +14,7 @@ import fastify, {
   RegisterOptions,
   RouteOptions,
   // preClose hook types should be exported correctly https://github.com/fastify/fastify/pull/5335
+  /* eslint-disable @typescript-eslint/no-unused-vars */
   preCloseAsyncHookHandler,
   preCloseHookHandler
 } from '../../fastify'

package/test/types/import.ts

@@ -1 +1,2 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import { FastifyListenOptions, FastifyLogFn } from '../../fastify'

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

@@ -1,4 +1,4 @@
-import { expectAssignable, expectDeprecated, expectError, expectNotDeprecated, expectType } from 'tsd'
+import { expectAssignable, expectError, expectNotDeprecated, expectType } from 'tsd'
 import fastify, {
   FastifyBaseLogger,
   FastifyBodyParser,
@@ -12,7 +12,6 @@ import fastify, {
 import { HookHandlerDoneFunction } from '../../types/hooks'
 import { FastifyReply } from '../../types/reply'
 import { FastifyRequest } from '../../types/request'
-import { DefaultRoute } from '../../types/route'
 import { FastifySchemaControllerOptions, FastifySchemaCompiler, FastifySerializerCompiler } from '../../types/schema'
 import { AddressInfo } from 'net'
 import { Bindings, ChildLoggerOptions } from '../../types/logger'
@@ -194,48 +193,6 @@ function invalidSchemaErrorFormatter (err: Error) {
 }
 expectError(server.setSchemaErrorFormatter(invalidSchemaErrorFormatter))
 
-// test listen method callback
-expectAssignable<void>(server.listen(3000, '', 0, (err, address) => {
-  expectType<Error | null>(err)
-}))
-expectAssignable<void>(server.listen('3000', '', 0, (err, address) => {
-  expectType<Error | null>(err)
-}))
-expectAssignable<void>(server.listen(3000, '', (err, address) => {
-  expectType<Error | null>(err)
-}))
-expectAssignable<void>(server.listen('3000', '', (err, address) => {
-  expectType<Error | null>(err)
-}))
-expectAssignable<void>(server.listen(3000, (err, address) => {
-  expectType<Error | null>(err)
-}))
-expectAssignable<void>(server.listen('3000', (err, address) => {
-  expectType<Error | null>(err)
-}))
-
-// test listen method callback types
-expectAssignable<void>(server.listen('3000', (err, address) => {
-  expectAssignable<Error|null>(err)
-  expectAssignable<string>(address)
-}))
-
-// test listen method promise
-expectAssignable<PromiseLike<string>>(server.listen(3000))
-expectAssignable<PromiseLike<string>>(server.listen('3000'))
-expectAssignable<PromiseLike<string>>(server.listen(3000, '', 0))
-expectAssignable<PromiseLike<string>>(server.listen('3000', '', 0))
-expectAssignable<PromiseLike<string>>(server.listen(3000, ''))
-expectAssignable<PromiseLike<string>>(server.listen('3000', ''))
-
-// Test variadic listen signatures Typescript deprecation
-expectDeprecated(server.listen(3000))
-expectDeprecated(server.listen('3000'))
-expectDeprecated(server.listen(3000, '', 0))
-expectDeprecated(server.listen('3000', '', 0))
-expectDeprecated(server.listen(3000, ''))
-expectDeprecated(server.listen('3000', ''))
-
 // test listen opts objects
 expectAssignable<PromiseLike<string>>(server.listen())
 expectAssignable<PromiseLike<string>>(server.listen({ port: 3000 }))
@@ -279,6 +236,12 @@ expectAssignable<FastifyInstance>(server.ready())
 expectAssignable<FastifyInstance>(server.ready((err) => {
   expectType<Error | null>(err)
 }))
+expectAssignable<FastifyInstance>(server.ready(async (err) => {
+  expectType<Error | null>(err)
+}))
+expectAssignable<Parameters<typeof server.ready>[0]>(async (err) => {
+  expectType<Error | null>(err)
+})
 
 expectAssignable<void>(server.routing({} as RawRequestDefaultExpression, {} as RawReplyDefaultExpression))
 
@@ -453,7 +416,7 @@ server.decorate('typedTestProperty', {
 })
 server.decorate('typedTestProperty')
 server.decorate('typedTestProperty', null, ['foo'])
-server.decorate('typedTestProperty', null)
+expectError(server.decorate('typedTestProperty', null))
 expectError(server.decorate('typedTestProperty', 'foo'))
 expectError(server.decorate('typedTestProperty', {
   getter () {
@@ -493,7 +456,7 @@ server.decorateRequest('typedTestRequestProperty', {
 })
 server.decorateRequest('typedTestRequestProperty')
 server.decorateRequest('typedTestRequestProperty', null, ['foo'])
-server.decorateRequest('typedTestRequestProperty', null)
+expectError(server.decorateRequest('typedTestRequestProperty', null))
 expectError(server.decorateRequest('typedTestRequestProperty', 'foo'))
 expectError(server.decorateRequest('typedTestRequestProperty', {
   getter () {
@@ -533,7 +496,7 @@ server.decorateReply('typedTestReplyProperty', {
 })
 server.decorateReply('typedTestReplyProperty')
 server.decorateReply('typedTestReplyProperty', null, ['foo'])
-server.decorateReply('typedTestReplyProperty', null)
+expectError(server.decorateReply('typedTestReplyProperty', null))
 expectError(server.decorateReply('typedTestReplyProperty', 'foo'))
 expectError(server.decorateReply('typedTestReplyProperty', {
   getter () {
@@ -570,9 +533,5 @@ const versionConstraintStrategy = {
 expectType<void>(server.addConstraintStrategy(versionConstraintStrategy))
 expectType<boolean>(server.hasConstraintStrategy(versionConstraintStrategy.name))
 
-expectType<boolean>(server.hasPlugin(''))
-
-expectAssignable<DefaultRoute<RawRequestDefaultExpression, RawReplyDefaultExpression>>(server.getDefaultRoute())
-
 expectType<FastifySchemaCompiler<any> | undefined>(server.validatorCompiler)
 expectType<FastifySerializerCompiler<any> | undefined>(server.serializerCompiler)

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

@@ -5,8 +5,7 @@ import fastify, {
   FastifyLoggerInstance,
   FastifyRequest,
   FastifyReply,
-  FastifyBaseLogger,
-  FastifyInstance
+  FastifyBaseLogger
 } from '../../fastify'
 import { Server, IncomingMessage, ServerResponse } from 'http'
 import * as fs from 'fs'
@@ -121,14 +120,52 @@ const serverAutoInferringTypes = fastify({
 
 expectType<FastifyBaseLogger>(serverAutoInferringTypes.log)
 
-const serverWithAutoInferredPino = fastify({
-  logger: P({
+const serverWithLoggerInstance = fastify({
+  loggerInstance: P({
     level: 'info',
     redact: ['x-userinfo']
   })
 })
 
-expectType<P.Logger>(serverWithAutoInferredPino.log)
+expectType<P.Logger>(serverWithLoggerInstance.log)
+
+const serverWithPinoConfig = fastify({
+  logger: {
+    level: 'info',
+    serializers: {
+      req (IncomingMessage) {
+        expectType<FastifyRequest>(IncomingMessage)
+        return {
+          method: 'method',
+          url: 'url',
+          version: 'version',
+          host: 'hostname',
+          remoteAddress: 'remoteAddress',
+          remotePort: 80,
+          other: ''
+        }
+      },
+      res (ServerResponse) {
+        expectType<ResSerializerReply<Server, FastifyReply>>(ServerResponse)
+        expectAssignable<Partial<FastifyReply> & Pick<FastifyReply, 'statusCode'>>(ServerResponse)
+        expectNotAssignable<FastifyReply>(ServerResponse)
+        return {
+          statusCode: 'statusCode'
+        }
+      },
+      err (FastifyError) {
+        return {
+          other: '',
+          type: 'type',
+          message: 'msg',
+          stack: 'stack'
+        }
+      }
+    }
+  }
+})
+
+expectType<FastifyBaseLogger>(serverWithPinoConfig.log)
 
 const serverAutoInferredFileOption = fastify({
   logger: {
@@ -165,7 +202,7 @@ const serverAutoInferredSerializerObjectOption = fastify({
           method: 'method',
           url: 'url',
           version: 'version',
-          hostname: 'hostname',
+          host: 'hostname',
           remoteAddress: 'remoteAddress',
           remotePort: 80,
           other: ''

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

@@ -1,4 +1,4 @@
-import fastify, { FastifyInstance, FastifyPluginOptions } from '../../fastify'
+import fastify, { FastifyInstance, FastifyPluginOptions, SafePromiseLike } from '../../fastify'
 import * as http from 'http'
 import * as https from 'https'
 import { expectType, expectError, expectAssignable } from 'tsd'
@@ -42,7 +42,9 @@ expectAssignable<FastifyInstance>(fastify().register(async function (instance, o
 expectError(fastify().register(function (instance, opts, done) { }, { logLevel: '' })) // must use a valid logLevel
 
 const httpsServer = fastify({ https: {} })
-expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(httpsServer)
+expectError<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & Promise<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(httpsServer)
+expectAssignable<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & PromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(httpsServer)
+expectType<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse> & SafePromiseLike<FastifyInstance<https.Server, http.IncomingMessage, http.ServerResponse>>>(httpsServer)
 
 // Chainable
 httpsServer
@@ -61,6 +63,7 @@ expectAssignable<PromiseLike<undefined>>(httpsServer.register(testPluginOptsWith
 expectAssignable<PromiseLike<undefined>>(httpsServer.register(testPluginOptsWithType, { prefix: '/test' }))
 expectAssignable<PromiseLike<undefined>>(httpsServer.register(testPluginOptsWithTypeAsync, { prefix: '/test' }))
 
+/* eslint-disable @typescript-eslint/no-unused-vars */
 async function testAsync (): Promise<void> {
   await httpsServer
     .register(testPluginOpts)

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

@@ -72,7 +72,7 @@ expectAssignable<ServerWithHttp2>(serverWithHttp2.register(async (instance: Serv
 }))
 
 // With Type Provider
-type TestTypeProvider = { input: 'test', output: 'test' }
+type TestTypeProvider = { schema: 'test', validator: 'test', serializer: 'test' }
 const serverWithTypeProvider = fastify().withTypeProvider<TestTypeProvider>()
 type ServerWithTypeProvider = FastifyInstance<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance, TestTypeProvider>
 const testPluginWithTypeProvider: FastifyPluginCallback<TestOptions, RawServerDefault, TestTypeProvider> = function (instance, opts, done) { }
@@ -115,7 +115,7 @@ const customLogger = {
   silent: () => { }
 }
 const serverWithTypeProviderAndLogger = fastify({
-  logger: customLogger
+  loggerInstance: customLogger
 }).withTypeProvider<TestTypeProvider>()
 type ServerWithTypeProviderAndLogger = FastifyInstance<Server, IncomingMessage, ServerResponse, typeof customLogger, TestTypeProvider>
 const testPluginWithTypeProviderAndLogger: FastifyPluginCallback<TestOptions, RawServerDefault, TestTypeProvider, typeof customLogger> = function (instance, opts, done) { }