fastify 4.0.3 → 4.2.1

package/lib/route.js

@@ -8,7 +8,7 @@ const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTI
 const { normalizeSchema } = require('./schemas')
 const { parseHeadOnSendHandlers } = require('./headRoute')
 const warning = require('./warnings')
-const { kRequestAcceptVersion } = require('./symbols')
+const { kRequestAcceptVersion, kRouteByFastify } = require('./symbols')
 
 const {
   compileSchemasForValidation,
@@ -113,7 +113,7 @@ function buildRouting (options) {
   }
 
   // Convert shorthand to extended route declaration
-  function prepareRoute (method, url, options, handler) {
+  function prepareRoute ({ method, url, options, handler, isFastify }) {
     if (typeof url !== 'string') {
       throw new FST_ERR_INVALID_URL(typeof url)
     }
@@ -140,11 +140,11 @@ function buildRouting (options) {
       handler: handler || (options && options.handler)
     })
 
-    return route.call(this, options)
+    return route.call(this, { options, isFastify })
   }
 
   // Route management
-  function route (options) {
+  function route ({ options, isFastify }) {
     // Since we are mutating/assigning only top level props, it is fine to have a shallow copy using the spread operator
     const opts = { ...options }
 
@@ -176,30 +176,30 @@ function buildRouting (options) {
     if (path === '/' && prefix.length > 0 && opts.method !== 'HEAD') {
       switch (opts.prefixTrailingSlash) {
         case 'slash':
-          addNewRoute.call(this, path)
+          addNewRoute.call(this, { path, isFastify })
           break
         case 'no-slash':
-          addNewRoute.call(this, '')
+          addNewRoute.call(this, { path: '', isFastify })
           break
         case 'both':
         default:
-          addNewRoute.call(this, '')
+          addNewRoute.call(this, { path: '', isFastify })
           // If ignoreTrailingSlash is set to true we need to add only the '' route to prevent adding an incomplete one.
           if (ignoreTrailingSlash !== true && (ignoreDuplicateSlashes !== true || !prefix.endsWith('/'))) {
-            addNewRoute.call(this, path, true)
+            addNewRoute.call(this, { path, prefixing: true, isFastify })
           }
       }
     } else if (path[0] === '/' && prefix.endsWith('/')) {
       // Ensure that '/prefix/' + '/route' gets registered as '/prefix/route'
-      addNewRoute.call(this, path.slice(1))
+      addNewRoute.call(this, { path: path.slice(1), isFastify })
     } else {
-      addNewRoute.call(this, path)
+      addNewRoute.call(this, { path, isFastify })
     }
 
     // chainable api
     return this
 
-    function addNewRoute (path, prefixing = false) {
+    function addNewRoute ({ path, prefixing = false, isFastify = false }) {
       const url = prefix + path
 
       opts.url = url
@@ -241,7 +241,8 @@ function buildRouting (options) {
         attachValidation: opts.attachValidation,
         schemaErrorFormatter: opts.schemaErrorFormatter,
         replySerializer: this[kReplySerializerDefault],
-        server: this
+        server: this,
+        isFastify
       })
 
       if (opts.version) {
@@ -249,13 +250,20 @@ function buildRouting (options) {
         constraints.version = opts.version
       }
 
-      const headRouteExists = opts.method === 'HEAD' && router.find(opts.method, opts.url, constraints) != null
+      const headHandler = router.find('HEAD', opts.url, constraints)
+      const hasHEADHandler = headHandler != null
 
-      // Check if the current route is not for a sibling HEAD one
-      if (!headRouteExists) {
-        try {
-          router.on(opts.method, opts.url, { constraints }, routeHandler, context)
-        } catch (error) {
+      // remove the head route created by fastify
+      if (hasHEADHandler && !context[kRouteByFastify] && headHandler.store[kRouteByFastify]) {
+        router.off(opts.method, opts.url, { constraints })
+      }
+
+      try {
+        router.on(opts.method, opts.url, { constraints }, routeHandler, context)
+      } catch (error) {
+        // any route insertion error created by fastify can be safely ignore
+        // because it only duplicate route for head
+        if (!context[kRouteByFastify]) {
           const isDuplicatedRoute = error.message.includes(`Method '${opts.method}' already declared for route '${opts.url}'`)
           if (isDuplicatedRoute) {
             throw new FST_ERR_DUPLICATED_ROUTE(opts.method, opts.url)
@@ -320,19 +328,21 @@ function buildRouting (options) {
           }
         })
 
-        const { exposeHeadRoute } = opts
-        const hasRouteExposeHeadRouteFlag = exposeHeadRoute != null
-        const shouldExposeHead = hasRouteExposeHeadRouteFlag ? exposeHeadRoute : globalExposeHeadRoutes
-
-        if (shouldExposeHead && options.method === 'GET' && !headRouteExists) {
-          const onSendHandlers = parseHeadOnSendHandlers(opts.onSend)
-          prepareRoute.call(this, 'HEAD', path, { ...opts, onSend: onSendHandlers })
-        } else if (headRouteExists && exposeHeadRoute) {
-          warning.emit('FSTDEP007')
-        }
-
         done(notHandledErr)
       })
+
+      // register head route in sync
+      // we must place it after the `this.after`
+      const { exposeHeadRoute } = opts
+      const hasRouteExposeHeadRouteFlag = exposeHeadRoute != null
+      const shouldExposeHead = hasRouteExposeHeadRouteFlag ? exposeHeadRoute : globalExposeHeadRoutes
+
+      if (shouldExposeHead && options.method === 'GET' && !hasHEADHandler) {
+        const onSendHandlers = parseHeadOnSendHandlers(opts.onSend)
+        prepareRoute.call(this, { method: 'HEAD', url: path, options: { ...opts, onSend: onSendHandlers }, isFastify: true })
+      } else if (hasHEADHandler && exposeHeadRoute) {
+        warning.emit('FSTDEP007')
+      }
     }
   }
 

package/lib/symbols.js

@@ -47,7 +47,8 @@ const keys = {
   kTestInternals: Symbol('fastify.testInternals'),
   kErrorHandler: Symbol('fastify.errorHandler'),
   kHasBeenDecorated: Symbol('fastify.hasBeenDecorated'),
-  kKeepAliveConnections: Symbol('fastify.keepAliveConnections')
+  kKeepAliveConnections: Symbol('fastify.keepAliveConnections'),
+  kRouteByFastify: Symbol('fastify.routeByFastify')
 }
 
 module.exports = keys

package/lib/validation.js

@@ -106,11 +106,13 @@ function validate (context, request) {
 
 function wrapValidationError (result, dataVar, schemaErrorFormatter) {
   if (result instanceof Error) {
+    result.statusCode = result.statusCode || 400
     result.validationContext = result.validationContext || dataVar
     return result
   }
 
   const error = schemaErrorFormatter(result, dataVar)
+  error.statusCode = error.statusCode || 400
   error.validation = result
   error.validationContext = dataVar
   return error

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.0.3",
+  "version": "4.2.1",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -17,7 +17,7 @@
     "lint:markdown": "markdownlint-cli2",
     "lint:standard": "standard | snazzy",
     "lint:typescript": "eslint -c types/.eslintrc.json types/**/*.d.ts test/types/**/*.test-d.ts",
-    "prepublishOnly": "tap --no-check-coverage test/build/**.test.js",
+    "prepublishOnly": "PREPUBLISH=true tap --no-check-coverage test/build/**.test.js",
     "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",
@@ -126,9 +126,9 @@
   "homepage": "https://www.fastify.io/",
   "devDependencies": {
     "@fastify/pre-commit": "^2.0.2",
-    "@sinclair/typebox": "^0.23.5",
+    "@sinclair/typebox": "^0.24.9",
     "@sinonjs/fake-timers": "^9.1.2",
-    "@types/node": "^17.0.38",
+    "@types/node": "^18.0.0",
     "@typescript-eslint/eslint-plugin": "^5.27.0",
     "@typescript-eslint/parser": "^5.27.0",
     "ajv": "^8.11.0",
@@ -146,8 +146,8 @@
     "eslint-plugin-n": "^15.2.0",
     "eslint-plugin-promise": "^6.0.0",
     "fast-json-body": "^1.1.0",
-    "fast-json-stringify": "^4.2.0",
-    "fastify-plugin": "^3.0.1",
+    "fast-json-stringify": "^5.0.0",
+    "fastify-plugin": "^4.0.0",
     "fluent-json-schema": "^3.1.0",
     "form-data": "^4.0.0",
     "frameguard": "^4.0.0",
@@ -170,19 +170,19 @@
     "split2": "^4.1.0",
     "standard": "^17.0.0-2",
     "tap": "^16.2.0",
-    "tsd": "^0.21.0",
+    "tsd": "^0.22.0",
     "typescript": "^4.7.2",
     "undici": "^5.4.0",
     "x-xss-protection": "^2.0.0",
     "yup": "^0.32.11"
   },
   "dependencies": {
-    "@fastify/ajv-compiler": "^3.1.0",
+    "@fastify/ajv-compiler": "^3.1.1",
     "@fastify/error": "^3.0.0",
-    "@fastify/fast-json-stringify-compiler": "^3.0.1",
+    "@fastify/fast-json-stringify-compiler": "^4.0.0",
     "abstract-logging": "^2.0.1",
     "avvio": "^8.1.3",
-    "find-my-way": "^6.3.0",
+    "find-my-way": "^7.0.0",
     "light-my-request": "^5.0.0",
     "pino": "^8.0.0",
     "process-warning": "^2.0.0",

package/test/404s.test.js

@@ -1320,7 +1320,7 @@ test('preHandler option for setNotFoundHandler', t => {
 
   // https://github.com/fastify/fastify/issues/2229
   t.test('preHandler hook in setNotFoundHandler should be called when callNotFound', { timeout: 40000 }, t => {
-    t.plan(2)
+    t.plan(3)
     const fastify = Fastify()
 
     fastify.setNotFoundHandler({
@@ -1333,7 +1333,7 @@ test('preHandler option for setNotFoundHandler', t => {
     })
 
     fastify.post('/', function (req, reply) {
-      reply.callNotFound()
+      t.equal(reply.callNotFound(), reply)
     })
 
     fastify.inject({

package/test/build/error-serializer.test.js

@@ -7,6 +7,10 @@ const path = require('path')
 
 const { code } = require('../../build/build-error-serializer')
 
+function unifyLineBreak (str) {
+  return str.toString().replace(/\r\n/g, '\n')
+}
+
 test('check generated code syntax', async (t) => {
   t.plan(1)
 
@@ -19,10 +23,13 @@ test('check generated code syntax', async (t) => {
   t.equal(result[0].fatalErrorCount, 0)
 })
 
-test('ensure the current error serializer is latest', async (t) => {
+const isPrebublish = !!process.env.PREPUBLISH
+
+test('ensure the current error serializer is latest', { skip: !isPrebublish }, async (t) => {
   t.plan(1)
 
   const current = await fs.promises.readFile(path.resolve('lib/error-serializer.js'))
 
-  t.equal(current.toString(), code)
+  // line break should not be a problem depends on system
+  t.equal(unifyLineBreak(current), unifyLineBreak(code))
 })

package/test/hooks.test.js

@@ -799,6 +799,27 @@ test('onRoute hook with many prefix', t => {
   fastify.ready(err => { t.error(err) })
 })
 
+test('onRoute hook should not be called when it registered after route', t => {
+  t.plan(3)
+  const fastify = Fastify()
+
+  fastify.addHook('onRoute', () => {
+    t.pass()
+  })
+
+  fastify.get('/', function (req, reply) {
+    reply.send()
+  })
+
+  fastify.addHook('onRoute', () => {
+    t.fail('should not be called')
+  })
+
+  fastify.ready(err => {
+    t.error(err)
+  })
+})
+
 test('onResponse hook should log request error', t => {
   t.plan(4)
 

package/test/internals/reply.test.js

@@ -233,6 +233,10 @@ test('within an instance', t => {
     reply.redirect('/')
   })
 
+  fastify.get('/redirect-async', async function (req, reply) {
+    return reply.redirect('/')
+  })
+
   fastify.get('/redirect-code', function (req, reply) {
     reply.redirect(301, '/')
   })
@@ -412,6 +416,14 @@ test('within an instance', t => {
       })
     })
 
+    test('redirect with async function to `/` - 10', t => {
+      t.plan(1)
+
+      http.get('http://localhost:' + fastify.server.address().port + '/redirect-async', function (response) {
+        t.equal(response.statusCode, 302)
+      })
+    })
+
     t.end()
   })
 })

package/test/pretty-print.test.js

@@ -144,7 +144,7 @@ test('pretty print - commonPrefix', t => {
 `
     const flatExpected = `└── / (-)
     ├── helicopter (GET, HEAD)
-    └── hello (GET, PUT, HEAD)
+    └── hello (GET, HEAD, PUT)
 `
     t.equal(typeof radixTree, 'string')
     t.equal(typeof flatTree, 'string')
@@ -200,7 +200,7 @@ test('pretty print - includeMeta, includeHooks', t => {
     │   • (onTimeout) ["onTimeout()"]
     │   • (onRequest) ["anonymous()"]
     │   • (errorHandler) "defaultErrorHandler()"
-    └── hello (GET, PUT, HEAD)
+    └── hello (GET, HEAD, PUT)
         • (onTimeout) ["onTimeout()"]
         • (onRequest) ["anonymous()"]
         • (errorHandler) "defaultErrorHandler()"
@@ -210,7 +210,7 @@ test('pretty print - includeMeta, includeHooks', t => {
     ├── helicopter (GET, HEAD)
     │   • (onTimeout) ["onTimeout()"]
     │   • (onRequest) ["anonymous()"]
-    └── hello (GET, PUT, HEAD)
+    └── hello (GET, HEAD, PUT)
         • (onTimeout) ["onTimeout()"]
         • (onRequest) ["anonymous()"]
 `

package/test/reply-error.test.js

@@ -324,7 +324,7 @@ test('invalid schema - ajv', t => {
 
   fastify.setErrorHandler((err, request, reply) => {
     t.ok(Array.isArray(err.validation))
-    reply.send('error')
+    reply.code(400).send('error')
   })
 
   fastify.inject({

package/test/schema-feature.test.js

@@ -206,7 +206,7 @@ test('Should throw of the schema does not exists in output', t => {
 
   fastify.ready(err => {
     t.equal(err.code, 'FST_ERR_SCH_SERIALIZATION_BUILD')
-    t.match(err.message, /^Failed building the serialization schema for GET: \/:id, due to error Cannot read propert.*/) // error from fast-json-strinfigy
+    t.match(err.message, /^Failed building the serialization schema for GET: \/:id, due to error Cannot find reference.*/) // error from fast-json-strinfigy
   })
 })
 
@@ -826,7 +826,7 @@ test('Validation context in validation result', t => {
     t.equal(err instanceof Error, true)
     t.ok(err.validation, 'detailed errors')
     t.equal(err.validationContext, 'body')
-    reply.send()
+    reply.code(400).send()
   })
   fastify.post('/', {
     handler: echoParams,

package/test/schema-validation.test.js

@@ -4,6 +4,7 @@ const { test } = require('tap')
 const Fastify = require('..')
 
 const AJV = require('ajv')
+const Schema = require('fluent-json-schema')
 
 const customSchemaCompilers = {
   body: new AJV({
@@ -946,3 +947,73 @@ test('Custom AJV settings on different parameters - pt2', t => {
     }
   })
 })
+
+test("The same $id in route's schema must not overwrite others", t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  const UserSchema = Schema.object()
+    .id('http://mydomain.com/user')
+    .title('User schema')
+    .description('Contains all user fields')
+    .prop('id', Schema.integer())
+    .prop('username', Schema.string().minLength(4))
+    .prop('firstName', Schema.string().minLength(1))
+    .prop('lastName', Schema.string().minLength(1))
+    .prop('fullName', Schema.string().minLength(1))
+    .prop('email', Schema.string())
+    .prop('password', Schema.string().minLength(6))
+    .prop('bio', Schema.string())
+
+  const userCreateSchema = UserSchema.only([
+    'username',
+    'firstName',
+    'lastName',
+    'email',
+    'bio',
+    'password',
+    'password_confirm'
+  ])
+    .required([
+      'username',
+      'firstName',
+      'lastName',
+      'email',
+      'bio',
+      'password'
+    ])
+
+  const userPatchSchema = UserSchema.only([
+    'firstName',
+    'lastName',
+    'bio'
+  ])
+
+  fastify
+    .patch('/user/:id', {
+      schema: { body: userPatchSchema },
+      handler: () => { return 'ok' }
+    })
+    .post('/user', {
+      schema: { body: userCreateSchema },
+      handler: () => { return 'ok' }
+    })
+
+  fastify.inject({
+    method: 'POST',
+    url: '/user',
+    body: {}
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.json().message, "body must have required property 'username'")
+  })
+
+  fastify.inject({
+    url: '/user/1',
+    method: 'PATCH',
+    body: {}
+  }, (err, res) => {
+    t.error(err)
+    t.same(res.payload, 'ok')
+  })
+})

package/test/stream.test.js

@@ -770,7 +770,7 @@ test('request terminated should not crash fastify', t => {
 
     reply.send(stream)
 
-    await new Promise((resolve) => { setTimeout(resolve, 6).unref() })
+    await new Promise((resolve) => { setTimeout(resolve, 100).unref() })
 
     stream.push('<h1>should disply on second stream</h1>')
     stream.push(null)

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

@@ -7,8 +7,10 @@ import fastify, {
   LightMyRequestChain,
   LightMyRequestResponse,
   LightMyRequestCallback,
-  InjectOptions, FastifyBaseLogger
+  InjectOptions, FastifyBaseLogger,
+  ValidationResult
 } from '../../fastify'
+import { ErrorObject as AjvErrorObject } from 'ajv'
 import * as http from 'http'
 import * as https from 'https'
 import * as http2 from 'http2'
@@ -192,7 +194,18 @@ expectAssignable<FastifyInstance>(fastify({ frameworkErrors: () => { } }))
 expectAssignable<FastifyInstance>(fastify({
   rewriteUrl: (req) => req.url === '/hi' ? '/hello' : req.url!
 }))
-expectAssignable<FastifyInstance>(fastify({ schemaErrorFormatter: (errors, dataVar) => new Error() }))
+expectAssignable<FastifyInstance>(fastify({
+  schemaErrorFormatter: (errors, dataVar) => {
+    console.log(
+      errors[0].keyword.toLowerCase(),
+      errors[0].message?.toLowerCase(),
+      errors[0].params,
+      errors[0].instancePath.toLowerCase(),
+      errors[0].schemaPath.toLowerCase()
+    )
+    return new Error()
+  }
+}))
 expectAssignable<FastifyInstance>(fastify({
   clientErrorHandler: (err, socket) => {
     expectType<ConnectionError>(err)
@@ -208,3 +221,12 @@ fastify().then(fastifyInstance => expectAssignable<FastifyInstance>(fastifyInsta
 expectAssignable<FastifyPluginAsync>(async () => {})
 expectAssignable<FastifyPluginCallback>(() => {})
 expectAssignable<FastifyPlugin>(() => {})
+
+const ajvErrorObject: AjvErrorObject = {
+  keyword: '',
+  instancePath: '',
+  schemaPath: '',
+  params: {},
+  message: ''
+}
+expectAssignable<ValidationResult>(ajvErrorObject)

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

@@ -11,7 +11,7 @@ import { HookHandlerDoneFunction } from '../../types/hooks'
 import { FastifyReply } from '../../types/reply'
 import { FastifyRequest } from '../../types/request'
 import { DefaultRoute } from '../../types/route'
-import { FastifySchemaControllerOptions } from '../../types/schema'
+import { FastifySchemaControllerOptions, FastifySchemaCompiler, FastifySerializerCompiler } from '../../types/schema'
 
 const server = fastify()
 
@@ -133,7 +133,7 @@ expectError(server.setErrorHandler(invalidErrorHandler))
 server.setSchemaController({
   bucket: (parentSchemas: unknown) => {
     return {
-      addSchema (schema: unknown) {
+      add (schema: unknown) {
         expectType<unknown>(schema)
         expectType<FastifyInstance>(server.addSchema({ type: 'null' }))
         return server.addSchema({ type: 'null' })
@@ -325,3 +325,6 @@ expectType<void>(server.addConstraintStrategy(versionConstraintStrategy))
 expectType<boolean>(server.hasConstraintStrategy(versionConstraintStrategy.name))
 
 expectAssignable<DefaultRoute<RawRequestDefaultExpression, RawReplyDefaultExpression>>(server.getDefaultRoute())
+
+expectType<FastifySchemaCompiler<any> | undefined>(server.validatorCompiler)
+expectType<FastifySerializerCompiler<any> | undefined>(server.serializerCompiler)

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

@@ -1,7 +1,21 @@
 import { expectAssignable, expectError, expectType } from 'tsd'
-import fastify, { FastifyInstance, FastifyPluginAsync } from '../../fastify'
+import { IncomingMessage, Server, ServerResponse } from 'http'
+import { Http2Server, Http2ServerRequest, Http2ServerResponse } from 'http2'
+import fastify, { FastifyInstance, FastifyError, FastifyLoggerInstance, FastifyPluginAsync, FastifyPluginCallback, FastifyPluginOptions, RawServerDefault } from '../../fastify'
 
-const testPluginOptsAsync: FastifyPluginAsync = async function (_instance, _opts) { }
+const testPluginCallback: FastifyPluginCallback = function (instance, opts, done) { }
+const testPluginAsync: FastifyPluginAsync = async function (instance, opts) { }
+
+const testPluginOpts: FastifyPluginCallback = function (instance, opts, done) { }
+const testPluginOptsAsync: FastifyPluginAsync = async function (instance, opts) { }
+
+const testPluginOptsWithType = (instance: FastifyInstance, opts: FastifyPluginOptions, done: (error?: FastifyError) => void) => { }
+const testPluginOptsWithTypeAsync = async (instance: FastifyInstance, opts: FastifyPluginOptions) => { }
+
+interface TestOptions extends FastifyPluginOptions {
+  option1: string;
+  option2: boolean;
+}
 
 // Type validation
 expectError(fastify().register(testPluginOptsAsync, { prefix: 1 }))
@@ -26,3 +40,64 @@ expectAssignable<FastifyInstance>(
     expectType<FastifyInstance>(instance)
   })
 )
+
+// With Http2
+const serverWithHttp2 = fastify({ http2: true })
+type ServerWithHttp2 = FastifyInstance<Http2Server, Http2ServerRequest, Http2ServerResponse>
+const testPluginWithHttp2: FastifyPluginCallback<TestOptions, Http2Server> = function (instance, opts, done) { }
+const testPluginWithHttp2Async: FastifyPluginAsync<TestOptions, Http2Server> = async function (instance, opts) { }
+const testPluginWithHttp2WithType = (instance: ServerWithHttp2, opts: FastifyPluginOptions, done: (error?: FastifyError) => void) => { }
+const testPluginWithHttp2WithTypeAsync = async (instance: ServerWithHttp2, opts: FastifyPluginOptions) => { }
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginCallback))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginAsync))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginOpts))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginOptsAsync))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginOptsWithType))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginOptsWithTypeAsync))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginWithHttp2))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginWithHttp2Async))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginWithHttp2WithType))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(testPluginWithHttp2WithTypeAsync))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register((instance) => {
+  expectAssignable<FastifyInstance>(instance)
+}))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register((instance: ServerWithHttp2) => {
+  expectAssignable<ServerWithHttp2>(instance)
+}))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(async (instance) => {
+  expectAssignable<FastifyInstance>(instance)
+}))
+expectAssignable<ServerWithHttp2>(serverWithHttp2.register(async (instance: ServerWithHttp2) => {
+  expectAssignable<ServerWithHttp2>(instance)
+}))
+
+// With Type Provider
+type TestTypeProvider = { input: 'test', output: 'test' }
+const serverWithTypeProvider = fastify().withTypeProvider<TestTypeProvider>()
+type ServerWithTypeProvider = FastifyInstance<Server, IncomingMessage, ServerResponse, FastifyLoggerInstance, TestTypeProvider>
+const testPluginWithTypeProvider: FastifyPluginCallback<TestOptions, RawServerDefault, TestTypeProvider> = function (instance, opts, done) { }
+const testPluginWithTypeProviderAsync: FastifyPluginAsync<TestOptions, RawServerDefault, TestTypeProvider> = async function (instance, opts) { }
+const testPluginWithTypeProviderWithType = (instance: ServerWithTypeProvider, opts: FastifyPluginOptions, done: (error?: FastifyError) => void) => { }
+const testPluginWithTypeProviderWithTypeAsync = async (instance: ServerWithTypeProvider, opts: FastifyPluginOptions) => { }
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginCallback))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginAsync))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOpts))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOptsAsync))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOptsWithType))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginOptsWithTypeAsync))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginWithTypeProvider))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginWithTypeProviderAsync))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginWithTypeProviderWithType))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(testPluginWithTypeProviderWithTypeAsync))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register((instance) => {
+  expectAssignable<FastifyInstance>(instance)
+}))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register((instance: ServerWithTypeProvider) => {
+  expectAssignable<ServerWithTypeProvider>(instance)
+}))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(async (instance) => {
+  expectAssignable<FastifyInstance>(instance)
+}))
+expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(async (instance: ServerWithTypeProvider) => {
+  expectAssignable<ServerWithTypeProvider>(instance)
+}))