fastify 3.17.0 → 3.19.1

package/GOVERNANCE.md

@@ -80,7 +80,7 @@ The consensus to grant a new candidate Collaborator status is reached when:
 - at least one of the Lead Maintainers approve
 - at least two of the Team Members approve
 
-After these conditions are satisfied, the [onboarding process](#onboarding-collaborators) may start.
+After these conditions are satisfied, the [onboarding process](CONTRIBUTING.md#onboarding-collaborators) may start.
 
 
 ## Lead Maintainers nominations

package/README.md

@@ -30,10 +30,6 @@ How can you efficiently handle the resources of your server, knowing that you ar
 
 Enter Fastify. Fastify is a web framework highly focused on providing the best developer experience with the least overhead and a powerful plugin architecture. It is inspired by Hapi and Express and as far as we know, it is one of the fastest web frameworks in town.
 
-### Requirements
-
-Node.js v10 LTS (10.16.0) or later.
-
 ### Quick start
 
 Create a folder and make it your current working directory:

package/build/build-validation.js

@@ -18,6 +18,7 @@ const defaultInitOptions = {
   bodyLimit: 1024 * 1024, // 1 MiB
   caseSensitive: true,
   disableRequestLogging: false,
+  jsonShorthand: true,
   ignoreTrailingSlash: false,
   maxParamLength: 100,
   onProtoPoisoning: 'error',
@@ -73,6 +74,7 @@ const schema = {
       type: 'boolean',
       default: false
     },
+    jsonShorthand: { type: 'boolean', default: defaultInitOptions.jsonShorthand },
     maxParamLength: { type: 'integer', default: defaultInitOptions.maxParamLength },
     onProtoPoisoning: { type: 'string', default: defaultInitOptions.onProtoPoisoning },
     onConstructorPoisoning: { type: 'string', default: defaultInitOptions.onConstructorPoisoning },

package/docs/ContentTypeParser.md

@@ -3,6 +3,8 @@
 ## `Content-Type` Parser
 Natively, Fastify only supports `'application/json'` and `'text/plain'` content types. The default charset is `utf-8`. If you need to support different content types, you can use the `addContentTypeParser` API. *The default JSON and/or plain text parser can be changed.*
 
+*Note: If you decide to specify your own content type with the `Content-Type` header, UTF-8 will not be the default. Be sure to include UTF-8 like this `text/html; charset=utf-8`.*
+
 As with the other APIs, `addContentTypeParser` is encapsulated in the scope in which it is declared. This means that if you declare it in the root scope it will be available everywhere, while if you declare it inside a plugin it will be available only in that scope and its children.
 
 Fastify automatically adds the parsed request payload to the [Fastify request](Request.md) object which you can access with `request.body`.

package/docs/Ecosystem.md

@@ -53,6 +53,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 
 #### [Community](#community)
 
+- [`@applicazza/fastify-nextjs`](https://github.com/applicazza/fastify-nextjs) Alternate Fastify and Next.js integration.
 - [`@coobaha/typed-fastify`](https://github.com/Coobaha/typed-fastify) Strongly typed routes with a runtime validation using JSON schema generated from types.
 - [`@dnlup/fastify-doc`](https://github.com/dnlup/fastify-doc) A plugin for sampling process metrics.
 - [`@dnlup/fastify-traps`](https://github.com/dnlup/fastify-traps) A plugin to close the server gracefully on `SIGINT` and `SIGTERM` signals.
@@ -63,6 +64,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`@mgcrea/fastify-session-sodium-crypto`](https://github.com/mgcrea/fastify-session-sodium-crypto) Fast sodium-based crypto for @mgcrea/fastify-session
 - [`@mgcrea/fastify-session`](https://github.com/mgcrea/fastify-session) Session plugin for Fastify that supports both stateless and stateful sessions
 - [`@mgcrea/pino-pretty-compact`](https://github.com/mgcrea/pino-pretty-compact) A custom compact pino-base prettifier
+- [`@trubavuong/fastify-seaweedfs`](https://github.com/trubavuong/fastify-seaweedfs) SeaweedFS for Fastify
 - [`apollo-server-fastify`](https://github.com/apollographql/apollo-server/tree/master/packages/apollo-server-fastify) Run an [Apollo Server](https://github.com/apollographql/apollo-server) to serve GraphQL with Fastify.
 - [`arecibo`](https://github.com/nucleode/arecibo) Fastify ping responder for Kubernetes Liveness and Readiness Probes.
 - [`cls-rtracer`](https://github.com/puzpuzpuz/cls-rtracer) Fastify middleware for CLS-based request ID generation. An out-of-the-box solution for adding request IDs into your logs.
@@ -75,6 +77,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`fastify-autoroutes`](https://github.com/GiovanniCardamone/fastify-autoroutes) Plugin to scan and load routes based on filesystem path from a custom directory.
 - [`fastify-axios`](https://github.com/davidedantonio/fastify-axios) Plugin to send HTTP requests via [axios](https://github.com/axios/axios).
 - [`fastify-babel`](https://github.com/cfware/fastify-babel) Fastify plugin for development servers that require Babel transformations of JavaScript sources.
+- [`fastify-bcrypt`](https://github.com/heply/fastify-bcrypt) A Bcrypt hash generator & checker.
 - [`fastify-blipp`](https://github.com/PavelPolyakov/fastify-blipp) Prints your routes to the console, so you definitely know which endpoints are available.
 - [`fastify-bookshelf`](https://github.com/butlerx/fastify-bookshelfjs) Fastify plugin to add [bookshelf.js](https://bookshelfjs.org/) ORM support.
 - [`fastify-boom`](https://github.com/jeromemacias/fastify-boom) Fastify plugin to add [boom](https://github.com/hapijs/boom) support.
@@ -89,6 +92,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`fastify-disablecache`](https://github.com/Fdawgs/fastify-disablecache) Fastify plugin to disable client-side caching, inspired by [nocache](https://github.com/helmetjs/nocache).
 - [`fastify-dynamodb`](https://github.com/matrus2/fastify-dynamodb) AWS DynamoDB plugin for Fastify. It exposes [AWS.DynamoDB.DocumentClient()](https://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/DynamoDB/DocumentClient.html) object.
 - [`fastify-dynareg`](https://github.com/greguz/fastify-dynareg) Dynamic plugin register for Fastify.
+- [`fastify-early-hints`](https://github.com/zekth/fastify-early-hints) Plugin to add HTTP 103 feature based on [RFC 8297](https://httpwg.org/specs/rfc8297.html)
 - [`fastify-envalid`](https://github.com/alemagio/fastify-envalid) Fastify plugin to integrate [envalid](https://github.com/af/envalid) in your Fastify project.
 - [`fastify-error-page`](https://github.com/hemerajs/fastify-error-page) Fastify plugin to print errors in structured HTML to the browser.
 - [`fastify-esso`](https://github.com/patrickpissurno/fastify-esso) The easiest authentication plugin for Fastify, with built-in support for Single sign-on (and great documentation).
@@ -98,6 +102,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`fastify-file-upload`](https://github.com/huangang/fastify-file-upload) Fastify plugin for uploading files.
 - [`fastify-firebase`](https://github.com/now-ims/fastify-firebase) Fastify plugin for [Firebase Admin SDK](https://firebase.google.com/docs/admin/setup) to Fastify so you can easily use Firebase Auth, Firestore, Cloud Storage, Cloud Messaging, and more.
 - [`fastify-firebase-auth`](https://github.com/oxsav/fastify-firebase-auth) Firebase Authentication for Fastify supporting all of the methods relating to the authentication API.
+- [`fastify-formidable`](https://github.com/climba03003/fastify-formidable) Handy plugin to provide multipart support and fastify-swagger integration.
 - [`fastify-gcloud-trace`](https://github.com/mkinoshi/fastify-gcloud-trace) [Google Cloud Trace API](https://cloud.google.com/trace/docs/reference) Connector for Fastify.
 - [`fastify-get-head`](https://github.com/MetCoder95/fastify-get-head) Small plugin to set a new HEAD route handler for each GET route previously registered in Fastify.
 - [`fastify-good-sessions`](https://github.com/Phara0h/fastify-good-sessions) A good Fastify sessions plugin focused on speed.
@@ -144,7 +149,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`fastify-objectionjs-classes`](https://github.com/kamikazechaser/fastify-objectionjs-classes) Plugin to cherry-pick classes from objectionjs ORM.
 - [`fastify-openapi-docs`](https://github.com/ShogunPanda/fastify-openapi-docs) A Fastify plugin that generates OpenAPI spec automatically.
 - [`fastify-openapi-glue`](https://github.com/seriousme/fastify-openapi-glue) Glue for OpenAPI specifications in Fastify, autogenerates routes based on an OpenAPI Specification.
-- [`fastify-opentelemetry`](https://github.com/autotelic/fastify-opentelemetry) A Fastify plugin that uses the [OpenTelemetry API](https://github.com/open-telemetry/opentelemetry-js/tree/master/packages/opentelemetry-api) to provide request tracing.
+- [`fastify-opentelemetry`](https://github.com/autotelic/fastify-opentelemetry) A Fastify plugin that uses the [OpenTelemetry API](https://github.com/open-telemetry/opentelemetry-js-api) to provide request tracing.
 - [`fastify-oracle`](https://github.com/cemremengu/fastify-oracle) Attaches an [`oracledb`](https://github.com/oracle/node-oracledb) connection pool to a Fastify server instance.
 - [`fastify-orientdb`](https://github.com/mahmed8003/fastify-orientdb) Fastify OrientDB connection plugin, with which you can share the OrientDB connection across every part of your server.
 - [`fastify-piscina`](https://github.com/piscinajs/fastify-piscina) A worker thread pool plugin using [Piscina](https://github.com/piscinajs/piscina).
@@ -164,6 +169,7 @@ Plugins maintained by the Fastify team are listed under [Core](#core) while plug
 - [`fastify-resty`](https://github.com/FastifyResty/fastify-resty) Fastify-based web framework with REST API routes auto-generation for TypeORM entities using DI and decorators.
 - [`fastify-reverse-routes`](https://github.com/dimonnwc3/fastify-reverse-routes) Fastify reverse routes plugin, allows to defined named routes and build path using name and parameters.
 - [`fastify-rob-config`](https://github.com/jeromemacias/fastify-rob-config) Fastify Rob-Config integration.
+- [`fastify-route-group`](https://github.com/TakNePoidet/fastify-route-group) Convenient grouping and inheritance of routes
 - [`fastify-schema-constraint`](https://github.com/Eomm/fastify-schema-constraint) Choose the JSON schema to use based on request parameters.
 - [`fastify-schema-to-typescript`](https://github.com/thomasthiebaud/fastify-schema-to-typescript) Generate typescript types based on your JSON/YAML validation schemas so they are always in sync.
 - [`fastify-secure-session`](https://github.com/mcollina/fastify-secure-session) Create a secure stateless cookie session for Fastify.

package/docs/Errors.md

@@ -68,6 +68,8 @@ The parser for this content type was already registered.
 
 The request body is larger than the provided limit.
 
+This setting can be defined in the Fastify server instance: [`bodyLimit`](Server.md#bodyLimit)
+
 <a name="FST_ERR_CTP_EMPTY_TYPE"></a>
 #### FST_ERR_CTP_EMPTY_TYPE
 

package/docs/Getting-Started.md

@@ -242,6 +242,8 @@ As discussed previously, Fastify offers a solid encapsulation model, to help you
 ### Validate your data
 Data validation is extremely important and a core concept of the framework.<br>
 To validate incoming requests, Fastify uses [JSON Schema](https://json-schema.org/).
+(JTD schemas are loosely supported, but `jsonShorthand` must be disabled first)
+
 Let's look at an example demonstrating validation for routes:
 ```js
 const opts = {

package/docs/Hooks.md

@@ -321,7 +321,7 @@ You can hook into the application-lifecycle as well.
 - [onRegister](#onregister)
 
 ### onReady
-Triggered before the server starts listening for requests. It cannot change the routes or add new hooks.
+Triggered before the server starts listening for requests and when `.ready()` is invoked. It cannot change the routes or add new hooks.
 Registered hook functions are executed serially.
 Only after all `onReady` hook functions have completed will the server start listening for requests.
 Hook functions accept one argument: a callback, `done`, to be invoked after the hook function is complete.

package/docs/LTS.md

@@ -19,9 +19,10 @@ out in this document:
    e.g. minimum supported Node.js version.
 
 1. Major releases will be tested and verified against all Node.js
-   releases that are supported by the
+   release lines that are supported by the
    [Node.js LTS policy](https://github.com/nodejs/Release) within the
-   LTS period of that given Fastify release line.
+   LTS period of that given Fastify release line. This implies that only
+   the latest Node.js release of a given line is supported.
 
 A "month" is defined as 30 consecutive days.
 

package/docs/Routes.md

@@ -69,6 +69,11 @@ They need to be in
 
   `reply` is defined in [Reply](Reply.md).
 
+**Notice:** The documentation of `onRequest`, `preParsing`, `preValidation`,
+`preHandler`, `preSerialization`, `onSend`, and `onResponse` are described in
+more detail in [Hooks](Hooks.md). Additionally, to send a response before the
+request is handled by the `handler` please refer to
+[Respond to a request from a hook](Hooks.md#respond-to-a-request-from-a-hook).
 
 Example:
 ```js

package/docs/Server.md

@@ -218,6 +218,37 @@ fastify.listen(3000)
 
 Internally Fastify uses the API of Node core HTTP server, so if you are using a custom server you must be sure to have the same API exposed. If not, you can enhance the server instance inside the `serverFactory` function before the `return` statement.<br/>
 
+<a name="schema-json-shorthand"></a>
+### `jsonShorthand`
+
++ Default: `true`
+
+Internally, and by default, Fastify will automatically infer the root properties of JSON Schemas if it doesn't find valid root properties according to the JSON Schema spec. If you wish to implement your own schema validation compiler, for example: to parse schemas as JTD instead of JSON Schema, then you can explicitly set this option to `false` to make sure the schemas you receive are unmodified and are not being treated internally as JSON Schema.
+
+```js
+const AjvJTD = require('ajv/dist/jtd'/* only valid for AJV v7+ */)
+const ajv = new AjvJTD({
+  // This would let you throw at start for invalid JTD schema objects
+  allErrors: process.env.NODE_ENV === 'development'
+})
+const fastify = Fastify({ jsonShorthand: false })
+fastify.setValidatorCompiler(({ schema }) => {
+  return ajv.compile(schema)
+})
+fastify.post('/', {
+  schema: {
+    body: {
+      properties: {
+        foo: { type: 'uint8' }
+      }
+    }
+  },
+  handler (req, reply) { reply.send({ ok: 1 }) }
+})
+```
+
+**Note: Fastify does not currently throw on invalid schemas, so if you turn this off in an existing project, you need to be careful that none of your existing schemas become invalid as a result, since they will be treated as a catch-all.**
+
 <a name="factory-case-sensitive"></a>
 ### `caseSensitive`
 
@@ -232,7 +263,7 @@ fastify.get('/user/:username', (request, reply) => {
 })
 ```
 
-Please note this setting this option to `false` goes against
+Please note that setting this option to `false` goes against
 [RFC3986](https://tools.ietf.org/html/rfc3986#section-6.2.2.1).
 
 <a name="factory-request-id-header"></a>
@@ -288,7 +319,7 @@ const fastify = Fastify({ trustProxy: true })
     }
     ```
 
-For more examples, refer to the [`@fastify/proxy-addr`](https://www.npmjs.com/package/@fastify/proxy-addr) package.
+For more examples, refer to the [`proxy-addr`](https://www.npmjs.com/package/proxy-addr) package.
 
 You may access the `ip`, `ips`, `hostname` and `protocol` values on the [`request`](Request.md) object.
 
@@ -967,6 +998,8 @@ fastify.register(function (instance, options, done) {
 }, { prefix: '/v1' })
 ```
 
+Fastify calls setNotFoundHandler to add a default 404 handler at startup before plugins are registered. If you would like to augment the behavior of the default 404 handler, for example with plugins, you can call setNotFoundHandler with no arguments `fastify.setNotFoundHandler()` within the context of these registered plugins.
+
 <a name="set-error-handler"></a>
 #### setErrorHandler
 
@@ -1026,6 +1059,31 @@ fastify.ready(() => {
 })
 ```
 
+`fastify.printRoutes({ includeMeta: (true | []) })` will display properties from the `route.store` object for each displayed route. This can be an `array` of keys (e.g. `['onRequest', Symbol('key')]`), or `true` to display all properties. A shorthand option, `fastify.printRoutes({ includeHooks: true })` will include all [hooks](https://www.fastify.io/docs/latest/Hooks/).
+
+```js
+  console.log(fastify.printRoutes({ includeHooks: true, includeMeta: ['metaProperty'] }))
+  // └── /
+  //     ├── test (GET)
+  //     │   • (onRequest) ["anonymous()","namedFunction()"]
+  //     │   • (metaProperty) "value"
+  //     │   └── /hello (GET)
+  //     └── hel
+  //         ├── lo/world (GET)
+  //         │   • (onTimeout) ["anonymous()"]
+  //         └── licopter (GET)
+
+  console.log(fastify.printRoutes({ includeHooks: true }))
+  // └── /
+  //     ├── test (GET)
+  //     │   • (onRequest) ["anonymous()","namedFunction()"]  
+  //     │   └── /hello (GET)
+  //     └── hel
+  //         ├── lo/world (GET)
+  //         │   • (onTimeout) ["anonymous()"]
+  //         └── licopter (GET)
+```
+
 <a name="print-plugins"></a>
 #### printPlugins
 
@@ -1042,9 +1100,9 @@ fastify.ready(() => {
   console.error(fastify.printPlugins())
   // will output the following to stderr:
   // └── root
-  //   ├── foo
-  //   │   └── bar
-  //   └── baz
+  //     ├── foo
+  //     │   └── bar
+  //     └── baz
 })
 ```
 

package/docs/TypeScript.md

@@ -265,6 +265,11 @@ In the last example we used interfaces to define the types for the request query
        const { username, password } = request.query
        done(username !== 'admin' ? new Error('Must be admin') : undefined)
      }
+     //  or if using async
+     //  preValidation: async (request, reply) => {
+     //    const { username, password } = request.query
+     //    return username !== "admin" ? new Error("Must be admin") : undefined;
+     //  }
    }, async (request, reply) => {
      const customerHeader = request.headers['h-Custom']
      // do something with request data
@@ -281,13 +286,15 @@ In the last example we used interfaces to define the types for the request query
        querystring: QuerystringSchema,
        headers: HeadersSchema
      },
-     preHandler: (request, reply) => {
+     preHandler: (request, reply, done) => {
        const { username, password } = request.query
        const customerHeader = request.headers['h-Custom']
+       done()
      },
      handler: (request, reply) => {
        const { username, password } = request.query
        const customerHeader = request.headers['h-Custom']
+       reply.status(200).send({username});
      }
    })
 
@@ -331,6 +338,7 @@ const todo = {
 With the provided type `FromSchema` you can build a type from your schema and use it in your handler.
 
 ```typescript
+import { FromSchema } from "json-schema-to-ts";
 fastify.post<{ Body: FromSchema<typeof todo> }>(
   '/todo',
   {

package/docs/Validation-and-Serialization.md

@@ -253,7 +253,7 @@ curl -X GET "http://localhost:3000/?ids=1
 {"params":{"hello":["1"]}}
 ```
 
-For further information see [here](https://ajv.js.org/docs/coercion.html)
+For further information see [here](https://ajv.js.org/coercion.html)
 
 <a name="ajv-plugins"></a>
 #### Ajv Plugins

package/fastify.d.ts

@@ -1,7 +1,6 @@
 import * as http from 'http'
 import * as http2 from 'http2'
 import * as https from 'https'
-import * as LightMyRequest from 'light-my-request'
 import { ConstraintStrategy, HTTPVersion } from 'find-my-way'
 
 import { FastifyRequest, RequestGenericInterface } from './types/request'
@@ -55,7 +54,8 @@ export type FastifyHttp2SecureOptions<
   Logger extends FastifyLoggerInstance = FastifyLoggerInstance
 > = FastifyServerOptions<Server, Logger> & {
   http2: true,
-  https: http2.SecureServerOptions
+  https: http2.SecureServerOptions,
+  http2SessionTimeout?: number
 }
 
 export type FastifyHttp2Options<
@@ -63,7 +63,7 @@ export type FastifyHttp2Options<
   Logger extends FastifyLoggerInstance = FastifyLoggerInstance
 > = FastifyServerOptions<Server, Logger> & {
   http2: true,
-  http2SessionTimeout?: number,
+  http2SessionTimeout?: number
 }
 
 export type FastifyHttpsOptions<
@@ -159,6 +159,7 @@ export interface ValidationResult {
 }
 
 /* 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'

package/fastify.js

@@ -4,9 +4,8 @@ const Avvio = require('avvio')
 const http = require('http')
 const querystring = require('querystring')
 let lightMyRequest
-let version
-let versionLoaded = false
 
+const { version } = require('./package.json')
 const {
   kAvvioBoot,
   kChildren,
@@ -35,7 +34,7 @@ const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTI
 const decorator = require('./lib/decorate')
 const ContentTypeParser = require('./lib/contentTypeParser')
 const SchemaController = require('./lib/schema-controller')
-const { Hooks, hookRunnerApplication } = require('./lib/hooks')
+const { Hooks, hookRunnerApplication, supportedHooks } = require('./lib/hooks')
 const { createLogger } = require('./lib/logger')
 const pluginUtils = require('./lib/pluginUtils')
 const reqIdGenFactory = require('./lib/reqIdGenFactory')
@@ -58,6 +57,19 @@ const onBadUrlContext = {
   onError: []
 }
 
+function defaultBuildPrettyMeta (route) {
+  // return a shallow copy of route's sanitized context
+
+  const cleanKeys = {}
+  const allowedProps = ['errorHandler', 'logLevel', 'logSerializers']
+
+  allowedProps.concat(supportedHooks).forEach(k => {
+    cleanKeys[k] = route.store[k]
+  })
+
+  return Object.assign({}, cleanKeys)
+}
+
 function defaultErrorHandler (error, request, reply) {
   if (reply.statusCode < 500) {
     reply.log.info(
@@ -158,7 +170,8 @@ function fastify (options) {
       constraints: constraints,
       ignoreTrailingSlash: options.ignoreTrailingSlash || defaultInitOptions.ignoreTrailingSlash,
       maxParamLength: options.maxParamLength || defaultInitOptions.maxParamLength,
-      caseSensitive: options.caseSensitive
+      caseSensitive: options.caseSensitive,
+      buildPrettyMeta: defaultBuildPrettyMeta
     }
   })
 
@@ -278,7 +291,7 @@ function fastify (options) {
     // fake http injection
     inject: inject,
     // pretty print of the registered routes
-    printRoutes: router.printRoutes,
+    printRoutes,
     // custom error handling
     setNotFoundHandler: setNotFoundHandler,
     setErrorHandler: setErrorHandler,
@@ -309,9 +322,6 @@ function fastify (options) {
     },
     version: {
       get () {
-        if (versionLoaded === false) {
-          version = loadVersion()
-        }
         return version
       }
     },
@@ -626,6 +636,12 @@ function fastify (options) {
     this[kErrorHandler] = func.bind(this)
     return this
   }
+
+  function printRoutes (opts = {}) {
+    // includeHooks:true - shortcut to include all supported hooks exported by fastify.Hooks
+    opts.includeMeta = opts.includeHooks ? opts.includeMeta ? supportedHooks.concat(opts.includeMeta) : supportedHooks : opts.includeMeta
+    return router.printRoutes(opts)
+  }
 }
 
 function validateSchemaErrorFormatter (schemaErrorFormatter) {
@@ -655,20 +671,6 @@ function wrapRouting (httpHandler, { rewriteUrl, logger }) {
   }
 }
 
-function loadVersion () {
-  versionLoaded = true
-  const fs = require('fs')
-  const path = require('path')
-  try {
-    const pkgPath = path.join(__dirname, 'package.json')
-    fs.accessSync(pkgPath, fs.constants.R_OK)
-    const pkg = JSON.parse(fs.readFileSync(pkgPath))
-    return pkg.name === 'fastify' ? pkg.version : undefined
-  } catch (e) {
-    return undefined
-  }
-}
-
 /**
  * These export configurations enable JS and TS developers
  * to consumer fastify in whatever way best suits their needs.