fastify 4.19.1 → 4.19.2

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.19.1'
+const VERSION = '4.19.2'
 
 const Avvio = require('avvio')
 const http = require('http')
@@ -426,12 +426,6 @@ function fastify (options) {
       router.closeRoutes()
 
       hookRunnerApplication('preClose', fastify[kAvvioBoot], fastify, function () {
-        // No new TCP connections are accepted.
-        // We must call close on the server even if we are not listening
-        // otherwise memory will be leaked.
-        // https://github.com/nodejs/node/issues/48604
-        instance.server.close(done)
-
         if (fastify[kState].listening) {
           /* istanbul ignore next: Cannot test this without Node.js core support */
           if (forceCloseConnections === 'idle') {
@@ -450,8 +444,22 @@ function fastify (options) {
               fastify[kKeepAliveConnections].delete(conn)
             }
           }
+        }
+
+        // No new TCP connections are accepted.
+        // We must call close on the server even if we are not listening
+        // otherwise memory will be leaked.
+        // https://github.com/nodejs/node/issues/48604
+        if (!options.serverFactory || fastify[kState].listening) {
+          instance.server.close(function (err) {
+            if (err && err.code !== 'ERR_SERVER_NOT_RUNNING') {
+              done(null)
+            } else {
+              done()
+            }
+          })
         } else {
-          done(null)
+          process.nextTick(done, null)
         }
       })
     })

package/package.json

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

package/test/custom-http-server.test.js

@@ -82,3 +82,45 @@ test('Should accept user defined serverFactory and ignore secondary server creat
     await app.listen({ port: 0 })
   })
 })
+
+test('Should not call close on the server if it has not created it', async t => {
+  const server = http.createServer()
+
+  const serverFactory = (handler, opts) => {
+    server.on('request', handler)
+    return server
+  }
+
+  const fastify = Fastify({ serverFactory })
+
+  fastify.get('/', (req, reply) => {
+    reply.send({ hello: 'world' })
+  })
+
+  await fastify.ready()
+
+  await new Promise((resolve, reject) => {
+    server.listen(0)
+    server.on('listening', resolve)
+    server.on('error', reject)
+  })
+
+  const address = server.address()
+  t.equal(server.listening, true)
+  await fastify.close()
+
+  t.equal(server.listening, true)
+  t.same(server.address(), address)
+  t.same(fastify.addresses(), [address])
+
+  await new Promise((resolve, reject) => {
+    server.close((err) => {
+      if (err) {
+        return reject(err)
+      }
+      resolve()
+    })
+  })
+  t.equal(server.listening, false)
+  t.same(server.address(), null)
+})

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

@@ -1,21 +1,21 @@
 import { FastifyError } from '@fastify/error'
 import { expectAssignable, expectError, expectType } from 'tsd'
 import fastify, {
+  ContextConfigDefault, FastifyContextConfig,
   FastifyInstance,
+  FastifyPluginOptions,
   FastifyReply,
   FastifyRequest,
+  FastifySchema,
+  FastifyTypeProviderDefault,
   RawReplyDefaultExpression,
   RawRequestDefaultExpression,
-  RouteOptions,
+  RawServerDefault,
   RegisterOptions,
-  FastifyPluginOptions,
-  FastifySchema,
-  FastifyTypeProviderDefault,
-  ContextConfigDefault, FastifyContextConfig, RawServerDefault
+  RouteOptions
 } from '../../fastify'
-import { preHandlerAsyncHookHandler, RequestPayload } from '../../types/hooks'
-import { RouteGenericInterface } from '../../types/route'
-import { ResolveFastifyRequestType } from '../../types/type-provider'
+import { RequestPayload, preHandlerAsyncHookHandler } from '../../types/hooks'
+import { FastifyRouteConfig, RouteGenericInterface } from '../../types/route'
 
 const server = fastify()
 
@@ -252,89 +252,90 @@ type CustomContextConfig = FastifyContextConfig & {
   foo: string;
   bar: number;
 }
+type CustomContextConfigWithDefault = CustomContextConfig & FastifyRouteConfig
 
 server.route<RouteGenericInterface, CustomContextConfig>({
   method: 'GET',
   url: '/',
   handler: () => { },
   onRequest: (request, reply, done) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   preParsing: (request, reply, payload, done) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   preValidation: (request, reply, done) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   preHandler: (request, reply, done) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   preSerialization: (request, reply, payload, done) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   onSend: (request, reply, payload, done) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   onResponse: (request, reply, done) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   onTimeout: (request, reply, done) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   onError: (request, reply, error, done) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   }
 })
 
 server.get<RouteGenericInterface, CustomContextConfig>('/', {
   onRequest: async (request, reply) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   preParsing: async (request, reply) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   preValidation: async (request, reply) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   preHandler: async (request, reply) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   preSerialization: async (request, reply) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   onSend: async (request, reply) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   onResponse: async (request, reply) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   onTimeout: async (request, reply) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   onError: async (request, reply) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   }
 }, async (request, reply) => {
-  expectType<CustomContextConfig>(request.context.config)
-  expectType<CustomContextConfig>(reply.context.config)
+  expectType<CustomContextConfigWithDefault>(request.context.config)
+  expectType<CustomContextConfigWithDefault>(reply.context.config)
 })
 
 type CustomContextRequest = FastifyRequest<any, any, any, any, any, CustomContextConfig, any>
@@ -344,40 +345,40 @@ server.route<RouteGenericInterface, CustomContextConfig>({
   url: '/',
   handler: () => { },
   onRequest: async (request: CustomContextRequest, reply: CustomContextReply) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   preParsing: async (request: CustomContextRequest, reply: CustomContextReply, payload: RequestPayload) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   preValidation: async (request: CustomContextRequest, reply: CustomContextReply) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   preHandler: async (request: CustomContextRequest, reply: CustomContextReply) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   preSerialization: async (request: CustomContextRequest, reply: CustomContextReply, payload: any) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   onSend: async (request: CustomContextRequest, reply: CustomContextReply, payload: any) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   onResponse: async (request: CustomContextRequest, reply: CustomContextReply) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   onTimeout: async (request: CustomContextRequest, reply: CustomContextReply) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   },
   onError: async (request: CustomContextRequest, reply: CustomContextReply, error: FastifyError) => {
-    expectType<CustomContextConfig>(request.context.config)
-    expectType<CustomContextConfig>(reply.context.config)
+    expectType<CustomContextConfigWithDefault>(request.context.config)
+    expectType<CustomContextConfigWithDefault>(reply.context.config)
   }
 })
 

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

@@ -315,6 +315,8 @@ server.decorate<string>('test', {
     expectType<FastifyInstance>(this)
   }
 })
+server.decorate('test')
+server.decorate('test', null, ['foo'])
 
 server.decorateRequest<(x: string, y: number) => void>('test', function (x: string, y: number): void {
   expectType<FastifyRequest>(this)
@@ -322,6 +324,8 @@ server.decorateRequest<(x: string, y: number) => void>('test', function (x: stri
 server.decorateRequest('test', function (x: string, y: number): void {
   expectType<FastifyRequest>(this)
 })
+server.decorateRequest('test')
+server.decorateRequest('test', null, ['foo'])
 
 server.decorateReply<(x: string) => void>('test', function (x: string): void {
   expectType<FastifyReply>(this)
@@ -329,6 +333,8 @@ server.decorateReply<(x: string) => void>('test', function (x: string): void {
 server.decorateReply('test', function (x: string): void {
   expectType<FastifyReply>(this)
 })
+server.decorateReply('test')
+server.decorateReply('test', null, ['foo'])
 
 expectError(server.decorate<string>('test', true))
 expectError(server.decorate<(myNumber: number) => number>('test', function (myNumber: number): string {
@@ -349,7 +355,20 @@ declare module '../../fastify' {
     typedTestPropertyGetterSetter: string
     typedTestMethod (x: string): string
   }
+
+  interface FastifyRequest {
+    typedTestRequestProperty: boolean
+    typedTestRequestPropertyGetterSetter: string
+    typedTestRequestMethod (x: string): string
+  }
+
+  interface FastifyReply {
+    typedTestReplyProperty: boolean
+    typedTestReplyPropertyGetterSetter: string
+    typedTestReplyMethod (x: string): string
+  }
 }
+
 server.decorate('typedTestProperty', false)
 server.decorate('typedTestProperty', {
   getter () {
@@ -365,6 +384,9 @@ server.decorate('typedTestProperty', {
     expectType<FastifyInstance>(this)
   }
 })
+server.decorate('typedTestProperty')
+server.decorate('typedTestProperty', null, ['foo'])
+server.decorate('typedTestProperty', null)
 expectError(server.decorate('typedTestProperty', 'foo'))
 expectError(server.decorate('typedTestProperty', {
   getter () {
@@ -387,6 +409,86 @@ expectError(server.decorate('typedTestMethod', async function (x) {
   return 'foo'
 }))
 
+server.decorateRequest('typedTestRequestProperty', false)
+server.decorateRequest('typedTestRequestProperty', {
+  getter () {
+    return false
+  }
+})
+server.decorateRequest('typedTestRequestProperty', {
+  getter (): boolean {
+    return true
+  },
+  setter (x) {
+    expectType<boolean>(x)
+    expectType<FastifyRequest>(this)
+  }
+})
+server.decorateRequest('typedTestRequestProperty')
+server.decorateRequest('typedTestRequestProperty', null, ['foo'])
+server.decorateRequest('typedTestRequestProperty', null)
+expectError(server.decorateRequest('typedTestRequestProperty', 'foo'))
+expectError(server.decorateRequest('typedTestRequestProperty', {
+  getter () {
+    return 'foo'
+  }
+}))
+server.decorateRequest('typedTestRequestMethod', function (x) {
+  expectType<string>(x)
+  expectType<FastifyRequest>(this)
+  return 'foo'
+})
+server.decorateRequest('typedTestRequestMethod', x => x)
+expectError(server.decorateRequest('typedTestRequestMethod', function (x: boolean) {
+  return 'foo'
+}))
+expectError(server.decorateRequest('typedTestRequestMethod', function (x) {
+  return true
+}))
+expectError(server.decorateRequest('typedTestRequestMethod', async function (x) {
+  return 'foo'
+}))
+
+server.decorateReply('typedTestReplyProperty', false)
+server.decorateReply('typedTestReplyProperty', {
+  getter () {
+    return false
+  }
+})
+server.decorateReply('typedTestReplyProperty', {
+  getter (): boolean {
+    return true
+  },
+  setter (x) {
+    expectType<boolean>(x)
+    expectType<FastifyReply>(this)
+  }
+})
+server.decorateReply('typedTestReplyProperty')
+server.decorateReply('typedTestReplyProperty', null, ['foo'])
+server.decorateReply('typedTestReplyProperty', null)
+expectError(server.decorateReply('typedTestReplyProperty', 'foo'))
+expectError(server.decorateReply('typedTestReplyProperty', {
+  getter () {
+    return 'foo'
+  }
+}))
+server.decorateReply('typedTestReplyMethod', function (x) {
+  expectType<string>(x)
+  expectType<FastifyReply>(this)
+  return 'foo'
+})
+server.decorateReply('typedTestReplyMethod', x => x)
+expectError(server.decorateReply('typedTestReplyMethod', function (x: boolean) {
+  return 'foo'
+}))
+expectError(server.decorateReply('typedTestReplyMethod', function (x) {
+  return true
+}))
+expectError(server.decorateReply('typedTestReplyMethod', async function (x) {
+  return 'foo'
+}))
+
 const versionConstraintStrategy = {
   name: 'version',
   storage: () => ({

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

@@ -1,19 +1,19 @@
-import { expectType, expectError, expectAssignable } from 'tsd'
-import fastify, { RouteHandlerMethod, RouteHandler, RawRequestDefaultExpression, FastifyContext, FastifyContextConfig, FastifyRequest, FastifyReply, FastifySchema, FastifyTypeProviderDefault } from '../../fastify'
-import { RawServerDefault, RawReplyDefaultExpression, ContextConfigDefault } from '../../types/utils'
+import { Buffer } from 'buffer'
+import { expectAssignable, expectError, expectType } from 'tsd'
+import fastify, { FastifyContext, FastifyReply, FastifyRequest, FastifySchema, FastifySchemaCompiler, FastifyTypeProviderDefault, RawRequestDefaultExpression, RouteHandler, RouteHandlerMethod } from '../../fastify'
+import { FastifyInstance } from '../../types/instance'
 import { FastifyLoggerInstance } from '../../types/logger'
+import { ResolveReplyTypeWithRouteGeneric } from '../../types/reply'
 import { RouteGenericInterface } from '../../types/route'
-import { FastifyInstance } from '../../types/instance'
-import { Buffer } from 'buffer'
-import { ReplyTypeConstrainer } from '../../types/reply'
+import { ContextConfigDefault, RawReplyDefaultExpression, RawServerDefault } from '../../types/utils'
 
 type DefaultSerializationFunction = (payload: { [key: string]: unknown }) => string
-type DefaultFastifyReplyWithCode<Code extends number> = FastifyReply<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, RouteGenericInterface, ContextConfigDefault, FastifySchema, FastifyTypeProviderDefault, ReplyTypeConstrainer<RouteGenericInterface['Reply'], Code>>
+type DefaultFastifyReplyWithCode<Code extends number> = FastifyReply<RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, RouteGenericInterface, ContextConfigDefault, FastifySchema, FastifyTypeProviderDefault, ResolveReplyTypeWithRouteGeneric<RouteGenericInterface['Reply'], Code, FastifySchema, FastifyTypeProviderDefault>>
 
 const getHandler: RouteHandlerMethod = function (_request, reply) {
   expectType<RawReplyDefaultExpression>(reply.raw)
   expectType<FastifyContext<ContextConfigDefault>>(reply.context)
-  expectType<FastifyContextConfig>(reply.context.config)
+  expectType<FastifyContext<ContextConfigDefault>['config']>(reply.context.config)
   expectType<FastifyLoggerInstance>(reply.log)
   expectType<FastifyRequest<RouteGenericInterface, RawServerDefault, RawRequestDefaultExpression>>(reply.request)
   expectType<<Code extends number>(statusCode: Code) => DefaultFastifyReplyWithCode<Code>>(reply.code)

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

@@ -1,26 +1,25 @@
-import { expectAssignable, expectType } from 'tsd'
 import pino from 'pino'
+import { expectAssignable, expectType } from 'tsd'
 import fastify, {
-  RouteHandler,
-  RawRequestDefaultExpression,
-  RequestBodyDefault,
-  RequestGenericInterface,
-  FastifyContext,
   ContextConfigDefault,
-  FastifyContextConfig,
+  FastifyContext,
   FastifyLogFn,
-  RouteHandlerMethod,
-  RawServerDefault,
-  RawReplyDefaultExpression,
   FastifySchema,
-  FastifyTypeProviderDefault
+  FastifyTypeProviderDefault,
+  RawReplyDefaultExpression,
+  RawRequestDefaultExpression,
+  RawServerDefault,
+  RequestBodyDefault,
+  RequestGenericInterface,
+  RouteHandler,
+  RouteHandlerMethod
 } from '../../fastify'
-import { RequestParamsDefault, RequestHeadersDefault, RequestQuerystringDefault } from '../../types/utils'
+import { FastifyInstance } from '../../types/instance'
 import { FastifyLoggerInstance } from '../../types/logger'
-import { FastifyRequest, RequestRouteOptions } from '../../types/request'
 import { FastifyReply } from '../../types/reply'
-import { FastifyInstance } from '../../types/instance'
+import { FastifyRequest, RequestRouteOptions } from '../../types/request'
 import { RouteGenericInterface } from '../../types/route'
+import { RequestHeadersDefault, RequestParamsDefault, RequestQuerystringDefault } from '../../types/utils'
 
 interface RequestBody {
   content: string;
@@ -76,8 +75,8 @@ const getHandler: RouteHandler = function (request, _reply) {
   expectType<RequestBodyDefault>(request.body)
   expectType<RequestParamsDefault>(request.params)
   expectType<FastifyContext<ContextConfigDefault>>(request.context)
-  expectType<FastifyContextConfig>(request.context.config)
-  expectType<FastifyContextConfig>(request.routeConfig)
+  expectType<FastifyContext<ContextConfigDefault>['config']>(request.context.config)
+  expectType<FastifyContext<ContextConfigDefault>['config']>(request.routeConfig)
   expectType<FastifySchema>(request.routeSchema)
 
   expectType<RequestHeadersDefault & RawRequestDefaultExpression['headers']>(request.headers)
@@ -110,7 +109,7 @@ const postHandler: Handler = function (request) {
   expectType<string>(request.headers['x-foobar'])
   expectType<FastifyInstance>(request.server)
   expectType<FastifyContext<ContextConfigDefault>>(request.context)
-  expectType<FastifyContextConfig>(request.context.config)
+  expectType<FastifyContext<ContextConfigDefault>['config']>(request.context.config)
 }
 
 function putHandler (request: CustomRequest, reply: FastifyReply) {
@@ -128,7 +127,7 @@ function putHandler (request: CustomRequest, reply: FastifyReply) {
   expectType<string>(request.headers['x-foobar'])
   expectType<FastifyInstance>(request.server)
   expectType<FastifyContext<ContextConfigDefault>>(request.context)
-  expectType<FastifyContextConfig>(request.context.config)
+  expectType<FastifyContext<ContextConfigDefault>['config']>(request.context.config)
 }
 
 const server = fastify()

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

@@ -1,9 +1,9 @@
-import fastify, { FastifyInstance, FastifyRequest, FastifyReply, RouteHandlerMethod } from '../../fastify'
-import { expectType, expectError, expectAssignable, printType } from 'tsd'
-import { HTTPMethods } from '../../types/utils'
+import { FastifyError } from '@fastify/error'
 import * as http from 'http'
+import { expectAssignable, expectError, expectType } from 'tsd'
+import fastify, { FastifyInstance, FastifyReply, FastifyRequest, RouteHandlerMethod } from '../../fastify'
 import { RequestPayload } from '../../types/hooks'
-import { FastifyError } from '@fastify/error'
+import { HTTPMethods } from '../../types/utils'
 
 /*
  * Testing Fastify HTTP Routes and Route Shorthands.
@@ -74,7 +74,7 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
     Headers: HeadersInterface;
   }
 
-  fastify()[lowerCaseMethod]<RouteGeneric, RouteSpecificContextConfigType>('/', { config: { foo: 'bar', bar: 100, extra: true, url: '/', method: lowerCaseMethod } }, (req, res) => {
+  fastify()[lowerCaseMethod]<RouteGeneric, RouteSpecificContextConfigType>('/', { config: { foo: 'bar', bar: 100, extra: true } }, (req, res) => {
     expectType<BodyInterface>(req.body)
     expectType<QuerystringInterface>(req.query)
     expectType<ParamsInterface>(req.params)
@@ -94,7 +94,7 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
   fastify().route<RouteGeneric>({
     url: '/',
     method: method as HTTPMethods,
-    config: { foo: 'bar', bar: 100, url: '/', method: method as HTTPMethods },
+    config: { foo: 'bar', bar: 100 },
     prefixTrailingSlash: 'slash',
     onRequest: (req, res, done) => { // these handlers are tested in `hooks.test-d.ts`
       expectType<BodyInterface>(req.body)
@@ -231,7 +231,7 @@ type LowerCaseHTTPMethods = 'get' | 'post' | 'put' | 'patch' | 'head' | 'delete'
   fastify().route<RouteGeneric>({
     url: '/',
     method: method as HTTPMethods,
-    config: { foo: 'bar', bar: 100, url: '/', method: method as HTTPMethods },
+    config: { foo: 'bar', bar: 100 },
     prefixTrailingSlash: 'slash',
     onRequest: async (req, res, done) => { // these handlers are tested in `hooks.test-d.ts`
       expectType<BodyInterface>(req.body)

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

@@ -299,6 +299,8 @@ expectAssignable(server.withTypeProvider<TypeBoxProvider>().get(
     res.send('hello')
     res.send(42)
     res.send({ error: 'error' })
+    expectType<(payload?: string | number | { error: string }) => typeof res>(res.code(200).send)
+    expectError<(payload?: unknown) => typeof res>(res.code(200).send)
   }
 ))
 
@@ -527,6 +529,8 @@ expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get(
     res.send('hello')
     res.send(42)
     res.send({ error: 'error' })
+    expectType<(payload?: string | number | { [x: string]: unknown, error?: string | undefined }) => typeof res>(res.code(200).send)
+    expectError<(payload?: unknown) => typeof res>(res.code(200).send)
   }
 ))
 

package/types/context.d.ts

@@ -1,8 +1,8 @@
-import { ContextConfigDefault } from './utils'
 import { FastifyRouteConfig } from './route'
+import { ContextConfigDefault } from './utils'
 
 // eslint-disable-next-line @typescript-eslint/no-empty-interface
-export interface FastifyContextConfig extends FastifyRouteConfig {
+export interface FastifyContextConfig {
 }
 
 /**
@@ -12,5 +12,5 @@ export interface FastifyContext<ContextConfig = ContextConfigDefault> {
   /**
    * @deprecated Use Request#routeConfig or Request#routeSchema instead
    */
-  config: FastifyContextConfig & ContextConfig;
+  config: FastifyContextConfig & FastifyRouteConfig & ContextConfig;
 }

package/types/instance.d.ts

@@ -103,6 +103,12 @@ type DecorationMethod<This, Return = This> = {
     >,
     dependencies?: string[]
   ): Return;
+
+  (property: string | symbol): Return;
+
+  (property: string | symbol, value: null): Return;
+
+  (property: string | symbol, value: null|undefined, dependencies: string[]): Return;
 }
 
 /**

package/types/reply.d.ts

@@ -6,17 +6,22 @@ import { FastifyRequest } from './request'
 import { RouteGenericInterface } from './route'
 import { FastifySchema } from './schema'
 import { FastifyReplyType, FastifyTypeProvider, FastifyTypeProviderDefault, ResolveFastifyReplyType } from './type-provider'
-import { CodeToReplyKey, ContextConfigDefault, ReplyKeysToCodes, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault, ReplyDefault } from './utils'
+import { CodeToReplyKey, ContextConfigDefault, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault, ReplyDefault, ReplyKeysToCodes } from './utils'
 
 export interface ReplyGenericInterface {
   Reply?: ReplyDefault;
 }
 
-export type ReplyTypeConstrainer<RouteGenericReply, Code extends ReplyKeysToCodes<keyof RouteGenericReply>, ReplyKey = CodeToReplyKey<Code>> =
+type ReplyTypeConstrainer<RouteGenericReply, Code extends ReplyKeysToCodes<keyof RouteGenericReply>, ReplyKey = CodeToReplyKey<Code>> =
   Code extends keyof RouteGenericReply ? RouteGenericReply[Code] :
     [ReplyKey] extends [never] ? unknown :
       ReplyKey extends keyof RouteGenericReply ? RouteGenericReply[ReplyKey] :
         unknown;
+
+export type ResolveReplyTypeWithRouteGeneric<RouteGenericReply, Code extends ReplyKeysToCodes<keyof RouteGenericReply>,
+  SchemaCompiler extends FastifySchema = FastifySchema,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault> =
+  ResolveFastifyReplyType<TypeProvider, SchemaCompiler, { Reply: ReplyTypeConstrainer<RouteGenericReply, Code> }>
 /**
  * FastifyReply is an instance of the standard http or http2 reply types.
  * It defaults to http.ServerResponse, and it also extends the relative reply object.
@@ -36,8 +41,8 @@ export interface FastifyReply<
   log: FastifyBaseLogger;
   request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>;
   server: FastifyInstance;
-  code<Code extends ReplyKeysToCodes<keyof RouteGeneric['Reply']>>(statusCode: Code): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, ReplyTypeConstrainer<RouteGeneric['Reply'], Code>>;
-  status<Code extends ReplyKeysToCodes<keyof RouteGeneric['Reply']>>(statusCode: Code): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, ReplyTypeConstrainer<RouteGeneric['Reply'], Code>>;
+  code<Code extends ReplyKeysToCodes<keyof RouteGeneric['Reply']>>(statusCode: Code): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, ResolveReplyTypeWithRouteGeneric<RouteGeneric['Reply'], Code, SchemaCompiler, TypeProvider>>;
+  status<Code extends ReplyKeysToCodes<keyof RouteGeneric['Reply']>>(statusCode: Code): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, ResolveReplyTypeWithRouteGeneric<RouteGeneric['Reply'], Code, SchemaCompiler, TypeProvider>>;
   statusCode: number;
   sent: boolean;
   send(payload?: ReplyType): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;

package/types/request.d.ts

@@ -1,11 +1,11 @@
 import { ErrorObject } from '@fastify/ajv-compiler'
+import { FastifyContext } from './context'
+import { FastifyInstance } from './instance'
 import { FastifyBaseLogger } from './logger'
-import { ContextConfigDefault, RawServerBase, RawServerDefault, RawRequestDefaultExpression, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault } from './utils'
 import { RouteGenericInterface } from './route'
-import { FastifyInstance } from './instance'
-import { FastifyTypeProvider, FastifyTypeProviderDefault, FastifyRequestType, ResolveFastifyRequestType } from './type-provider'
 import { FastifySchema } from './schema'
-import { FastifyContext, FastifyContextConfig } from './context'
+import { FastifyRequestType, FastifyTypeProvider, FastifyTypeProviderDefault, ResolveFastifyRequestType } from './type-provider'
+import { ContextConfigDefault, RawRequestDefaultExpression, RawServerBase, RawServerDefault, RequestBodyDefault, RequestHeadersDefault, RequestParamsDefault, RequestQuerystringDefault } from './utils'
 
 type HTTPRequestPart = 'body' | 'query' | 'querystring' | 'params' | 'headers'
 export interface RequestGenericInterface {
@@ -59,7 +59,7 @@ export interface FastifyRequest<RouteGeneric extends RouteGenericInterface = Rou
   server: FastifyInstance;
   body: RequestType['body'];
   context: FastifyContext<ContextConfig>;
-  routeConfig: FastifyContextConfig & ContextConfig;
+  routeConfig: FastifyContext<ContextConfig>['config'];
   routeSchema: FastifySchema
 
   /** in order for this to be used the user should ensure they have set the attachValidation option. */

package/types/route.d.ts

@@ -1,17 +1,17 @@
+import { FastifyError } from '@fastify/error'
+import { FastifyContext } from './context'
+import { onErrorHookHandler, onRequestAbortHookHandler, onRequestHookHandler, onResponseHookHandler, onSendHookHandler, onTimeoutHookHandler, preHandlerHookHandler, preParsingHookHandler, preSerializationHookHandler, preValidationHookHandler } from './hooks'
 import { FastifyInstance } from './instance'
-import { FastifyRequest, RequestGenericInterface } from './request'
+import { FastifyBaseLogger, LogLevel } from './logger'
 import { FastifyReply, ReplyGenericInterface } from './reply'
+import { FastifyRequest, RequestGenericInterface } from './request'
 import { FastifySchema, FastifySchemaCompiler, FastifySerializerCompiler, SchemaErrorFormatter } from './schema'
-import { HTTPMethods, RawServerBase, RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression, ContextConfigDefault } from './utils'
-import { preValidationHookHandler, preHandlerHookHandler, preSerializationHookHandler, onRequestHookHandler, preParsingHookHandler, onResponseHookHandler, onSendHookHandler, onErrorHookHandler, onTimeoutHookHandler, onRequestAbortHookHandler } from './hooks'
-import { FastifyError } from '@fastify/error'
-import { FastifyContext } from './context'
 import {
   FastifyTypeProvider,
   FastifyTypeProviderDefault,
   ResolveFastifyReplyReturnType
 } from './type-provider'
-import { FastifyBaseLogger, LogLevel } from './logger'
+import { ContextConfigDefault, HTTPMethods, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault } from './utils'
 
 export interface FastifyRouteConfig {
   url: string;
@@ -41,7 +41,7 @@ export interface RouteShorthandOptions<
   serializerCompiler?: FastifySerializerCompiler<SchemaCompiler>;
   bodyLimit?: number;
   logLevel?: LogLevel;
-  config?: FastifyContext<ContextConfig>['config'];
+  config?: Omit<FastifyContext<ContextConfig>['config'], 'url' | 'method'>;
   version?: string;
   constraints?: { [name: string]: any },
   prefixTrailingSlash?: 'slash'|'no-slash'|'both';