fastify 5.0.0-alpha.4 → 5.0.0

package/README.md

@@ -346,6 +346,10 @@ listed in alphabetical order.
   <https://twitter.com/simonebu>, <https://www.npmjs.com/~simoneb>
 * [__Gürgün Dayıoğlu__](https://github.com/gurgunday),
   <https://www.npmjs.com/~gurgunday>
+* [__Dan Castillo__](https://github.com/dancastillo),
+  <https://www.npmjs.com/~dancastillo>
+* [__Jean Michelet__](https://github.com/jean-michelet),
+  <https://www.npmjs.com/~jean-michelet>
 
 ### Great Contributors
 Great contributors on a specific area in the Fastify ecosystem will be invited

package/docs/Guides/Getting-Started.md

@@ -143,7 +143,7 @@ declaration](../Reference/Routes.md) docs).
 ```js
 // ESM
 import Fastify from 'fastify'
-import firstRoute from './our-first-route'
+import firstRoute from './our-first-route.js'
 /**
  * @type {import('fastify').FastifyInstance} Instance of Fastify
  */
@@ -232,8 +232,8 @@ npm i fastify-plugin @fastify/mongodb
 ```js
 // ESM
 import Fastify from 'fastify'
-import dbConnector from './our-db-connector'
-import firstRoute from './our-first-route'
+import dbConnector from './our-db-connector.js'
+import firstRoute from './our-first-route.js'
 
 /**
  * @type {import('fastify').FastifyInstance} Instance of Fastify

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

@@ -9,25 +9,29 @@ work after upgrading.
 ## Codemods
 ### Fastify v4 Codemods
 
-To help with the upgrade, we’ve worked with the team at codemod.com to
+To help with the upgrade, we’ve worked with the team at 
+[Codemod](https://github.com/codemod-com/codemod) to
 publish codemods that will automatically update your code to many of 
 the new APIs and patterns in Fastify v4.
-Run the following codemods to automatically update your code for Fastify v4 migration:
+
+Run the following 
+[migration recipe](https://go.codemod.com/fastify-4-migration-recipe) to 
+automatically update your code to Fastify v4:
 
 ```
 npx codemod@latest fastify/4/migration-recipe
 ```
 
-This will run the following codemods from the Fastify Codemod repository:
+This will run the following codemods:
 
-- **fastify/4/remove-app-use**
-- **fastify/4/reply-raw-access**
-- **fastify/4/wrap-routes-plugin**
-- **fastify/4/await-register-calls**
+- [`fastify/4/remove-app-use`](https://go.codemod.com/fastify-4-remove-app-use)
+- [`fastify/4/reply-raw-access`](https://go.codemod.com/fastify-4-reply-raw-access)
+- [`fastify/4/wrap-routes-plugin`](https://go.codemod.com/fastify-4-wrap-routes-plugin)
+- [`fastify/4/await-register-calls`](https://go.codemod.com/fastify-4-await-register-calls)
 
 Each of these codemods automates the changes listed in the v4 migration guide.
 For a complete list of available Fastify codemods and further details, 
-see the [codemod registry](https://codemod.com/registry?q=fastify).
+see [Codemod Registry](https://go.codemod.com/fastify).
 
 
 ## Breaking Changes

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

@@ -3,11 +3,103 @@
 This guide is intended to help with migration from Fastify v4 to v5.
 
 Before migrating to v5, please ensure that you have fixed all deprecation
-warnings from v4. All v4 deprecations have been removed and they will no longer
+warnings from v4. All v4 deprecations have been removed and will no longer
 work after upgrading.
 
+## Long Term Support Cycle
+
+Fastify v5 will only support Node.js v20+. If you are using an older version of
+Node.js, you will need to upgrade to a newer version to use Fastify v5.
+
+Fastify v4 is still supported until June 30, 2025. If you are unable to upgrade,
+you should consider buying an end-of-life support plan from HeroDevs.
+
+### Why Node.js v20?
+
+Fastify v5 will only support Node.js v20+ because it has significant differences
+compared to v18, such as
+better support for `node:test`. This allows us to provide a better developer
+experience and streamline maintenance.
+
+Node.js v18 will exit Long Term Support on April 30, 2025, so you should be planning
+to upgrade to v20 anyway.
+
 ## Breaking Changes
 
+### Full JSON Schema is now required for `querystring`, `params` and `body` and response schemas
+
+Starting with v5, Fastify will require a full JSON schema for the `querystring`,
+`params` and `body` schema. Note that the `jsonShortHand` option has been
+removed as well.
+
+If the default JSON Schema validator is used, you will need
+to provide a full JSON schema for the
+`querystring`, `params`, `body`, and `response` schemas,
+including the `type` property.
+
+```js
+// v4
+fastify.get('/route', {
+  schema: {
+    querystring: {
+      name: { type: 'string' }
+    }
+  }
+}, (req, reply) => {
+  reply.send({ hello: req.query.name });
+});
+```
+
+```js
+// v5
+fastify.get('/route', {
+  schema: {
+    querystring: {
+      type: 'object',
+      properties: {
+        name: { type: 'string' }
+      },
+      required: ['name']
+    }
+  }
+}, (req, reply) => {
+  reply.send({ hello: req.query.name });
+});
+```
+
+See [#5586](https://github.com/fastify/fastify/pull/5586) for more details
+
+Note that it's still possible to override the JSON Schema validator to
+use a different format, such as Zod. This change simplifies that as well.
+
+This change helps with integration of other tools, such as
+[`@fastify/swagger`](https://github.com/fastify/fastify-swagger).
+
+### New logger constructor signature
+
+In Fastify v4, Fastify accepted the options to build a pino
+logger in the `logger` option, as well as a custom logger instance.
+This was the source of significant confusion.
+
+As a result, the `logger` option will not accept a custom logger anymore in v5.
+To use a custom logger, you should use the `loggerInstance` option instead:
+
+```js
+// v4
+const logger = require('pino')();
+const fastify = require('fastify')({
+  logger
+});
+```
+
+```js
+// v5
+const loggerInstance = require('pino')();
+const fastify = require('fastify')({
+  loggerInstance
+});
+```
+
 ### `useSemicolonDelimiter` false by default
 
 Starting with v5, Fastify instances will no longer default to supporting the use
@@ -18,3 +110,479 @@ behavior and not adhering to [RFC 3986](https://www.rfc-editor.org/rfc/rfc3986#s
 If you still wish to use semicolons as delimiters, you can do so by
 setting `useSemicolonDelimiter: true` in the server configuration.
 
+```js
+const fastify = require('fastify')({
+  useSemicolonDelimiter: true
+});
+```
+
+### The parameters object no longer has a prototype
+
+In v4, the `parameters` object had a prototype. This is no longer the case in v5.
+This means that you can no longer access properties inherited from `Object` on
+the `parameters` object, such as `toString` or `hasOwnProperty`.
+
+```js
+// v4
+fastify.get('/route/:name', (req, reply) => {
+  console.log(req.params.hasOwnProperty('name')); // true
+  return { hello: req.params.name };
+});
+```
+
+```js
+// v5
+fastify.get('/route/:name', (req, reply) => {
+  console.log(Object.hasOwn(req.params, 'name')); // true
+  return { hello: req.params.name };
+});
+```
+
+This increases the security of the application by hardening against prototype
+pollution attacks.
+
+### Type Providers now differentiate between validator and serializer schemas
+
+In v4, the type providers had the same types for both validation and serialization.
+In v5, the type providers have been split into two separate types: `ValidatorSchema`
+and `SerializerSchema`.
+
+[`@fastify/type-provider-json-schema-to-ts`](https://github.com/fastify/fastify-type-provider-json-schema-to-ts)
+and
+[`@fastify/type-provider-typebox`](https://github.com/fastify/fastify-type-provider-typebox)
+have already been updated: upgrade to the latest version to get the new types.
+If you are using a custom type provider, you will need to modify it like
+the following:
+
+```
+--- a/index.ts
++++ b/index.ts
+@@ -11,7 +11,8 @@ import {
+ import { FromSchema, FromSchemaDefaultOptions, FromSchemaOptions, JSONSchema } from 'json-schema-to-ts'
+ 
+ export interface JsonSchemaToTsProvider<
+   Options extends FromSchemaOptions = FromSchemaDefaultOptions
+ > extends FastifyTypeProvider {
+-  output: this['input'] extends JSONSchema ? FromSchema<this['input'], Options> : unknown;
++  validator: this['schema'] extends JSONSchema ? FromSchema<this['schema'], Options> : unknown;
++  serializer: this['schema'] extends JSONSchema ? FromSchema<this['schema'], Options> : unknown;
+ }
+ ```
+
+### Changes to the .listen() method
+
+The variadic argument signature of the `.listen()` method has been removed.
+This means that you can no longer call `.listen()` with a variable number of arguments.
+
+```js
+// v4
+fastify.listen(8000)
+```
+
+Will become:
+
+```js
+// v5
+fastify.listen({ port: 8000 })
+```
+
+This was already deprecated in v4 as `FSTDEP011`, so you should have already updated
+your code to use the new signature.
+
+### Direct return of trailers has been removed
+
+In v4, you could directly return trailers from a handler.
+This is no longer possible in v5.
+
+```js
+// v4
+fastify.get('/route', (req, reply) => {
+  reply.trailer('ETag', function (reply, payload) {
+    return 'custom-etag'
+  })
+  reply.send('')
+});
+```
+
+```js
+// v5
+fastify.get('/route', (req, reply) => {
+  reply.trailer('ETag', async function (reply, payload) {
+    return 'custom-etag'
+  })
+  reply.send('')
+});
+```
+
+A callback could also be used.
+This was already deprecated in v4 as `FSTDEP013`,
+so you should have already updated your code to use the new signature.
+
+### Streamlined access to route definition
+
+All deprecated properties relating to accessing the route definition have been removed
+and are now accessed via `request.routeOptions`.
+
+| Code | Description | How to solve | Discussion |
+| ---- | ----------- | ------------ | ---------- |
+| FSTDEP012 | You are trying to access the deprecated `request.context` property. | Use `request.routeOptions.config` or `request.routeOptions.schema`. | [#4216](https://github.com/fastify/fastify/pull/4216) [#5084](https://github.com/fastify/fastify/pull/5084) |
+| FSTDEP015 | You are accessing the deprecated `request.routeSchema` property. | Use `request.routeOptions.schema`. | [#4470](https://github.com/fastify/fastify/pull/4470) |
+| FSTDEP016 | You are accessing the deprecated `request.routeConfig` property. | Use `request.routeOptions.config`. | [#4470](https://github.com/fastify/fastify/pull/4470) |
+| FSTDEP017 | You are accessing the deprecated `request.routerPath` property. | Use `request.routeOptions.url`. | [#4470](https://github.com/fastify/fastify/pull/4470) |
+| FSTDEP018 | You are accessing the deprecated `request.routerMethod` property. | Use `request.routeOptions.method`. | [#4470](https://github.com/fastify/fastify/pull/4470) |
+| FSTDEP019 | You are accessing the deprecated `reply.context` property. | Use `reply.routeOptions.config` or `reply.routeOptions.schema`. | [#5032](https://github.com/fastify/fastify/pull/5032) [#5084](https://github.com/fastify/fastify/pull/5084) |
+
+See [#5616](https://github.com/fastify/fastify/pull/5616) for more information.
+
+### `reply.redirect()` has a new signature
+
+The `reply.redirect()` method has a new signature:
+`reply.redirect(url: string, code?: number)`.
+
+```js
+// v4
+reply.redirect(301, '/new-route')
+```
+
+Change it to:
+
+```js
+// v5
+reply.redirect('/new-route', 301)
+```
+
+This was already deprecated in v4 as `FSTDEP021`, so you should have already
+updated your code to use the new signature.
+
+
+### Modifying `reply.sent` is now forbidden
+
+In v4, you could modify the `reply.sent` property to prevent the response from
+being sent.
+This is no longer possible in v5, use `reply.hijack()` instead.
+
+```js
+// v4
+fastify.get('/route', (req, reply) => {
+  reply.sent = true;
+  reply.raw.end('hello');
+});
+```
+
+Change it to:
+
+```js
+// v5
+fastify.get('/route', (req, reply) => {
+  reply.hijack();
+  reply.raw.end('hello');
+});
+```
+
+This was already deprecated in v4 as `FSTDEP010`, so you should have already
+updated your code to use the new signature.
+
+### Constraints for route versioning signature changes
+
+We changed the signature for route versioning constraints.
+The `version` and `versioning` options have been removed and you should
+use the `constraints` option instead.
+
+| Code | Description | How to solve | Discussion |
+| ---- | ----------- | ------------ | ---------- |
+| FSTDEP008 | You are using route constraints via the route `{version: "..."}` option.  |  Use `{constraints: {version: "..."}}` option.  | [#2682](https://github.com/fastify/fastify/pull/2682) |
+| FSTDEP009 | You are using a custom route versioning strategy via the server `{versioning: "..."}` option. |  Use `{constraints: {version: "..."}}` option.  | [#2682](https://github.com/fastify/fastify/pull/2682) |
+
+### `HEAD` routes requires to register before `GET` when `exposeHeadRoutes: true`
+
+We have a more strict requirement for custom `HEAD` route when
+`exposeHeadRoutes: true`.
+
+When you provides a custom `HEAD` route, you must either explicitly 
+set `exposeHeadRoutes` to `false`
+
+```js
+// v4
+fastify.get('/route', {
+
+}, (req, reply) => {
+  reply.send({ hello: 'world' });
+});
+
+fastify.head('/route', (req, reply) => {
+  // ...
+});
+```
+
+```js
+// v5
+fastify.get('/route', {
+  exposeHeadRoutes: false
+}, (req, reply) => {
+  reply.send({ hello: 'world' });
+});
+
+fastify.head('/route', (req, reply) => {
+  // ...
+});
+```
+
+or place the `HEAD` route before `GET`.
+
+```js
+// v5
+fastify.head('/route', (req, reply) => {
+  // ...
+});
+
+fastify.get('/route', {
+
+}, (req, reply) => {
+  reply.send({ hello: 'world' });
+});
+```
+
+This was changed in [#2700](https://github.com/fastify/fastify/pull/2700),
+and the old behavior was deprecated in v4 as `FSTDEP007`.
+
+### Removed `request.connection`
+
+The `request.connection` property has been removed in v5.
+You should use `request.socket` instead.
+
+```js
+// v4
+fastify.get('/route', (req, reply) => {
+  console.log(req.connection.remoteAddress);
+  return { hello: 'world' };
+});
+```
+
+```js
+// v5
+fastify.get('/route', (req, reply) => {
+  console.log(req.socket.remoteAddress);
+  return { hello: 'world' };
+});
+```
+
+This was already deprecated in v4 as `FSTDEP05`, so you should
+have already updated your code to use the new signature.
+
+### `reply.getResponseTime()` has been removed, use `reply.elapsedTime` instead
+
+The `reply.getResponseTime()` method has been removed in v5.
+You should use `reply.elapsedTime` instead.
+
+```js
+// v4
+fastify.get('/route', (req, reply) => {
+  console.log(reply.getResponseTime());
+  return { hello: 'world' };
+});
+```
+
+```js
+// v5
+fastify.get('/route', (req, reply) => {
+  console.log(reply.elapsedTime);
+  return { hello: 'world' };
+});
+```
+
+This was already deprecated in v4 as `FSTDEP20`, so you should have already
+updated your code to use the new signature.
+
+### `fastify.hasRoute()` now matches the behavior of `find-my-way`
+
+The `fastify.hasRoute()` method now matches the behavior of `find-my-way`
+and requires the route definition to be passed as it is defined in the route.
+
+```js
+// v4
+fastify.get('/example/:file(^\\d+).png', function (request, reply) { })
+
+console.log(fastify.hasRoute({
+  method: 'GET', 
+  url: '/example/12345.png'
+)); // true
+```
+
+```js
+// v5
+
+fastify.get('/example/:file(^\\d+).png', function (request, reply) { })
+
+console.log(fastify.hasRoute({
+  method: 'GET', 
+  url: '/example/:file(^\\d+).png'
+)); // true
+```
+
+### Removal of some non-standard HTTP methods
+
+We have removed the following HTTP methods from Fastify:
+- `PROPFIND`
+- `PROPPATCH`
+- `MKCOL`
+- `COPY`
+- `MOVE`
+- `LOCK`
+- `UNLOCK`
+- `TRACE`
+- `SEARCH`
+
+It's now possible to add them back using the `acceptHTTPMethod` method.
+
+```js
+const fastify = Fastify()
+
+// add a new http method on top of the default ones:
+fastify.acceptHTTPMethod('REBIND')
+
+// add a new HTTP method that accepts a body:
+fastify.acceptHTTPMethod('REBIND', { hasBody: true })
+
+// reads the HTTP methods list:
+fastify.supportedMethods // returns a string array
+```
+
+See [#5567](https://github.com/fastify/fastify/pull/5567) for more
+information.
+
+### Removed support from reference types in decorators
+
+Decorating Request/Reply with a reference type (`Array`, `Object`)
+is now prohibited as this reference is shared amongst all requests.
+
+```js
+// v4
+fastify.decorateRequest('myObject', { hello: 'world' });
+```
+
+```js
+// v5
+fastify.decorateRequest('myObject');
+fastify.addHook('onRequest', async (req, reply) => {
+  req.myObject = { hello: 'world' };
+});
+```
+
+or turn it into a function
+
+```js
+// v5
+fastify.decorateRequest('myObject', () => { hello: 'world' });
+```
+
+or as a getter
+
+```js
+// v5
+fastify.decorateRequest('myObject', {
+  getter () { 
+    return { hello: 'world' }
+  }
+});
+```
+
+See [#5462](https://github.com/fastify/fastify/pull/5462) for more information.
+
+### Remove support for DELETE with a `Content-Type: application/json` header and an empty body
+
+In v4, Fastify allowed `DELETE` requests with a `Content-Type: application/json`
+header and an empty body was accepted.
+This is no longer allowed in v5.
+
+See [#5419](https://github.com/fastify/fastify/pull/5419) for more information.
+
+### Plugins cannot mix callback/promise API anymore
+
+In v4, plugins could mix the callback and promise API, leading to unexpected behavior.
+This is no longer allowed in v5.
+
+```js
+// v4
+fastify.register(async function (instance, opts, done) {
+  done();
+});
+```
+
+```js
+// v5
+fastify.register(async function (instance, opts) {
+  return;
+});
+```
+
+or
+
+```js
+// v5
+fastify.register(function (instance, opts, done) {
+  done();
+});
+```
+
+### Removes `getDefaultRoute` and `setDefaultRoute` methods
+
+The `getDefaultRoute` and `setDefaultRoute` methods have been removed in v5.
+
+See [#4485](https://github.com/fastify/fastify/pull/4485)
+and [#4480](https://github.com/fastify/fastify/pull/4485)
+for more information.
+This was already deprecated in v4 as `FSTDEP014`,
+so you should have already updated your code.
+
+## New Features
+
+### Diagnostic Channel support
+
+Fastify v5 now supports the [Diagnostic Channel](https://nodejs.org/api/diagnostic_channel.html)
+API natively
+and provides a way to trace the lifecycle of a request.
+
+```js
+'use strict'
+
+const diagnostics = require('node:diagnostics_channel')
+const sget = require('simple-get').concat
+const Fastify = require('fastify')
+
+diagnostics.subscribe('tracing:fastify.request.handler:start', (msg) => {
+  console.log(msg.route.url) // '/:id'
+  console.log(msg.route.method) // 'GET'
+})
+
+diagnostics.subscribe('tracing:fastify.request.handler:end', (msg) => {
+  // msg is the same as the one emitted by the 'tracing:fastify.request.handler:start' channel
+  console.log(msg)
+})
+
+diagnostics.subscribe('tracing:fastify.request.handler:error', (msg) => {
+  // in case of error
+})
+
+const fastify = Fastify()
+fastify.route({
+  method: 'GET',
+  url: '/:id',
+  handler: function (req, reply) {
+    return { hello: 'world' }
+  }
+})
+
+fastify.listen({ port: 0 }, function () {
+  sget({
+    method: 'GET',
+    url: fastify.listeningOrigin + '/7'
+  }, (err, response, body) => {
+    t.error(err)
+    t.equal(response.statusCode, 200)
+    t.same(JSON.parse(body), { hello: 'world' })
+  })
+})
+```
+
+See the [documentation](https://github.com/fastify/fastify/blob/main/docs/Reference/Hooks.md#diagnostics-channel-hooks)
+and [#5252](https://github.com/fastify/fastify/pull/5252) for additional details.

package/docs/Reference/LTS.md

@@ -57,7 +57,8 @@ A "month" is defined as 30 consecutive days.
 | 1.0.0   | 2018-03-06   | 2019-09-01      | 6, 8, 9, 10, 11    |                |
 | 2.0.0   | 2019-02-25   | 2021-01-31      | 6, 8, 10, 12, 14   |                |
 | 3.0.0   | 2020-07-07   | 2023-06-30      | 10, 12, 14, 16, 18 | v5(18)         |
-| 4.0.0   | 2022-06-08   | TBD             | 14, 16, 18, 20     | v5(18), v5(20) |
+| 4.0.0   | 2022-06-08   | 2025-06-30      | 14, 16, 18, 20, 22 | v5(18), v5(20) |
+| 5.0.0   | 2024-09-17   | TBD             | 20, 22             | v5(20)         |
 
 ### CI tested operating systems
 
@@ -71,10 +72,10 @@ YAML workflow labels below:
 
 | OS      | YAML Workflow Label | Package Manager | Node.js     | Nsolid(Node)  |
 | ------- | ------------------- | --------------- | ----------- | ------------- |
-| Linux   | `ubuntu-latest`   | npm             | 14,16,18,20 | v5(18),v5(20) |
-| Linux   | `ubuntu-latest`   | yarn,pnpm       | 14,16,18,20 | v5(18),v5(20) |
-| Windows | `windows-latest`  | npm             | 14,16,18,20 | v5(18),v5(20) |
-| MacOS   | `macos-latest`    | npm             | 14,16,18,20 | v5(18),v5(20) |
+| Linux   | `ubuntu-latest`     | npm             | 20          | v5(20)        |
+| Linux   | `ubuntu-latest`     | yarn,pnpm       | 20          | v5(20)        |
+| Windows | `windows-latest`    | npm             | 20          | v5(20)        |
+| MacOS   | `macos-latest`      | npm             | 20          | v5(20)        |
 
 Using [yarn](https://yarnpkg.com/) might require passing the `--ignore-engines`
 flag.

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '5.0.0-alpha.4'
+const VERSION = '5.0.0'
 
 const Avvio = require('avvio')
 const http = require('node:http')
@@ -673,7 +673,7 @@ function fastify (options) {
     }
 
     if (name === 'onClose') {
-      this.onClose(fn)
+      this.onClose(fn.bind(this))
     } else if (name === 'onReady' || name === 'onListen' || name === 'onRoute') {
       this[kHooks].add(name, fn)
     } else {

package/lib/warnings.js

@@ -6,6 +6,8 @@ const { createWarning } = require('process-warning')
  * Deprecation codes:
  *   - FSTWRN001
  *   - FSTSEC001
+ *
+ * Deprecation Codes FSTDEP001 - FSTDEP021 were used by v4 and MUST NOT not be reused.
  */
 
 const FSTWRN001 = createWarning({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fastify",
-  "version": "5.0.0-alpha.4",
+  "version": "5.0.0",
   "description": "Fast and low overhead web framework, for Node.js",
   "main": "fastify.js",
   "type": "commonjs",
@@ -192,7 +192,7 @@
   "dependencies": {
     "@fastify/ajv-compiler": "^4.0.0",
     "@fastify/error": "^4.0.0",
-    "@fastify/fast-json-stringify-compiler": "^4.3.0",
+    "@fastify/fast-json-stringify-compiler": "^5.0.0",
     "abstract-logging": "^2.0.1",
     "avvio": "^9.0.0",
     "fast-json-stringify": "^6.0.0",

package/test/close.test.js

@@ -9,11 +9,14 @@ const split = require('split2')
 const { sleep } = require('./helper')
 
 test('close callback', t => {
-  t.plan(4)
+  t.plan(7)
   const fastify = Fastify()
   fastify.addHook('onClose', onClose)
   function onClose (instance, done) {
+    t.type(fastify, this)
     t.type(fastify, instance)
+    t.equal(fastify, this)
+    t.equal(fastify, instance)
     done()
   }
 

package/test/hooks.test.js

@@ -3072,13 +3072,14 @@ test('preSerialization hooks should support encapsulation', t => {
 })
 
 test('onRegister hook should be called / 1', t => {
-  t.plan(3)
+  t.plan(4)
   const fastify = Fastify()
 
-  fastify.addHook('onRegister', (instance, opts) => {
+  fastify.addHook('onRegister', (instance, opts, done) => {
     // duck typing for the win!
     t.ok(instance.addHook)
     t.same(opts, pluginOpts)
+    t.notOk(done)
   })
 
   const pluginOpts = { prefix: 'hello', custom: 'world' }

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

@@ -131,12 +131,9 @@ server.addHook('onRoute', function (opts) {
   expectType<RouteOptions & { routePath: string; path: string; prefix: string }>(opts)
 })
 
-server.addHook('onRegister', (instance, opts, done) => {
+server.addHook('onRegister', (instance, opts) => {
   expectType<FastifyInstance>(instance)
   expectType<RegisterOptions & FastifyPluginOptions>(opts)
-  expectAssignable<(err?: FastifyError) => void>(done)
-  expectAssignable<(err?: NodeJS.ErrnoException) => void>(done)
-  expectType<void>(done(new Error()))
 })
 
 server.addHook('onReady', function (done) {
@@ -152,7 +149,8 @@ server.addHook('onListen', function (done) {
   expectAssignable<(err?: NodeJS.ErrnoException) => void>(done)
 })
 
-server.addHook('onClose', (instance, done) => {
+server.addHook('onClose', function (instance, done) {
+  expectType<FastifyInstance>(this)
   expectType<FastifyInstance>(instance)
   expectAssignable<(err?: FastifyError) => void>(done)
   expectAssignable<(err?: NodeJS.ErrnoException) => void>(done)
@@ -237,7 +235,8 @@ server.addHook('onListen', async function () {
   expectType<FastifyInstance>(this)
 })
 
-server.addHook('onClose', async (instance) => {
+server.addHook('onClose', async function (instance) {
+  expectType<FastifyInstance>(this)
   expectType<FastifyInstance>(instance)
 })
 

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

@@ -370,11 +370,12 @@ expectError(server.decorate<string>('test', true))
 expectError(server.decorate<(myNumber: number) => number>('test', function (myNumber: number): string {
   return ''
 }))
-expectError(server.decorate<string>('test', {
-  getter () {
-    return true
-  }
-}))
+// TODO(mcollina): uncomment after https://github.com/tsdjs/tsd/pull/220 lands.
+// expectError(server.decorate<string>('test', {
+//   getter () {
+//     return true
+//   }
+// }))
 expectError(server.decorate<string>('test', {
   setter (x) {}
 }))
@@ -418,11 +419,12 @@ server.decorate('typedTestProperty')
 server.decorate('typedTestProperty', null, ['foo'])
 expectError(server.decorate('typedTestProperty', null))
 expectError(server.decorate('typedTestProperty', 'foo'))
-expectError(server.decorate('typedTestProperty', {
-  getter () {
-    return 'foo'
-  }
-}))
+// TODO(mcollina): uncomment after https://github.com/tsdjs/tsd/pull/220 lands.
+// expectError(server.decorate('typedTestProperty', {
+//  getter () {
+//    return 'foo'
+//  }
+// }))
 server.decorate('typedTestMethod', function (x) {
   expectType<string>(x)
   expectType<FastifyInstance>(this)

package/types/hooks.d.ts

@@ -711,9 +711,8 @@ export interface onRegisterHookHandler<
 > {
   (
     instance: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
-    opts: RegisterOptions & Options,
-    done: HookHandlerDoneFunction
-  ): Promise<unknown> | void; // documentation is missing the `done` method
+    opts: RegisterOptions & Options
+  ): Promise<unknown> | void;
 }
 
 /**
@@ -782,6 +781,7 @@ export interface onCloseHookHandler<
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > {
   (
+    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
     instance: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
     done: HookHandlerDoneFunction
   ): void;
@@ -795,6 +795,7 @@ export interface onCloseAsyncHookHandler<
   TypeProvider extends FastifyTypeProvider = FastifyTypeProviderDefault
 > {
   (
+    this: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>,
     instance: FastifyInstance<RawServer, RawRequest, RawReply, Logger, TypeProvider>
   ): Promise<unknown>;
 }