fastify 4.27.0 → 5.0.0-alpha.2

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

@@ -4,7 +4,8 @@ import fastify, {
   FastifyRequest,
   FastifyReply,
   FastifyInstance,
-  FastifyError
+  FastifyError,
+  SafePromiseLike
 } from '../../fastify'
 import { expectAssignable, expectError, expectType } from 'tsd'
 import { IncomingHttpHeaders } from 'http'
@@ -23,7 +24,10 @@ expectAssignable(server.get('/', (req) => expectType<unknown>(req.body)))
 // Remapping
 // -------------------------------------------------------------------
 
-interface NumberProvider extends FastifyTypeProvider { output: number } // remap all schemas to numbers
+interface NumberProvider extends FastifyTypeProvider {
+  validator: number
+  serializer: number
+} // remap all schemas to numbers
 
 expectAssignable(server.withTypeProvider<NumberProvider>().get(
   '/',
@@ -47,7 +51,7 @@ expectAssignable(server.withTypeProvider<NumberProvider>().get(
 // Override
 // -------------------------------------------------------------------
 
-interface OverriddenProvider extends FastifyTypeProvider { output: 'inferenced' }
+interface OverriddenProvider extends FastifyTypeProvider { validator: 'inferenced' }
 
 expectAssignable(server.withTypeProvider<OverriddenProvider>().get<{ Body: 'override' }>(
   '/',
@@ -69,7 +73,10 @@ expectAssignable(server.withTypeProvider<OverriddenProvider>().get<{ Body: 'over
 // TypeBox
 // -------------------------------------------------------------------
 
-interface TypeBoxProvider extends FastifyTypeProvider { output: this['input'] extends TSchema ? Static<this['input']> : unknown }
+interface TypeBoxProvider extends FastifyTypeProvider {
+  validator: this['schema'] extends TSchema ? Static<this['schema']> : unknown
+  serializer: this['schema'] extends TSchema ? Static<this['schema']> : unknown
+}
 
 expectAssignable(server.withTypeProvider<TypeBoxProvider>().get(
   '/',
@@ -103,7 +110,10 @@ expectAssignable<FastifyInstance>(server.withTypeProvider<TypeBoxProvider>())
 // JsonSchemaToTs
 // -------------------------------------------------------------------
 
-interface JsonSchemaToTsProvider extends FastifyTypeProvider { output: this['input'] extends JSONSchema ? FromSchema<this['input']> : unknown }
+interface JsonSchemaToTsProvider extends FastifyTypeProvider {
+  validator: this['schema'] extends JSONSchema ? FromSchema<this['schema']> : unknown
+  serializer: this['schema'] extends JSONSchema ? FromSchema<this['schema']> : unknown
+}
 
 // explicitly setting schema `as const`
 
@@ -907,7 +917,7 @@ expectError(server.withTypeProvider<JsonSchemaToTsProvider>().get(
 // Reply Type Override
 // -------------------------------------------------------------------
 
-expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{Reply: boolean}>(
+expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{ Reply: boolean }>(
   '/',
   {
     schema: {
@@ -927,7 +937,7 @@ expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{Reply: b
 // Reply Type Override (Different Content-types)
 // -------------------------------------------------------------------
 
-expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{Reply: boolean}>(
+expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{ Reply: boolean }>(
   '/',
   {
     schema: {
@@ -955,7 +965,7 @@ expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{Reply: b
 // Reply Type Return Override
 // -------------------------------------------------------------------
 
-expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{Reply: boolean}>(
+expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{ Reply: boolean }>(
   '/',
   {
     schema: {
@@ -975,7 +985,7 @@ expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{Reply: b
 // Reply Type Return Override (Different Content-types)
 // -------------------------------------------------------------------
 
-expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{Reply: boolean}>(
+expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{ Reply: boolean }>(
   '/',
   {
     schema: {
@@ -1003,7 +1013,7 @@ expectAssignable(server.withTypeProvider<JsonSchemaToTsProvider>().get<{Reply: b
 // FastifyPlugin: Auxiliary
 // -------------------------------------------------------------------
 
-interface AuxiliaryPluginProvider extends FastifyTypeProvider { output: 'plugin-auxiliary' }
+interface AuxiliaryPluginProvider extends FastifyTypeProvider { validator: 'plugin-auxiliary' }
 
 // Auxiliary plugins may have varying server types per application. Recommendation would be to explicitly remap instance provider context within plugin if required.
 function plugin<T extends FastifyInstance> (instance: T) {
@@ -1032,7 +1042,7 @@ expectAssignable(server.withTypeProvider<AuxiliaryPluginProvider>().register(plu
 // Handlers: Inline
 // -------------------------------------------------------------------
 
-interface InlineHandlerProvider extends FastifyTypeProvider { output: 'handler-inline' }
+interface InlineHandlerProvider extends FastifyTypeProvider { validator: 'handler-inline' }
 
 // Inline handlers should infer for the request parameters (non-shared)
 expectAssignable(server.withTypeProvider<InlineHandlerProvider>().get(
@@ -1052,7 +1062,7 @@ expectAssignable(server.withTypeProvider<InlineHandlerProvider>().get(
 // Handlers: Auxiliary
 // -------------------------------------------------------------------
 
-interface AuxiliaryHandlerProvider extends FastifyTypeProvider { output: 'handler-auxiliary' }
+interface AuxiliaryHandlerProvider extends FastifyTypeProvider { validator: 'handler-auxiliary' }
 
 // Auxiliary handlers are likely shared for multiple routes and thus should infer as unknown due to potential varying parameters
 function auxiliaryHandler (request: FastifyRequest, reply: FastifyReply, done: HookHandlerDoneFunction): void {
@@ -1063,9 +1073,46 @@ expectAssignable(server.withTypeProvider<AuxiliaryHandlerProvider>().get(
   '/',
   {
     onRequest: auxiliaryHandler,
-    schema: { body: null }
+    schema: { body: 'handler-auxiliary' }
   },
   (req) => {
     expectType<'handler-auxiliary'>(req.body)
   }
 ))
+
+// -------------------------------------------------------------------
+// SafePromiseLike
+// -------------------------------------------------------------------
+const safePromiseLike = {
+  then: new Promise<string>(resolve => resolve('')).then,
+  __linterBrands: 'SafePromiseLike' as const
+}
+expectAssignable<SafePromiseLike<string>>(safePromiseLike)
+expectAssignable<PromiseLike<string>>(safePromiseLike)
+expectError<Promise<string>>(safePromiseLike)
+
+// -------------------------------------------------------------------
+// Separate Providers
+// -------------------------------------------------------------------
+
+interface SeparateProvider extends FastifyTypeProvider {
+  validator: string
+  serializer: Date
+}
+
+expectAssignable(server.withTypeProvider<SeparateProvider>().get(
+  '/',
+  {
+    schema: {
+      body: null,
+      response: {
+        200: { type: 'string' }
+      }
+    }
+  },
+  (req, res) => {
+    expectType<string>(req.body)
+
+    res.send(new Date())
+  }
+))

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

@@ -1,4 +1,4 @@
-import { expectAssignable, expectType } from 'tsd'
+import { expectAssignable } from 'tsd'
 import fastify, { FastifyInstance } from '../../fastify'
 
 async function hasSymbolDisposeWithUsing () {
@@ -12,3 +12,6 @@ async function hasSymbolDispose () {
   expectAssignable<FastifyInstance>(app)
   expectAssignable<FastifyInstance[typeof Symbol.asyncDispose]>(app.close)
 }
+
+hasSymbolDisposeWithUsing()
+hasSymbolDispose()

package/test/url-rewriting.test.js

@@ -119,8 +119,8 @@ test('Should rewrite url but keep originalUrl unchanged', t => {
     method: 'GET',
     url: '/',
     handler: (req, reply) => {
+      reply.send({ hello: 'world', hostname: req.hostname, port: req.port })
       t.equal(req.originalUrl, '/this-would-404-without-url-rewrite')
-      reply.send({ hello: 'world' })
     }
   })
 
@@ -132,7 +132,8 @@ test('Should rewrite url but keep originalUrl unchanged', t => {
       url: 'http://localhost:' + fastify.server.address().port + '/this-would-404-without-url-rewrite'
     }, (err, response, body) => {
       t.error(err)
-      t.same(JSON.parse(body), { hello: 'world' })
+      const parsedBody = JSON.parse(body)
+      t.same(parsedBody, { hello: 'world', hostname: 'localhost', port: fastify.server.address().port })
       t.equal(response.statusCode, 200)
     })
   })

package/test/useSemicolonDelimiter.test.js

@@ -5,30 +5,27 @@ const test = t.test
 const Fastify = require('..')
 const sget = require('simple-get').concat
 
-test('use semicolon delimiter default true', t => {
+test('use semicolon delimiter default false', t => {
   t.plan(4)
 
   const fastify = Fastify({})
 
   t.teardown(fastify.close.bind(fastify))
 
-  fastify.get('/1234', (req, reply) => {
+  fastify.get('/1234;foo=bar', (req, reply) => {
     reply.send(req.query)
   })
 
   fastify.listen({ port: 0 }, err => {
     t.error(err)
 
-    console.log('http://localhost:' + fastify.server.address().port + '/1234;foo=bar')
     sget({
       method: 'GET',
       url: 'http://localhost:' + fastify.server.address().port + '/1234;foo=bar'
     }, (err, response, body) => {
       t.error(err)
       t.equal(response.statusCode, 200)
-      t.same(JSON.parse(body), {
-        foo: 'bar'
-      })
+      t.same(JSON.parse(body), {})
     })
   })
 })

package/test/versioned-routes.test.js

@@ -454,7 +454,7 @@ test('test log stream', t => {
     t.teardown(() => { fastify.close() })
 
     http.get({
-      hostname: fastify.server.address().hostname,
+      host: fastify.server.address().hostname,
       port: fastify.server.address().port,
       path: '/',
       method: 'GET',

package/test/web-api.test.js

@@ -4,15 +4,9 @@ const t = require('tap')
 const test = t.test
 const Fastify = require('../fastify')
 const fs = require('node:fs')
-const semver = require('semver')
 const { Readable } = require('node:stream')
 const { fetch: undiciFetch } = require('undici')
 
-if (semver.lt(process.versions.node, '18.0.0')) {
-  t.skip('Response or ReadableStream not available, skipping test')
-  process.exit(0)
-}
-
 test('should response with a ReadableStream', async (t) => {
   t.plan(2)
 

package/types/content-type-parser.d.ts

@@ -15,7 +15,7 @@ export type FastifyBodyParser<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
   SchemaCompiler extends FastifySchema = FastifySchema,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > = ((request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>, rawBody: RawBody, done: ContentTypeParserDoneFunction) => void)
 | ((request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>, rawBody: RawBody) => Promise<any>)
 
@@ -27,7 +27,7 @@ export type FastifyContentTypeParser<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
   SchemaCompiler extends FastifySchema = FastifySchema,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > = ((request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>, payload: RawRequest) => Promise<any>)
 | ((request: FastifyRequest<RouteGeneric, RawServer, RawRequest, SchemaCompiler, TypeProvider>, payload: RawRequest, done: ContentTypeParserDoneFunction) => void)
 
@@ -39,7 +39,7 @@ export interface AddContentTypeParser<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
   SchemaCompiler extends FastifySchema = FastifySchema,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > {
   (
     contentType: string | string[] | RegExp,

package/types/context.d.ts

@@ -1,7 +1,6 @@
 import { FastifyRouteConfig } from './route'
 import { ContextConfigDefault } from './utils'
 
-// eslint-disable-next-line @typescript-eslint/no-empty-interface
 export interface FastifyContextConfig {
 }
 

package/types/errors.d.ts

@@ -24,6 +24,7 @@ export type FastifyErrorCodes = Record<
 'FST_ERR_DEC_DEPENDENCY_INVALID_TYPE' |
 'FST_ERR_DEC_MISSING_DEPENDENCY' |
 'FST_ERR_DEC_AFTER_START' |
+'FST_ERR_DEC_REFERENCE_TYPE' |
 'FST_ERR_HOOK_INVALID_TYPE' |
 'FST_ERR_HOOK_INVALID_HANDLER' |
 'FST_ERR_HOOK_INVALID_ASYNC_HANDLER' |

package/types/hooks.d.ts

@@ -724,7 +724,7 @@ export interface onReadyHookHandler<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
   Logger extends FastifyBaseLogger = FastifyBaseLogger,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > {
   (
     this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
@@ -737,7 +737,7 @@ export interface onReadyAsyncHookHandler<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
   Logger extends FastifyBaseLogger = FastifyBaseLogger,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > {
   (
     this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
@@ -752,7 +752,7 @@ export interface onListenHookHandler<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
   Logger extends FastifyBaseLogger = FastifyBaseLogger,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > {
   (
     this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
@@ -765,7 +765,7 @@ export interface onListenAsyncHookHandler<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
   Logger extends FastifyBaseLogger = FastifyBaseLogger,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > {
   (
     this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
@@ -779,7 +779,7 @@ export interface onCloseHookHandler<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
   Logger extends FastifyBaseLogger = FastifyBaseLogger,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > {
   (
     instance: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
@@ -807,7 +807,7 @@ export interface preCloseHookHandler<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
   Logger extends FastifyBaseLogger = FastifyBaseLogger,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > {
   (
     this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,

package/types/instance.d.ts

@@ -9,7 +9,7 @@ import { FastifyBaseLogger, FastifyChildLoggerFactory } from './logger'
 import { FastifyRegister } from './register'
 import { FastifyReply } from './reply'
 import { FastifyRequest } from './request'
-import { DefaultRoute, RouteGenericInterface, RouteHandlerMethod, RouteOptions, RouteShorthandMethod } from './route'
+import { RouteGenericInterface, RouteHandlerMethod, RouteOptions, RouteShorthandMethod } from './route'
 import {
   FastifySchema,
   FastifySchemaCompiler,
@@ -19,7 +19,8 @@ import {
 } from './schema'
 import {
   FastifyTypeProvider,
-  FastifyTypeProviderDefault
+  FastifyTypeProviderDefault,
+  SafePromiseLike
 } from './type-provider'
 import { ContextConfigDefault, HTTPMethods, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault } from './utils'
 
@@ -30,7 +31,7 @@ export interface PrintRoutesOptions {
   includeHooks?: boolean
 }
 
-type AsyncFunction = (...args: any) => Promise<any>;
+type AsyncFunction = (...args: any) => Promise<any>
 
 export interface FastifyListenOptions {
   /**
@@ -96,7 +97,7 @@ type GetterSetter<This, T> = T | {
 type DecorationMethod<This, Return = This> = {
   <
     // Need to disable "no-use-before-define" to maintain backwards compatibility, as else decorate<Foo> would suddenly mean something new
-    // eslint-disable-next-line no-use-before-define
+
     T extends (P extends keyof This ? This[P] : unknown),
     P extends string | symbol = string | symbol
   >(property: P,
@@ -109,9 +110,7 @@ type DecorationMethod<This, Return = This> = {
 
   (property: string | symbol): Return;
 
-  (property: string | symbol, value: null): Return;
-
-  (property: string | symbol, value: null|undefined, dependencies: string[]): Return;
+  (property: string | symbol, value: null | undefined, dependencies: string[]): Return;
 }
 
 /**
@@ -122,7 +121,7 @@ export interface FastifyInstance<
   RawRequest extends RawRequestDefaultExpression<RawServer> = RawRequestDefaultExpression<RawServer>,
   RawReply extends RawReplyDefaultExpression<RawServer> = RawReplyDefaultExpression<RawServer>,
   Logger extends FastifyBaseLogger = FastifyBaseLogger,
-  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > {
   server: RawServer;
   pluginName: string;
@@ -137,14 +136,14 @@ export interface FastifyInstance<
   getSchema(schemaId: string): unknown;
   getSchemas(): Record<string, unknown>;
 
-  after(): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider> & PromiseLike<undefined>;
+  after(): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider> & SafePromiseLike<undefined>;
   after(afterListener: (err: Error | null) => void): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
 
   close(): Promise<undefined>;
   close(closeListener: () => void): undefined;
 
   /** Alias for {@linkcode FastifyInstance.close()} */
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+
   // @ts-ignore - type only available for @types/node >=17 or typescript >= 5.2
   [Symbol.asyncDispose](): Promise<undefined>;
 
@@ -169,61 +168,49 @@ export interface FastifyInstance<
   listen(opts?: FastifyListenOptions): Promise<string>;
   listen(callback: (err: Error | null, address: string) => void): void;
 
-  /**
-   * @deprecated Variadic listen method is deprecated. Please use `.listen(optionsObject, callback)` instead. The variadic signature will be removed in `fastify@5`
-   * @see https://github.com/fastify/fastify/pull/3712
-   */
-  listen(port: number | string, address: string, backlog: number, callback: (err: Error|null, address: string) => void): void;
-  /**
-   * @deprecated Variadic listen method is deprecated. Please use `.listen(optionsObject, callback)` instead. The variadic signature will be removed in `fastify@5`
-   * @see https://github.com/fastify/fastify/pull/3712
-   */
-  listen(port: number | string, address: string, callback: (err: Error|null, address: string) => void): void;
-  /**
-   * @deprecated Variadic listen method is deprecated. Please use `.listen(optionsObject, callback)` instead. The variadic signature will be removed in `fastify@5`
-   * @see https://github.com/fastify/fastify/pull/3712
-   */
-  listen(port: number | string, callback: (err: Error|null, address: string) => void): void;
-  /**
-   * @deprecated Variadic listen method is deprecated. Please use `.listen(optionsObject)` instead. The variadic signature will be removed in `fastify@5`
-   * @see https://github.com/fastify/fastify/pull/3712
-   */
-  listen(port: number | string, address?: string, backlog?: number): Promise<string>;
-
-  ready(): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider> & PromiseLike<undefined>;
-  ready(readyListener: (err: Error | null) => void): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
+  ready(): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider> & SafePromiseLike<undefined>;
+  ready(readyListener: (err: Error | null) => void | Promise<void>): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
 
-  register: FastifyRegister<FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider> & PromiseLike<undefined>>;
+  register: FastifyRegister<FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider> & SafePromiseLike<undefined>>;
 
   routing(req: RawRequest, res: RawReply): void;
-  getDefaultRoute(): DefaultRoute<RawRequest, RawReply>;
-  setDefaultRoute(defaultRoute: DefaultRoute<RawRequest, RawReply>): void;
 
   route<
     RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
     ContextConfig = ContextConfigDefault,
-    const SchemaCompiler extends FastifySchema = FastifySchema,
+    const SchemaCompiler extends FastifySchema = FastifySchema
   >(opts: RouteOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider, Logger>): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;
 
+  delete: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
   get: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
   head: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
+  patch: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
   post: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
   put: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
-  delete: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
   options: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
-  patch: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
+  propfind: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
+  proppatch: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
+  mkcalendar: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
+  mkcol: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
+  copy: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
+  move: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
+  lock: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
+  unlock: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
+  trace: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
+  report: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
+  search: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
   all: RouteShorthandMethod<RawServer, RawRequest, RawReply, TypeProvider, Logger>;
 
   hasRoute<
     RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
     ContextConfig = ContextConfigDefault,
-    SchemaCompiler extends FastifySchema = FastifySchema,
+    SchemaCompiler extends FastifySchema = FastifySchema
   >(opts: Pick<RouteOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>, 'method' | 'url' | 'constraints'>): boolean;
 
   findRoute<
     RouteGeneric extends RouteGenericInterface = RouteGenericInterface,
     ContextConfig = ContextConfigDefault,
-    SchemaCompiler extends FastifySchema = FastifySchema,
+    SchemaCompiler extends FastifySchema = FastifySchema
   >(opts: Pick<RouteOptions<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>, 'method' | 'url' | 'constraints'>): Omit<FindMyWayFindResult<RawServer>, 'store'>;
 
   // addHook: overloads

package/types/logger.d.ts

@@ -43,7 +43,7 @@ export type PinoLoggerOptions = pino.LoggerOptions
 export type ResSerializerReply<
   RawServer extends RawServerBase,
   RawReply extends FastifyReply<RawServer>
-> = Partial<RawReply> & Pick<RawReply, 'statusCode'>;
+> = Partial<RawReply> & Pick<RawReply, 'statusCode'>
 
 /**
  * Fastify Custom Logger options.
@@ -51,14 +51,14 @@ export type ResSerializerReply<
 export interface FastifyLoggerOptions<
   RawServer extends RawServerBase = RawServerDefault,
   RawRequest extends FastifyRequest<RouteGenericInterface, RawServer, RawRequestDefaultExpression<RawServer>, FastifySchema, FastifyTypeProvider> = FastifyRequest<RouteGenericInterface, RawServer, RawRequestDefaultExpression<RawServer>, FastifySchema, FastifyTypeProviderDefault>,
-  RawReply extends FastifyReply<RawServer, RawRequestDefaultExpression<RawServer>, RawReplyDefaultExpression<RawServer>, RouteGenericInterface, ContextConfigDefault, FastifySchema, FastifyTypeProvider> = FastifyReply<RawServer, RawRequestDefaultExpression<RawServer>, RawReplyDefaultExpression<RawServer>, RouteGenericInterface, ContextConfigDefault, FastifySchema, FastifyTypeProviderDefault>,
+  RawReply extends FastifyReply<RawServer, RawRequestDefaultExpression<RawServer>, RawReplyDefaultExpression<RawServer>, RouteGenericInterface, ContextConfigDefault, FastifySchema, FastifyTypeProvider> = FastifyReply<RawServer, RawRequestDefaultExpression<RawServer>, RawReplyDefaultExpression<RawServer>, RouteGenericInterface, ContextConfigDefault, FastifySchema, FastifyTypeProviderDefault>
 > {
   serializers?: {
     req?: (req: RawRequest) => {
       method?: string;
       url?: string;
       version?: string;
-      hostname?: string;
+      host?: string;
       remoteAddress?: string;
       remotePort?: number;
       [key: string]: unknown;

package/types/plugin.d.ts

@@ -14,7 +14,7 @@ export type FastifyPluginCallback<
   Options extends FastifyPluginOptions = Record<never, never>,
   Server extends RawServerBase = RawServerDefault,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
-  Logger extends FastifyBaseLogger = FastifyBaseLogger,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger
 > = (
   instance: FastifyInstance<Server, RawRequestDefaultExpression<Server>, RawReplyDefaultExpression<Server>, Logger, TypeProvider>,
   opts: Options,
@@ -30,11 +30,11 @@ export type FastifyPluginAsync<
   Options extends FastifyPluginOptions = Record<never, never>,
   Server extends RawServerBase = RawServerDefault,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
-  Logger extends FastifyBaseLogger = FastifyBaseLogger,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger
 > = (
   instance: FastifyInstance<Server, RawRequestDefaultExpression<Server>, RawReplyDefaultExpression<Server>, Logger, TypeProvider>,
   opts: Options
-) => Promise<void>;
+) => Promise<void>
 
 /**
  * Generic plugin type.

package/types/reply.d.ts

@@ -5,7 +5,7 @@ import { FastifyBaseLogger } from './logger'
 import { FastifyRequest } from './request'
 import { RouteGenericInterface } from './route'
 import { FastifySchema } from './schema'
-import { FastifyReplyType, FastifyTypeProvider, FastifyTypeProviderDefault, ResolveFastifyReplyType, CallTypeProvider } from './type-provider'
+import { CallSerializerTypeProvider, FastifyReplyType, FastifyTypeProvider, FastifyTypeProviderDefault, ResolveFastifyReplyType } from './type-provider'
 import { CodeToReplyKey, ContextConfigDefault, HttpKeys, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault, ReplyDefault, ReplyKeysToCodes, HttpHeader } from './utils'
 
 export interface ReplyGenericInterface {
@@ -18,13 +18,13 @@ type ReplyTypeConstrainer<RouteGenericReply, Code extends ReplyKeysToCodes<keyof
   RouteGenericReply extends HttpCodesReplyType & Record<Exclude<keyof RouteGenericReply, keyof HttpCodesReplyType>, never> ?
     Code extends keyof RouteGenericReply ? RouteGenericReply[Code] :
       CodeToReplyKey<Code> extends keyof RouteGenericReply ? RouteGenericReply[CodeToReplyKey<Code>] : unknown :
-    RouteGenericReply;
+    RouteGenericReply
 
 export type ResolveReplyTypeWithRouteGeneric<RouteGenericReply, Code extends ReplyKeysToCodes<keyof RouteGenericReply>,
   SchemaCompiler extends FastifySchema = FastifySchema,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault> =
   Code extends keyof SchemaCompiler['response'] ?
-    CallTypeProvider<TypeProvider, SchemaCompiler['response'][Code]> :
+    CallSerializerTypeProvider<TypeProvider, SchemaCompiler['response'][Code]> :
     ResolveFastifyReplyType<TypeProvider, SchemaCompiler, { Reply: ReplyTypeConstrainer<RouteGenericReply, Code> }>
 /**
  * FastifyReply is an instance of the standard http or http2 reply types.
@@ -57,24 +57,23 @@ export interface FastifyReply<
   getHeaders(): Record<HttpHeader, number | string | string[] | undefined>;
   removeHeader(key: HttpHeader): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
   hasHeader(key: HttpHeader): boolean;
-  // Note: should consider refactoring the argument order for redirect. statusCode is optional so it should be after the required url param
+  /**
+   * @deprecated The `reply.redirect()` method has a new signature: `reply.reply.redirect(url: string, code?: number)`. It will be enforced in `fastify@v5`'.
+   */
   redirect(statusCode: number, url: string): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
-  redirect(url: string): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
+  redirect(url: string, statusCode?: number): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
+  writeEarlyHints(hints: Record<string, string | string[]>, callback?: () => void): void;
   hijack(): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
   callNotFound(): void;
-  /**
-   * @deprecated Use the Reply#elapsedTime property instead
-   */
-  getResponseTime(): number;
   type(contentType: string): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
   serializer(fn: (payload: any) => string): FastifyReply<RawServer, RawRequest, RawReply, RouteGeneric, ContextConfig, SchemaCompiler, TypeProvider>;
   serialize(payload: any): string | ArrayBuffer | Buffer;
   // Serialization Methods
-  getSerializationFunction(httpStatus: string, contentType?: string): ((payload: {[key: string]: unknown}) => string) | undefined;
-  getSerializationFunction(schema: {[key: string]: unknown}): ((payload: {[key: string]: unknown}) => string) | undefined;
-  compileSerializationSchema(schema: {[key: string]: unknown}, httpStatus?: string, contentType?: string): (payload: {[key: string]: unknown}) => string;
-  serializeInput(input: {[key: string]: unknown}, schema: {[key: string]: unknown}, httpStatus?: string, contentType?: string): string;
-  serializeInput(input: {[key: string]: unknown}, httpStatus: string, contentType?: string): unknown;
+  getSerializationFunction(httpStatus: string, contentType?: string): ((payload: { [key: string]: unknown }) => string) | undefined;
+  getSerializationFunction(schema: { [key: string]: unknown }): ((payload: { [key: string]: unknown }) => string) | undefined;
+  compileSerializationSchema(schema: { [key: string]: unknown }, httpStatus?: string, contentType?: string): (payload: { [key: string]: unknown }) => string;
+  serializeInput(input: { [key: string]: unknown }, schema: { [key: string]: unknown }, httpStatus?: string, contentType?: string): string;
+  serializeInput(input: { [key: string]: unknown }, httpStatus: string, contentType?: string): unknown;
   then(fulfilled: () => void, rejected: (err: Error) => void): void;
   trailer: (
     key: string,

package/types/request.d.ts

@@ -75,6 +75,8 @@ export interface FastifyRequest<RouteGeneric extends RouteGenericInterface = Rou
   readonly req: RawRequest & RouteGeneric['Headers']; // this enables the developer to extend the existing http(s|2) headers list
   readonly ip: string;
   readonly ips?: string[];
+  readonly host: string;
+  readonly port: number;
   readonly hostname: string;
   readonly url: string;
   readonly originalUrl: string;
@@ -87,9 +89,9 @@ export interface FastifyRequest<RouteGeneric extends RouteGenericInterface = Rou
   readonly socket: RawRequest['socket'];
 
   getValidationFunction(httpPart: HTTPRequestPart): ValidationFunction
-  getValidationFunction(schema: {[key: string]: any}): ValidationFunction
-  compileValidationSchema(schema: {[key: string]: any}, httpPart?: HTTPRequestPart): ValidationFunction
-  validateInput(input: any, schema: {[key: string]: any}, httpPart?: HTTPRequestPart): boolean
+  getValidationFunction(schema: { [key: string]: any }): ValidationFunction
+  compileValidationSchema(schema: { [key: string]: any }, httpPart?: HTTPRequestPart): ValidationFunction
+  validateInput(input: any, schema: { [key: string]: any }, httpPart?: HTTPRequestPart): boolean
   validateInput(input: any, httpPart?: HTTPRequestPart): boolean
 
   // Prefer `socket` over deprecated `connection` property in node 13.0.0 or higher