fastify 4.10.2 → 4.12.0

package/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2016-2022 The Fastify Team
+Copyright (c) 2016-2023 The Fastify Team
 
 The Fastify team members are listed at https://github.com/fastify/fastify#team
 and in the README file.

package/README.md

@@ -289,8 +289,6 @@ listed in alphabetical order.
 ### Fastify Core team
 * [__Tommaso Allevi__](https://github.com/allevo),
   <https://twitter.com/allevitommaso>, <https://www.npmjs.com/~allevo>
-* [__Ethan Arrowood__](https://github.com/Ethan-Arrowood/),
-  <https://twitter.com/arrowoodtech>, <https://www.npmjs.com/~ethan_arrowood>
 * [__Harry Brundage__](https://github.com/airhorns/),
   <https://twitter.com/harrybrundage>, <https://www.npmjs.com/~airhorns>
 * [__David Mark Clements__](https://github.com/davidmarkclements),
@@ -362,6 +360,8 @@ to join this group by Lead Maintainers.
   <https://twitter.com/cemremengu>, <https://www.npmjs.com/~cemremengu>
 * [__Nathan Woltman__](https://github.com/nwoltman),
   <https://twitter.com/NathanWoltman>, <https://www.npmjs.com/~nwoltman>
+* [__Ethan Arrowood__](https://github.com/Ethan-Arrowood/),
+  <https://twitter.com/arrowoodtech>, <https://www.npmjs.com/~ethan_arrowood>
 
 ## Hosted by
 

package/docs/Guides/Ecosystem.md

@@ -220,6 +220,10 @@ section.
   plugin to authenticate HTTP requests based on api key and signature
 - [`fastify-appwrite`](https://github.com/Dev-Manny/fastify-appwrite) Fastify
   Plugin for interacting with Appwrite server.
+- [`fastify-at-mysql`](https://github.com/mateonunez/fastify-at-mysql) Fastify
+  MySQL plugin with auto SQL injection attack prevention.
+- [`fastify-at-postgres`](https://github.com/mateonunez/fastify-at-postgres) Fastify
+  Postgres plugin with auto SQL injection attack prevention.
 - [`fastify-auth0-verify`](https://github.com/nearform/fastify-auth0-verify):
   Auth0 verification plugin for Fastify, internally uses
   [fastify-jwt](https://npm.im/fastify-jwt) and
@@ -362,6 +366,9 @@ section.
 - [`fastify-influxdb`](https://github.com/alex-ppg/fastify-influxdb) Fastify
   InfluxDB plugin connecting to an InfluxDB instance via the Influx default
   package.
+- [`fastify-ip`](https://github.com/metcoder95/fastify-ip) A plugin
+  for Fastify that allows you to infer a request ID by a
+  given set of custom Request headers.
 - [`fastify-jwt-authz`](https://github.com/Ethan-Arrowood/fastify-jwt-authz) JWT
   user scope verifier.
 - [`fastify-jwt-webapp`](https://github.com/charlesread/fastify-jwt-webapp) JWT
@@ -387,6 +394,9 @@ section.
 - [`fastify-lured`](https://github.com/lependu/fastify-lured) Plugin to load lua
   scripts with [fastify-redis](https://github.com/fastify/fastify-redis) and
   [lured](https://github.com/enobufs/lured).
+- [`fastify-lyra`](https://github.com/mateonunez/fastify-lyra)
+  A plugin to implement [Lyra](https://github.com/LyraSearch/lyra) search engine
+  on Fastify.
 - [`fastify-mailer`](https://github.com/coopflow/fastify-mailer) Plugin to
   initialize and encapsulate [Nodemailer](https://nodemailer.com)'s transporters
   instances in Fastify.
@@ -467,6 +477,8 @@ section.
 - [`fastify-postgraphile`](https://github.com/alemagio/fastify-postgraphile)
   Plugin to integrate [PostGraphile](https://www.graphile.org/postgraphile/) in
   a Fastify project.
+- [`fastify-postgres-dot-js`](https://github.com/kylerush/fastify-postgresjs) Fastify
+  PostgreSQL connection plugin that uses [Postgres.js](https://github.com/porsager/postgres).
 - [`fastify-prettier`](https://github.com/hsynlms/fastify-prettier) A Fastify
   plugin that uses [prettier](https://github.com/prettier/prettier) under the
   hood to beautify outgoing responses and/or other things in the Fastify server.
@@ -565,6 +577,8 @@ section.
   for [zod](https://github.com/colinhacks/zod).
 - [`fastify-typeorm-plugin`](https://github.com/inthepocket/fastify-typeorm-plugin)
   Fastify plugin to work with TypeORM.
+- [`fastify-user-agent`](https://github.com/Eomm/fastify-user-agent) parses your
+  request's `user-agent` header.
 - [`fastify-vhost`](https://github.com/patrickpissurno/fastify-vhost) Proxy
   subdomain HTTP requests to another server (useful if you want to point
   multiple subdomains to the same IP address, while running different servers on

package/docs/Guides/Migration-Guide-V4.md

@@ -39,6 +39,11 @@ const res = await fastify.inject('/encapsulated')
 console.log(res.json().message) // 'wrapped'
 ```
 
+>The root error handler is Fastify’s generic error handler. 
+>This error handler will use the headers and status code in the Error object, 
+>if they exist. **The headers and status code will not be automatically set if
+>a custom error handler is provided**. 
+
 ### Removed `app.use()` ([#3506](https://github.com/fastify/fastify/pull/3506))
 
 With v4 of Fastify, `app.use()` has been removed and the use of middleware is

package/docs/Reference/Errors.md

@@ -112,6 +112,9 @@ fastify.setErrorHandler(function (error, request, reply) {
     this.log.error(error)
     // Send error response
     reply.status(500).send({ ok: false })
+  } else {
+    // fastify will use parent error handler to handle this
+    reply.send(error)
   }
 })
 
@@ -382,4 +385,4 @@ Impossible to load plugin because the parent (mapped directly from `avvio`)
 <a name="FST_ERR_PLUGIN_TIMEOUT"></a>
 #### FST_ERR_PLUGIN_TIMEOUT
 
-Plugin did not start in time. Default timeout (in millis): `10000`
+Plugin did not start in time. Default timeout (in millis): `10000`

package/docs/Reference/Reply.md

@@ -674,6 +674,15 @@ fastify.get('/streams', function (request, reply) {
   reply.send(stream)
 })
 ```
+When using async-await you will need to return or await the reply object:
+```js
+fastify.get('/streams', async function (request, reply) {
+  const fs = require('fs')
+  const stream = fs.createReadStream('some-file', 'utf8')
+  reply.header('Content-Type', 'application/octet-stream')
+  return reply.send(stream)
+})
+```
 
 #### Buffers
 <a id="send-buffers"></a>
@@ -689,6 +698,16 @@ fastify.get('/streams', function (request, reply) {
 })
 ```
 
+When using async-await you will need to return or await the reply object:
+```js
+const fs = require('fs')
+fastify.get('/streams', async function (request, reply) {
+  fs.readFile('some-file', (err, fileBuffer) => {
+    reply.send(err || fileBuffer)
+  })
+  return reply
+})
+```
 #### Errors
 <a id="errors"></a>
 

package/docs/Reference/Server.md

@@ -1011,6 +1011,9 @@ Note that the array contains the `fastify.server.address()` too.
 #### getDefaultRoute
 <a id="getDefaultRoute"></a>
 
+**Notice**: this method is deprecated and should be removed in the next Fastify
+major version.
+
 The `defaultRoute` handler handles requests that do not match any URL specified
 by your Fastify application. This defaults to the 404 handler, but can be
 overridden with [setDefaultRoute](#setdefaultroute). Method to get the
@@ -1023,14 +1026,25 @@ const defaultRoute = fastify.getDefaultRoute()
 #### setDefaultRoute
 <a id="setDefaultRoute"></a>
 
-**Note**: The default 404 handler, or one set using `setNotFoundHandler`, will
-never trigger if the default route is overridden. This sets the handler for the 
+**Notice**: this method is deprecated and should be removed in the next Fastify
+major version. Please, consider to use `setNotFoundHandler` or a wildcard
+matching route.
+
+The default 404 handler, or one set using `setNotFoundHandler`, will
+never trigger if the default route is overridden. This sets the handler for the
 Fastify application, not just the current instance context. Use
 [setNotFoundHandler](#setnotfoundhandler) if you want to customize 404 handling
-instead. Method to set the `defaultRoute` for the server:
+instead.
+
+This method sets the `defaultRoute` for the server. Note that, its purpose is
+to interact with the underlying raw requests. Unlike other Fastify handlers, the
+arguments received are of type [RawRequest](./TypeScript.md#rawrequest) and
+[RawReply](./TypeScript.md#rawreply) respectively.
 
 ```js
 const defaultRoute = function (req, res) {
+  // req = RawRequest
+  // res = RawReply
   res.end('hello world')
 }
 
@@ -1670,7 +1684,7 @@ information.
 `fastify.defaultTextParser()` can be used to parse content as plain text.
 
 ```js
-fastify.addContentTypeParser('text/json', { asString: true }, fastify.defaultTextParser())
+fastify.addContentTypeParser('text/json', { asString: true }, fastify.defaultTextParser)
 ```
 
 #### errorHandler

package/fastify.d.ts

@@ -1,26 +1,190 @@
 import * as http from 'http'
 import * as http2 from 'http2'
 import * as https from 'https'
-import { ConstraintStrategy, HTTPVersion } from 'find-my-way'
+import { Socket } from 'net'
 
-import { FastifyRequest, RequestGenericInterface } from './types/request'
-import { RawServerBase, RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression } from './types/utils'
-import { FastifyBaseLogger, FastifyLoggerInstance, FastifyLoggerOptions, PinoLoggerOptions } from './types/logger'
-import { FastifyInstance } from './types/instance'
-import { FastifyServerFactory } from './types/serverFactory'
-import { Options as AjvOptions } from '@fastify/ajv-compiler'
-import { Options as FJSOptions } from '@fastify/fast-json-stringify-compiler'
+import { Options as AjvOptions, ValidatorCompiler } from '@fastify/ajv-compiler'
 import { FastifyError } from '@fastify/error'
+import { Options as FJSOptions, SerializerCompiler } from '@fastify/fast-json-stringify-compiler'
+import { ConstraintStrategy, HTTPVersion } from 'find-my-way'
+import { Chain as LightMyRequestChain, InjectOptions, Response as LightMyRequestResponse, CallbackFunc as LightMyRequestCallback } from 'light-my-request'
+
+import { FastifyBodyParser, FastifyContentTypeParser, AddContentTypeParser, hasContentTypeParser, getDefaultJsonParser, ProtoAction, ConstructorAction } from './types/content-type-parser'
+import { FastifyContext, FastifyContextConfig } from './types/context'
+import { FastifyErrorCodes } from './types/errors'
+import { DoneFuncWithErrOrRes, HookHandlerDoneFunction, RequestPayload, onCloseAsyncHookHandler, onCloseHookHandler, onErrorAsyncHookHandler, onErrorHookHandler, onReadyAsyncHookHandler, onReadyHookHandler, onRegisterHookHandler, onRequestAsyncHookHandler, onRequestHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler, onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler, preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler, preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler, preValidationHookHandler } from './types/hooks'
+import { FastifyListenOptions, FastifyInstance, PrintRoutesOptions } from './types/instance'
+import { FastifyBaseLogger, FastifyLoggerInstance, FastifyLoggerOptions, PinoLoggerOptions, FastifyLogFn, LogLevel } from './types/logger'
+import { FastifyPluginCallback, FastifyPluginAsync, FastifyPluginOptions, FastifyPlugin } from './types/plugin'
+import { FastifyRegister, FastifyRegisterOptions, RegisterOptions } from './types/register'
 import { FastifyReply } from './types/reply'
-import { FastifySchemaValidationError } from './types/schema'
-import { ConstructorAction, ProtoAction } from "./types/content-type-parser";
-import { Socket } from 'net'
-import { ValidatorCompiler } from '@fastify/ajv-compiler'
-import { SerializerCompiler } from '@fastify/fast-json-stringify-compiler'
-import { FastifySchema } from './types/schema'
-import { FastifyContextConfig } from './types/context'
+import { FastifyRequest, RequestGenericInterface } from './types/request'
+import { RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler, RouteGenericInterface } from './types/route'
+import { FastifySchema, FastifySchemaCompiler, FastifySchemaValidationError } from './types/schema'
+import { FastifyServerFactory, FastifyServerFactoryHandler } from './types/serverFactory'
 import { FastifyTypeProvider, FastifyTypeProviderDefault } from './types/type-provider'
-import { FastifyErrorCodes } from './types/errors'
+import { HTTPMethods, RawServerBase, RawRequestDefaultExpression, RawReplyDefaultExpression, RawServerDefault, ContextConfigDefault, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault } from './types/utils'
+
+declare module '@fastify/error' {
+  interface FastifyError {
+    validation?: fastify.ValidationResult[];
+    validationContext?: 'body' | 'headers' | 'parameters' | 'querystring';
+  }
+}
+
+type Fastify = typeof fastify
+
+declare namespace fastify {
+  export const errorCodes: FastifyErrorCodes;
+
+  export type FastifyHttp2SecureOptions<
+    Server extends http2.Http2SecureServer,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = FastifyServerOptions<Server, Logger> & {
+    http2: true,
+    https: http2.SecureServerOptions,
+    http2SessionTimeout?: number
+  }
+
+  export type FastifyHttp2Options<
+    Server extends http2.Http2Server,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = FastifyServerOptions<Server, Logger> & {
+    http2: true,
+    http2SessionTimeout?: number
+  }
+
+  export type FastifyHttpsOptions<
+    Server extends https.Server,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = FastifyServerOptions<Server, Logger> & {
+    https: https.ServerOptions | null
+  }
+
+  type FindMyWayVersion<RawServer extends RawServerBase> = RawServer extends http.Server ? HTTPVersion.V1 : HTTPVersion.V2
+
+  export interface ConnectionError extends Error {
+    code: string,
+    bytesParsed: number,
+    rawPacket: {
+      type: string,
+      data: number[]
+    }
+  }
+
+  type TrustProxyFunction = (address: string, hop: number) => boolean
+
+  /**
+   * Options for a fastify server instance. Utilizes conditional logic on the generic server parameter to enforce certain https and http2
+   */
+  export type FastifyServerOptions<
+    RawServer extends RawServerBase = RawServerDefault,
+    Logger extends FastifyBaseLogger = FastifyBaseLogger
+  > = {
+    ignoreTrailingSlash?: boolean,
+    ignoreDuplicateSlashes?: boolean,
+    connectionTimeout?: number,
+    keepAliveTimeout?: number,
+    maxRequestsPerSocket?: number,
+    forceCloseConnections?: boolean | 'idle',
+    requestTimeout?: number,
+    pluginTimeout?: number,
+    bodyLimit?: number,
+    maxParamLength?: number,
+    disableRequestLogging?: boolean,
+    exposeHeadRoutes?: boolean,
+    onProtoPoisoning?: ProtoAction,
+    onConstructorPoisoning?: ConstructorAction,
+    logger?: boolean | FastifyLoggerOptions<RawServer> & PinoLoggerOptions | Logger,
+    serializerOpts?: FJSOptions | Record<string, unknown>,
+    serverFactory?: FastifyServerFactory<RawServer>,
+    caseSensitive?: boolean,
+    requestIdHeader?: string | false,
+    requestIdLogLabel?: string;
+    jsonShorthand?: boolean;
+    genReqId?: <RequestGeneric extends RequestGenericInterface = RequestGenericInterface, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault>(req: FastifyRequest<RequestGeneric, RawServer, RawRequestDefaultExpression<RawServer>, FastifySchema, TypeProvider>) => string,
+    trustProxy?: boolean | string | string[] | number | TrustProxyFunction,
+    querystringParser?: (str: string) => { [key: string]: unknown },
+    /**
+     * @deprecated Prefer using the `constraints.version` property
+     */
+    versioning?: {
+      storage(): {
+        get(version: string): string | null,
+        set(version: string, store: Function): void
+        del(version: string): void,
+        empty(): void
+      },
+      deriveVersion<Context>(req: Object, ctx?: Context): string // not a fan of using Object here. Also what is Context? Can either of these be better defined?
+    },
+    constraints?: {
+      [name: string]: ConstraintStrategy<FindMyWayVersion<RawServer>, unknown>,
+    },
+    schemaController?: {
+      bucket?: (parentSchemas?: unknown) => {
+        add(schema: unknown): FastifyInstance;
+        getSchema(schemaId: string): unknown;
+        getSchemas(): Record<string, unknown>;
+      };
+      compilersFactory?: {
+        buildValidator?: ValidatorCompiler;
+        buildSerializer?: SerializerCompiler;
+      };
+    };
+    return503OnClosing?: boolean,
+    ajv?: {
+      customOptions?: AjvOptions,
+      plugins?: (Function | [Function, unknown])[]
+    },
+    frameworkErrors?: <RequestGeneric extends RequestGenericInterface = RequestGenericInterface, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault, SchemaCompiler extends FastifySchema = FastifySchema>(
+      error: FastifyError,
+      req: FastifyRequest<RequestGeneric, RawServer, RawRequestDefaultExpression<RawServer>, FastifySchema, TypeProvider>,
+      res: FastifyReply<RawServer, RawRequestDefaultExpression<RawServer>, RawReplyDefaultExpression<RawServer>, RequestGeneric, FastifyContextConfig, SchemaCompiler, TypeProvider>
+    ) => void,
+    rewriteUrl?: (req: RawRequestDefaultExpression<RawServer>) => string,
+    schemaErrorFormatter?: (errors: FastifySchemaValidationError[], dataVar: string) => Error,
+    /**
+     * listener to error events emitted by client connections
+     */
+    clientErrorHandler?: (error: ConnectionError, socket: Socket) => void
+  }
+
+  export interface ValidationResult {
+    keyword: string;
+    instancePath: string;
+    schemaPath: string;
+    params: Record<string, string | string[]>;
+    message?: string;
+  }
+
+  /* Export additional types */
+  export type {
+    LightMyRequestChain, InjectOptions, LightMyRequestResponse, LightMyRequestCallback, // 'light-my-request'
+    FastifyRequest, RequestGenericInterface, // './types/request'
+    FastifyReply, // './types/reply'
+    FastifyPluginCallback, FastifyPluginAsync, FastifyPluginOptions, FastifyPlugin, // './types/plugin'
+    FastifyListenOptions, FastifyInstance, PrintRoutesOptions, // './types/instance'
+    FastifyLoggerOptions, FastifyBaseLogger, FastifyLoggerInstance, FastifyLogFn, LogLevel, // './types/logger'
+    FastifyContext, FastifyContextConfig, // './types/context'
+    RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler, RouteGenericInterface, // './types/route'
+    FastifyRegister, FastifyRegisterOptions, RegisterOptions, // './types/register'
+    FastifyBodyParser, FastifyContentTypeParser, AddContentTypeParser, hasContentTypeParser, getDefaultJsonParser, ProtoAction, ConstructorAction, // './types/content-type-parser'
+    FastifyError, // '@fastify/error'
+    FastifySchema, FastifySchemaCompiler, // './types/schema'
+    HTTPMethods, RawServerBase, RawRequestDefaultExpression, RawReplyDefaultExpression, RawServerDefault, ContextConfigDefault, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault, // './types/utils'
+    DoneFuncWithErrOrRes, HookHandlerDoneFunction, RequestPayload, onCloseAsyncHookHandler, onCloseHookHandler, onErrorAsyncHookHandler, onErrorHookHandler, onReadyAsyncHookHandler, onReadyHookHandler, onRegisterHookHandler, onRequestAsyncHookHandler, onRequestHookHandler, onResponseAsyncHookHandler, onResponseHookHandler, onRouteHookHandler, onSendAsyncHookHandler, onSendHookHandler, onTimeoutAsyncHookHandler, onTimeoutHookHandler, preHandlerAsyncHookHandler, preHandlerHookHandler, preParsingAsyncHookHandler, preParsingHookHandler, preSerializationAsyncHookHandler, preSerializationHookHandler, preValidationAsyncHookHandler, preValidationHookHandler, // './types/hooks'
+    FastifyServerFactory, FastifyServerFactoryHandler, // './types/serverFactory'
+    FastifyTypeProvider, FastifyTypeProviderDefault, // './types/type-provider'
+    FastifyErrorCodes, // './types/errors'
+  }
+  // named export
+  // import { plugin } from 'plugin'
+  // const { plugin } = require('plugin')
+  export const fastify: Fastify
+  // default export
+  // import plugin from 'plugin'
+  export { fastify as default }
+}
 
 /**
  * Fastify factory function for the standard fastify http, https, or http2 server instance.
@@ -34,183 +198,34 @@ declare function fastify<
   Server extends http2.Http2SecureServer,
   Request extends RawRequestDefaultExpression<Server> = RawRequestDefaultExpression<Server>,
   Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
-  Logger extends FastifyBaseLogger = FastifyLoggerInstance,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
->(opts: FastifyHttp2SecureOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & PromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
+>(opts: fastify.FastifyHttp2SecureOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & PromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
 
 declare function fastify<
   Server extends http2.Http2Server,
   Request extends RawRequestDefaultExpression<Server> = RawRequestDefaultExpression<Server>,
   Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
-  Logger extends FastifyBaseLogger = FastifyLoggerInstance,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
->(opts: FastifyHttp2Options<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & PromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
+>(opts: fastify.FastifyHttp2Options<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & PromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
 
 declare function fastify<
   Server extends https.Server,
   Request extends RawRequestDefaultExpression<Server> = RawRequestDefaultExpression<Server>,
   Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
-  Logger extends FastifyBaseLogger = FastifyLoggerInstance,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
->(opts: FastifyHttpsOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & PromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
+>(opts: fastify.FastifyHttpsOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & PromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
 
 declare function fastify<
   Server extends http.Server,
   Request extends RawRequestDefaultExpression<Server> = RawRequestDefaultExpression<Server>,
   Reply extends RawReplyDefaultExpression<Server> = RawReplyDefaultExpression<Server>,
-  Logger extends FastifyBaseLogger = FastifyLoggerInstance,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
->(opts?: FastifyServerOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & PromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
-
-declare namespace fastify {
-  export const errorCodes: FastifyErrorCodes;
-}
-
-export default fastify
-
-export type FastifyHttp2SecureOptions<
-  Server extends http2.Http2SecureServer,
-  Logger extends FastifyBaseLogger = FastifyLoggerInstance
-> = FastifyServerOptions<Server, Logger> & {
-  http2: true,
-  https: http2.SecureServerOptions,
-  http2SessionTimeout?: number
-}
-
-export type FastifyHttp2Options<
-  Server extends http2.Http2Server,
-  Logger extends FastifyBaseLogger = FastifyLoggerInstance
-> = FastifyServerOptions<Server, Logger> & {
-  http2: true,
-  http2SessionTimeout?: number
-}
-
-export type FastifyHttpsOptions<
-  Server extends https.Server,
-  Logger extends FastifyBaseLogger = FastifyLoggerInstance
-> = FastifyServerOptions<Server, Logger> & {
-  https: https.ServerOptions | null
-}
-
-type FindMyWayVersion<RawServer extends RawServerBase> = RawServer extends http.Server ? HTTPVersion.V1 : HTTPVersion.V2
-
-export interface ConnectionError extends Error {
-  code: string,
-  bytesParsed: number,
-  rawPacket: {
-    type: string,
-    data: number[]
-  }
-}
-
-/**
- * Options for a fastify server instance. Utilizes conditional logic on the generic server parameter to enforce certain https and http2
- */
-export type FastifyServerOptions<
-  RawServer extends RawServerBase = RawServerDefault,
-  Logger extends FastifyBaseLogger = FastifyLoggerInstance
-> = {
-  ignoreTrailingSlash?: boolean,
-  ignoreDuplicateSlashes?: boolean,
-  connectionTimeout?: number,
-  keepAliveTimeout?: number,
-  maxRequestsPerSocket?: number,
-  forceCloseConnections?: boolean | 'idle',
-  requestTimeout?: number,
-  pluginTimeout?: number,
-  bodyLimit?: number,
-  maxParamLength?: number,
-  disableRequestLogging?: boolean,
-  exposeHeadRoutes?: boolean,
-  onProtoPoisoning?: ProtoAction,
-  onConstructorPoisoning?: ConstructorAction,
-  logger?: boolean | FastifyLoggerOptions<RawServer> & PinoLoggerOptions | Logger,
-  serializerOpts?: FJSOptions | Record<string, unknown>,
-  serverFactory?: FastifyServerFactory<RawServer>,
-  caseSensitive?: boolean,
-  requestIdHeader?: string | false,
-  requestIdLogLabel?: string;
-  jsonShorthand?: boolean;
-  genReqId?: <RequestGeneric extends RequestGenericInterface = RequestGenericInterface, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault>(req: FastifyRequest<RequestGeneric, RawServer, RawRequestDefaultExpression<RawServer>, FastifySchema, TypeProvider>) => string,
-  trustProxy?: boolean | string | string[] | number | TrustProxyFunction,
-  querystringParser?: (str: string) => { [key: string]: unknown },
-  /**
-   * @deprecated Prefer using the `constraints.version` property
-   */
-  versioning?: {
-    storage(): {
-      get(version: string): string | null,
-      set(version: string, store: Function): void
-      del(version: string): void,
-      empty(): void
-    },
-    deriveVersion<Context>(req: Object, ctx?: Context): string // not a fan of using Object here. Also what is Context? Can either of these be better defined?
-  },
-  constraints?: {
-    [name: string]: ConstraintStrategy<FindMyWayVersion<RawServer>, unknown>,
-  },
-  schemaController?: {
-    bucket?: (parentSchemas?: unknown) => {
-      add(schema: unknown): FastifyInstance;
-      getSchema(schemaId: string): unknown;
-      getSchemas(): Record<string, unknown>;
-    };
-    compilersFactory?: {
-      buildValidator?: ValidatorCompiler;
-      buildSerializer?: SerializerCompiler;
-    };
-  };
-  return503OnClosing?: boolean,
-  ajv?: {
-    customOptions?: AjvOptions,
-    plugins?: (Function | [Function, unknown])[]
-  },
-  frameworkErrors?: <RequestGeneric extends RequestGenericInterface = RequestGenericInterface, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault, SchemaCompiler extends FastifySchema = FastifySchema>(
-    error: FastifyError,
-    req: FastifyRequest<RequestGeneric, RawServer, RawRequestDefaultExpression<RawServer>, FastifySchema, TypeProvider>,
-    res: FastifyReply<RawServer, RawRequestDefaultExpression<RawServer>, RawReplyDefaultExpression<RawServer>, RequestGeneric, FastifyContextConfig, SchemaCompiler, TypeProvider>
-  ) => void,
-  rewriteUrl?: (req: RawRequestDefaultExpression<RawServer>) => string,
-  schemaErrorFormatter?: (errors: FastifySchemaValidationError[], dataVar: string) => Error,
-  /**
-   * listener to error events emitted by client connections
-   */
-  clientErrorHandler?: (error: ConnectionError, socket: Socket) => void
-}
-
-type TrustProxyFunction = (address: string, hop: number) => boolean
-
-declare module '@fastify/error' {
-  interface FastifyError {
-    validation?: ValidationResult[];
-    validationContext?: 'body' | 'headers' | 'parameters' | 'querystring';
-  }
-}
-
-export interface ValidationResult {
-  keyword: string;
-  instancePath: string;
-  schemaPath: string;
-  params: Record<string, string | string[]>;
-  message?: string;
-}
+>(opts?: fastify.FastifyServerOptions<Server, Logger>): FastifyInstance<Server, Request, Reply, Logger, TypeProvider> & PromiseLike<FastifyInstance<Server, Request, Reply, Logger, TypeProvider>>
 
-/* Export all additional types */
-export type { Chain as LightMyRequestChain, InjectOptions, Response as LightMyRequestResponse, CallbackFunc as LightMyRequestCallback } from 'light-my-request'
-export { FastifyRequest, RequestGenericInterface } from './types/request'
-export { FastifyReply } from './types/reply'
-export { FastifyPluginCallback, FastifyPluginAsync, FastifyPluginOptions, FastifyPlugin } from './types/plugin'
-export { FastifyListenOptions, FastifyInstance, PrintRoutesOptions } from './types/instance'
-export { FastifyLoggerOptions, FastifyBaseLogger, FastifyLoggerInstance, FastifyLogFn, LogLevel } from './types/logger'
-export { FastifyContext, FastifyContextConfig } from './types/context'
-export { RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler, RouteGenericInterface } from './types/route'
-export * from './types/register'
-export { FastifyBodyParser, FastifyContentTypeParser, AddContentTypeParser, hasContentTypeParser, getDefaultJsonParser, ProtoAction, ConstructorAction } from './types/content-type-parser'
-export { FastifyError } from '@fastify/error'
-export { FastifySchema, FastifySchemaCompiler } from './types/schema'
-export { HTTPMethods, RawServerBase, RawRequestDefaultExpression, RawReplyDefaultExpression, RawServerDefault, ContextConfigDefault, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault } from './types/utils'
-export * from './types/hooks'
-export { FastifyServerFactory, FastifyServerFactoryHandler } from './types/serverFactory'
-export { FastifyTypeProvider, FastifyTypeProviderDefault } from './types/type-provider'
-export { FastifyErrorCodes } from './types/errors'
-export { fastify }
+// CJS export
+// const fastify = require('fastify')
+export = fastify

package/fastify.js

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

package/lib/contentTypeParser.js

@@ -2,9 +2,7 @@
 
 const { AsyncResource } = require('async_hooks')
 const lru = require('tiny-lru').lru
-// TODO: find more perforamant solution
-const { parse: parseContentType } = require('content-type')
-
+const { safeParse: safeParseContentType, defaultContentType } = require('fast-content-type-parse')
 const secureJson = require('secure-json-parse')
 const {
   kDefaultJsonParse,
@@ -70,6 +68,7 @@ ContentTypeParser.prototype.add = function (contentType, opts, parserFn) {
     if (contentTypeIsString) {
       this.parserList.unshift(new ParserListItem(contentType))
     } else {
+      contentType.isEssence = contentType.source.indexOf(';') === -1
       this.parserRegExpList.unshift(contentType)
     }
     this.customParsers.set(contentType.toString(), parser)
@@ -103,7 +102,7 @@ ContentTypeParser.prototype.getParser = function (contentType) {
 
   // dummyContentType always the same object
   // we can use === for the comparsion and return early
-  if (parsed === dummyContentType) {
+  if (parsed === defaultContentType) {
     return this.customParsers.get('')
   }
 
@@ -307,6 +306,7 @@ function buildContentTypeParser (c) {
   contentTypeParser[kDefaultJsonParse] = c[kDefaultJsonParse]
   contentTypeParser.customParsers = new Map(c.customParsers.entries())
   contentTypeParser.parserList = c.parserList.slice()
+  contentTypeParser.parserRegExpList = c.parserRegExpList.slice()
   return contentTypeParser
 }
 
@@ -358,17 +358,6 @@ function removeAllContentTypeParsers () {
   this[kContentTypeParser].removeAll()
 }
 
-// dummy here to prevent repeated object creation
-const dummyContentType = { type: '', parameters: Object.create(null) }
-
-function safeParseContentType (contentType) {
-  try {
-    return parseContentType(contentType)
-  } catch (err) {
-    return dummyContentType
-  }
-}
-
 function compareContentType (contentType, parserListItem) {
   if (parserListItem.isEssence) {
     // we do essence check
@@ -389,7 +378,7 @@ function compareContentType (contentType, parserListItem) {
 }
 
 function compareRegExpContentType (contentType, essenceMIMEType, regexp) {
-  if (regexp.source.indexOf(';') === -1) {
+  if (regexp.isEssence) {
     // we do essence check
     return regexp.test(essenceMIMEType)
   } else {

package/lib/error-serializer.js

@@ -5,6 +5,9 @@
 
   
 
+// eslint-disable-next-line
+const STR_ESCAPE = /[\u0000-\u001f\u0022\u005c\ud800-\udfff]|[\ud800-\udbff](?![\udc00-\udfff])|(?:[^\ud800-\udbff]|^)[\udc00-\udfff]/
+
 class Serializer {
   constructor (options = {}) {
     switch (options.rounding) {
@@ -99,6 +102,11 @@ class Serializer {
       str = str.toString()
     }
 
+    // Fast escape chars check
+    if (!STR_ESCAPE.test(str)) {
+      return quotes + str + quotes
+    }
+
     if (str.length < 42) {
       return this.asStringSmall(str)
     } else {

package/lib/route.js

@@ -89,9 +89,11 @@ function buildRouting (options) {
     hasRoute,
     prepareRoute,
     getDefaultRoute: function () {
+      warning.emit('FSTDEP014')
       return router.defaultRoute
     },
     setDefaultRoute: function (defaultRoute) {
+      warning.emit('FSTDEP014')
       if (typeof defaultRoute !== 'function') {
         throw new FST_ERR_DEFAULT_ROUTE_INVALID_TYPE()
       }

package/lib/warnings.js

@@ -25,4 +25,6 @@ warning.create('FastifyDeprecation', 'FSTDEP012', 'Request#context property acce
 
 warning.create('FastifyDeprecation', 'FSTDEP013', 'Direct return of "trailers" function is deprecated. Please use "callback" or "async-await" for return value. The support of direct return will removed in `fastify@5`.')
 
+warning.create('FastifyDeprecation', 'FSTDEP014', 'You are trying to set/access the default route. This property is deprecated. Please, use setNotFoundHandler if you want to custom a 404 handler or the wildcard (*) to match all routes.')
+
 module.exports = warning

package/lib/wrapThenable.js

@@ -35,7 +35,13 @@ function wrapThenable (thenable, reply) {
     }
 
     reply[kReplyIsError] = true
-    reply.send(err)
+
+    // try-catch allow to re-throw error in error handler for async handler
+    try {
+      reply.send(err)
+    } catch (err) {
+      reply.send(err)
+    }
   })
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "4.10.2",
+  "version": "4.12.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -154,7 +154,7 @@
     "json-schema-to-ts": "^2.5.5",
     "JSONStream": "^1.3.5",
     "license-checker": "^25.0.1",
-    "markdownlint-cli2": "^0.5.1",
+    "markdownlint-cli2": "^0.6.0",
     "proxyquire": "^2.1.3",
     "pump": "^3.0.0",
     "self-cert": "^2.0.0",
@@ -164,7 +164,7 @@
     "split2": "^4.1.0",
     "standard": "^17.0.0",
     "tap": "^16.3.0",
-    "tsd": "^0.24.1",
+    "tsd": "^0.25.0",
     "typescript": "^4.8.3",
     "undici": "^5.10.0",
     "vary": "^1.1.2",
@@ -176,7 +176,7 @@
     "@fastify/fast-json-stringify-compiler": "^4.1.0",
     "abstract-logging": "^2.0.1",
     "avvio": "^8.2.0",
-    "content-type": "^1.0.4",
+    "fast-content-type-parse": "^1.0.0",
     "find-my-way": "^7.3.0",
     "light-my-request": "^5.6.1",
     "pino": "^8.5.0",

package/test/close-pipelining.test.js

@@ -36,7 +36,7 @@ test('Should return 503 while closing - pipelining', async t => {
   await instance.close()
 })
 
-const isV19plus = semver.satisfies(process.version, '>= v19.0.0')
+const isV19plus = semver.gte(process.version, '19.0.0')
 test('Should not return 503 while closing - pipelining - return503OnClosing: false, skip Node >= v19.x', { skip: isV19plus }, async t => {
   const fastify = Fastify({
     return503OnClosing: false,

package/test/close.test.js

@@ -203,7 +203,7 @@ test('Should return error while closing (callback) - injection', t => {
   })
 })
 
-const isV19plus = semver.satisfies(process.version, '>= v19.0.0')
+const isV19plus = semver.gte(process.version, '19.0.0')
 t.test('Current opened connection should continue to work after closing and return "connection: close" header - return503OnClosing: false, skip Node >= v19.x', { skip: isV19plus }, t => {
   const fastify = Fastify({
     return503OnClosing: false,

package/test/content-parser.test.js

@@ -609,3 +609,46 @@ test('content-type fail when parameters not match - regexp', async t => {
 
   t.same(response.statusCode, 415)
 })
+
+// Refs: https://github.com/fastify/fastify/issues/4495
+test('content-type regexp list should be cloned when plugin override', async t => {
+  t.plan(6)
+
+  const fastify = Fastify()
+
+  fastify.addContentTypeParser(/^image\/.*/, { parseAs: 'buffer' }, (req, payload, done) => {
+    done(null, payload)
+  })
+
+  fastify.register(function plugin (fastify, options, done) {
+    fastify.post('/', function (request, reply) {
+      reply.type(request.headers['content-type']).send(request.body)
+    })
+
+    done()
+  })
+
+  {
+    const { payload, headers, statusCode } = await fastify.inject({
+      method: 'POST',
+      path: '/',
+      payload: 'jpeg',
+      headers: { 'content-type': 'image/jpeg' }
+    })
+    t.same(statusCode, 200)
+    t.same(headers['content-type'], 'image/jpeg')
+    t.same(payload, 'jpeg')
+  }
+
+  {
+    const { payload, headers, statusCode } = await fastify.inject({
+      method: 'POST',
+      path: '/',
+      payload: 'png',
+      headers: { 'content-type': 'image/png' }
+    })
+    t.same(statusCode, 200)
+    t.same(headers['content-type'], 'image/png')
+    t.same(payload, 'png')
+  }
+})

package/test/default-route.test.js

@@ -3,6 +3,51 @@
 const t = require('tap')
 const test = t.test
 const Fastify = require('..')
+const warning = require('../lib/warnings')
+
+// Silence the standard warning logs. We will test the messages explicitly.
+process.removeAllListeners('warning')
+
+test('setDefaultRoute should emit a deprecation warning', t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+  const defaultRoute = (req, res) => {
+    res.end('hello from defaultRoute')
+  }
+
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'FastifyDeprecation')
+    t.equal(warning.code, 'FSTDEP014')
+  }
+
+  t.teardown(() => {
+    process.removeListener('warning', onWarning)
+    warning.emitted.set('FSTDEP014', false)
+  })
+
+  fastify.setDefaultRoute(defaultRoute)
+})
+
+test('getDefaultRoute should emit a deprecation warning', t => {
+  t.plan(2)
+
+  const fastify = Fastify()
+
+  process.on('warning', onWarning)
+  function onWarning (warning) {
+    t.equal(warning.name, 'FastifyDeprecation')
+    t.equal(warning.code, 'FSTDEP014')
+  }
+
+  t.teardown(() => {
+    process.removeListener('warning', onWarning)
+    warning.emitted.set('FSTDEP014', false)
+  })
+
+  fastify.getDefaultRoute()
+})
 
 test('should fail if defaultRoute is not a function', t => {
   t.plan(1)

package/test/reply-error.test.js

@@ -514,6 +514,34 @@ test('error thrown by custom error handler routes to default error handler', t =
   })
 })
 
+// Refs: https://github.com/fastify/fastify/pull/4484#issuecomment-1367301750
+test('allow re-thrown error to default error handler when route handler is async and error handler is sync', t => {
+  t.plan(4)
+  const fastify = Fastify()
+
+  fastify.setErrorHandler(function (error) {
+    t.equal(error.message, 'kaboom')
+    throw Error('kabong')
+  })
+
+  fastify.get('/', async function () {
+    throw Error('kaboom')
+  })
+
+  fastify.inject({
+    url: '/',
+    method: 'GET'
+  }, (err, res) => {
+    t.error(err)
+    t.equal(res.statusCode, 500)
+    t.same(JSON.parse(res.payload), {
+      error: statusCodes['500'],
+      message: 'kabong',
+      statusCode: 500
+    })
+  })
+})
+
 // Issue 2078 https://github.com/fastify/fastify/issues/2078
 // Supported error code list: http://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
 const invalidErrorCodes = [

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

@@ -12,6 +12,7 @@ import { FastifyReply } from '../../types/reply'
 import { FastifyRequest } from '../../types/request'
 import { DefaultRoute } from '../../types/route'
 import { FastifySchemaControllerOptions, FastifySchemaCompiler, FastifySerializerCompiler } from '../../types/schema'
+import { AddressInfo } from 'net'
 
 const server = fastify()
 
@@ -26,6 +27,7 @@ expectAssignable<FastifyInstance>(server.addSchema({
 }))
 
 expectType<Record<string, unknown>>(server.getSchemas())
+expectType<AddressInfo[]>(server.addresses())
 expectType<unknown>(server.getSchema('SchemaId'))
 expectType<string>(server.printRoutes())
 expectType<string>(server.printPlugins())

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

@@ -123,6 +123,21 @@ const serverAutoInferredFileOption = fastify({
 
 expectType<FastifyBaseLogger>(serverAutoInferredFileOption.log)
 
+const serverAutoInferredSerializerResponseObjectOption = fastify({
+  logger: {
+    serializers: {
+      res (ServerResponse) {
+        expectType<FastifyReply>(ServerResponse)
+        return {
+          status: '200'
+        }
+      }
+    }
+  }
+})
+
+expectType<FastifyBaseLogger>(serverAutoInferredSerializerResponseObjectOption.log)
+
 const serverAutoInferredSerializerObjectOption = fastify({
   logger: {
     serializers: {

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

@@ -101,3 +101,46 @@ expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(async (
 expectAssignable<ServerWithTypeProvider>(serverWithTypeProvider.register(async (instance: ServerWithTypeProvider) => {
   expectAssignable<ServerWithTypeProvider>(instance)
 }))
+
+// With Type Provider and logger
+const customLogger = {
+  level: 'info',
+  info: () => { },
+  warn: () => { },
+  error: () => { },
+  fatal: () => { },
+  trace: () => { },
+  debug: () => { },
+  child: () => customLogger,
+  silent: () => { }
+}
+const serverWithTypeProviderAndLogger = fastify({
+  logger: customLogger
+}).withTypeProvider<TestTypeProvider>()
+type ServerWithTypeProviderAndLogger = FastifyInstance<Server, IncomingMessage, ServerResponse, typeof customLogger, TestTypeProvider>
+const testPluginWithTypeProviderAndLogger: FastifyPluginCallback<TestOptions, RawServerDefault, TestTypeProvider, typeof customLogger> = function (instance, opts, done) { }
+const testPluginWithTypeProviderAndLoggerAsync: FastifyPluginAsync<TestOptions, RawServerDefault, TestTypeProvider, typeof customLogger> = async function (instance, opts) { }
+const testPluginWithTypeProviderAndLoggerWithType = (instance: ServerWithTypeProviderAndLogger, opts: FastifyPluginOptions, done: (error?: FastifyError) => void) => { }
+const testPluginWithTypeProviderAndLoggerWithTypeAsync = async (instance: ServerWithTypeProviderAndLogger, opts: FastifyPluginOptions) => { }
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginCallback))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginAsync))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginOpts))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginOptsAsync))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginOptsWithType))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginOptsWithTypeAsync))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLogger))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerAsync))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerWithType))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(testPluginWithTypeProviderAndLoggerWithTypeAsync))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register((instance) => {
+  expectAssignable<FastifyInstance>(instance)
+}))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register((instance: ServerWithTypeProviderAndLogger) => {
+  expectAssignable<ServerWithTypeProviderAndLogger>(instance)
+}))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(async (instance) => {
+  expectAssignable<FastifyInstance>(instance)
+}))
+expectAssignable<ServerWithTypeProviderAndLogger>(serverWithTypeProviderAndLogger.register(async (instance: ServerWithTypeProviderAndLogger) => {
+  expectAssignable<ServerWithTypeProviderAndLogger>(instance)
+}))

package/types/instance.d.ts

@@ -21,6 +21,7 @@ import {
   FastifyTypeProviderDefault
 } from './type-provider'
 import { ContextConfigDefault, RawReplyDefaultExpression, RawRequestDefaultExpression, RawServerBase, RawServerDefault } from './utils'
+import { AddressInfo } from 'net'
 
 export interface PrintRoutesOptions {
   includeMeta?: boolean | (string | symbol)[]
@@ -92,6 +93,7 @@ export interface FastifyInstance<
   version: string;
   log: Logger;
 
+  addresses(): AddressInfo[]
   withTypeProvider<Provider extends FastifyTypeProvider>(): FastifyInstance<RawServer, RawRequest, RawReply, Logger, Provider>;
 
   addSchema(schema: unknown): FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>;

package/types/logger.d.ts

@@ -60,7 +60,7 @@ export interface FastifyLoggerOptions<
       [key: string]: unknown;
     };
     res?: (res: RawReply) => {
-      statusCode: string | number;
+      statusCode?: string | number;
       [key: string]: unknown;
     };
   };

package/types/plugin.d.ts

@@ -10,8 +10,13 @@ export type FastifyPluginOptions = Record<string, any>
  *
  * Fastify allows the user to extend its functionalities with plugins. A plugin can be a set of routes, a server decorator or whatever. To activate plugins, use the `fastify.register()` method.
  */
-export type FastifyPluginCallback<Options extends FastifyPluginOptions = Record<never, never>, Server extends RawServerBase = RawServerDefault, TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault> = (
-  instance: FastifyInstance<Server, RawRequestDefaultExpression<Server>, RawReplyDefaultExpression<Server>, FastifyBaseLogger, TypeProvider>,
+export type FastifyPluginCallback<
+  Options extends FastifyPluginOptions = Record<never, never>,
+  Server extends RawServerBase = RawServerDefault,
+  TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
+> = (
+  instance: FastifyInstance<Server, RawRequestDefaultExpression<Server>, RawReplyDefaultExpression<Server>, Logger, TypeProvider>,
   opts: Options,
   done: (err?: Error) => void
 ) => void
@@ -25,8 +30,9 @@ export type FastifyPluginAsync<
   Options extends FastifyPluginOptions = Record<never, never>,
   Server extends RawServerBase = RawServerDefault,
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault,
+  Logger extends FastifyBaseLogger = FastifyBaseLogger,
 > = (
-  instance: FastifyInstance<Server, RawRequestDefaultExpression<Server>, RawReplyDefaultExpression<Server>, FastifyBaseLogger, TypeProvider>,
+  instance: FastifyInstance<Server, RawRequestDefaultExpression<Server>, RawReplyDefaultExpression<Server>, Logger, TypeProvider>,
   opts: Options
 ) => Promise<void>;
 

package/types/register.d.ts

@@ -2,7 +2,7 @@ import { FastifyPluginOptions, FastifyPluginCallback, FastifyPluginAsync } from
 import { LogLevel } from './logger'
 import { FastifyInstance } from './instance'
 import { RawServerBase } from './utils'
-import { FastifyTypeProvider, RawServerDefault } from '../fastify'
+import { FastifyBaseLogger, FastifyTypeProvider, RawServerDefault } from '../fastify'
 
 export interface RegisterOptions {
   prefix?: string;
@@ -17,17 +17,17 @@ export type FastifyRegisterOptions<Options> = (RegisterOptions & Options) | ((in
  *
  * Function for adding a plugin to fastify. The options are inferred from the passed in FastifyPlugin parameter.
  */
-export interface FastifyRegister<T = void, RawServer extends RawServerBase = RawServerDefault, TypeProviderDefault extends FastifyTypeProvider = FastifyTypeProvider> {
-  <Options extends FastifyPluginOptions, Server extends RawServerBase = RawServer, TypeProvider extends FastifyTypeProvider = TypeProviderDefault>(
-    plugin: FastifyPluginCallback<Options, Server, TypeProvider>,
+export interface FastifyRegister<T = void, RawServer extends RawServerBase = RawServerDefault, TypeProviderDefault extends FastifyTypeProvider = FastifyTypeProvider, LoggerDefault extends FastifyBaseLogger = FastifyBaseLogger> {
+  <Options extends FastifyPluginOptions, Server extends RawServerBase = RawServer, TypeProvider extends FastifyTypeProvider = TypeProviderDefault, Logger extends FastifyBaseLogger = LoggerDefault>(
+    plugin: FastifyPluginCallback<Options, Server, TypeProvider, Logger>,
     opts?: FastifyRegisterOptions<Options>
   ): T;
-  <Options extends FastifyPluginOptions, Server extends RawServerBase = RawServer, TypeProvider extends FastifyTypeProvider = TypeProviderDefault>(
-    plugin: FastifyPluginAsync<Options, Server, TypeProvider>,
+  <Options extends FastifyPluginOptions, Server extends RawServerBase = RawServer, TypeProvider extends FastifyTypeProvider = TypeProviderDefault, Logger extends FastifyBaseLogger = LoggerDefault>(
+    plugin: FastifyPluginAsync<Options, Server, TypeProvider, Logger>,
     opts?: FastifyRegisterOptions<Options>
   ): T;
-  <Options extends FastifyPluginOptions, Server extends RawServerBase = RawServer, TypeProvider extends FastifyTypeProvider = TypeProviderDefault>(
-    plugin: FastifyPluginCallback<Options, Server, TypeProvider> | FastifyPluginAsync<Options, Server, TypeProvider> | Promise<{ default: FastifyPluginCallback<Options, Server, TypeProvider> }> | Promise<{ default: FastifyPluginAsync<Options, Server, TypeProvider> }>,
+  <Options extends FastifyPluginOptions, Server extends RawServerBase = RawServer, TypeProvider extends FastifyTypeProvider = TypeProviderDefault, Logger extends FastifyBaseLogger = LoggerDefault>(
+    plugin: FastifyPluginCallback<Options, Server, TypeProvider, Logger> | FastifyPluginAsync<Options, Server, TypeProvider, Logger> | Promise<{ default: FastifyPluginCallback<Options, Server, TypeProvider, Logger> }> | Promise<{ default: FastifyPluginAsync<Options, Server, TypeProvider, Logger> }>,
     opts?: FastifyRegisterOptions<Options>
   ): T;
 }