fastify 4.0.2 → 4.2.0

package/.eslintrc

@@ -1,3 +1,4 @@
 {
+  "root": true,
   "extends": "standard"
 }

package/README.md

@@ -56,7 +56,7 @@ 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.
 
-This branch refers to the upcoming Fastify v4 release. Check out the
+This branch refers to the Fastify v4 release. Check out the
 [v3.x](https://github.com/fastify/fastify/tree/v3.x) branch for v3.
 
 ### Quick start
@@ -104,11 +104,11 @@ project as a dependency:
 
 Install with npm:
 ```sh
-npm i fastify@next
+npm i fastify
 ```
 Install with yarn:
 ```sh
-yarn add fastify@next
+yarn add fastify
 ```
 
 ### Example

package/docs/Guides/Database.md

@@ -37,7 +37,7 @@ fastify.get('/user/:id', function(req, reply) {
   )
 })
 
-fastify.listen(3000, err => {
+fastify.listen({ port: 3000 }, err => {
   if (err) throw err
   console.log(`server listening on ${fastify.server.address().port}`)
 })
@@ -64,7 +64,7 @@ fastify.get('/user/:id', function (req, reply) {
   )
 })
 
-fastify.listen(3000, err => {
+fastify.listen({ port: 3000 }, err => {
   if (err) throw err
   console.log(`server listening on ${fastify.server.address().port}`)
 })
@@ -98,7 +98,7 @@ fastify.post('/foo', function (req, reply) {
   })
 })
 
-fastify.listen(3000, err => {
+fastify.listen({ port: 3000 }, err => {
   if (err) throw err
   console.log(`server listening on ${fastify.server.address().port}`)
 })
@@ -145,7 +145,7 @@ fastify.get('/user/:id', function (req, reply) {
   })
 })
 
-fastify.listen(3000, err => {
+fastify.listen({ port: 3000 }, err => {
   if (err) throw err
 })
 ```
@@ -172,7 +172,7 @@ fastify.post('/foo', async function (req, reply) {
   return { status: 'ok' }
 })
 
-fastify.listen(3000, err => {
+fastify.listen({ port: 3000 }, err => {
   if (err) throw err
   console.log(`server listening on ${fastify.server.address().port}`)
 })

package/docs/Guides/Delay-Accepting-Requests.md

@@ -48,7 +48,7 @@ server (fewer resources allocated to a bound-to-fail task) and for the client
 That will be achieved by wrapping into a custom plugin two main features:
 
 1. the mechanism for authenticating with the provider
-[decorating](../Referece/Decorators.md) the `fastify` object with the
+[decorating](../Reference/Decorators.md) the `fastify` object with the
 authentication key (`magicKey` from here onwards)
 1. the mechanism for denying requests that would, otherwise, fail
 

package/docs/Guides/Ecosystem.md

@@ -132,9 +132,15 @@ section.
   sampling process metrics.
 - [`@dnlup/fastify-traps`](https://github.com/dnlup/fastify-traps) A plugin to
   close the server gracefully on `SIGINT` and `SIGTERM` signals.
+- [`@eropple/fastify-openapi3`](https://github.com/eropple/fastify-openapi3) Provides
+  easy, developer-friendly OpenAPI 3.1 specs + doc explorer based on your routes.
 - [`@gquittet/graceful-server`](https://github.com/gquittet/graceful-server)
   Tiny (~5k), Fast, KISS, and dependency-free Node.JS library to make your
   Fastify API graceful.
+- [`@h4ad/serverless-adapter`](https://github.com/H4ad/serverless-adapter)
+  Run REST APIs and other web applications using your existing Node.js 
+  application framework (Express, Koa, Hapi and Fastify), on top of AWS Lambda, 
+  Huawei and many other clouds.
 - [`@immobiliarelabs/fastify-metrics`](https://github.com/immobiliare/fastify-metrics)
   Minimalistic and opinionated plugin that collects usage/process metrics and
   dispatches to [statsd](https://github.com/statsd/statsd).
@@ -327,6 +333,8 @@ section.
   Kubernetes client plugin.
 - [`fastify-language-parser`](https://github.com/lependu/fastify-language-parser)
   Fastify plugin to parse request language.
+- [`fastify-lcache`](https://github.com/denbon05/fastify-lcache)
+  Lightweight cache plugin
 - [`fastify-loader`](https://github.com/TheNoim/fastify-loader) Load routes from
   a directory and inject the Fastify instance in each file.
 - [`fastify-lured`](https://github.com/lependu/fastify-lured) Plugin to load lua
@@ -346,6 +354,9 @@ section.
   minification and transformation of responses.
 - [`fastify-mongo-memory`](https://github.com/chapuletta/fastify-mongo-memory)
   Fastify MongoDB in Memory Plugin for testing support.
+- [`fastify-mongodb-sanitizer`](https://github.com/KlemenKozelj/fastify-mongodb-sanitizer)
+  Fastify plugin that sanitizes client input to prevent
+  potential MongoDB query injection attacks.
 - [`fastify-mongoose-api`](https://github.com/jeka-kiselyov/fastify-mongoose-api)
   Fastify plugin to create REST API methods based on Mongoose MongoDB models.
 - [`fastify-mongoose-driver`](https://github.com/alex-ppg/fastify-mongoose)
@@ -475,6 +486,8 @@ section.
   Events with `reply.sse( … )` to Fastify.
 - [`fastify-sse-v2`](https://github.com/nodefactoryio/fastify-sse-v2) to provide
   Server-Sent Events using Async Iterators (supports newer versions of Fastify).
+- [`fastify-ssr-vite`](https://github.com/nineohnine/fastify-ssr-vite) A simple
+  plugin for setting up server side rendering with vite.
 - [`fastify-stripe`](https://github.com/coopflow/fastify-stripe) Plugin to
   initialize and encapsulate [Stripe
   Node.js](https://github.com/stripe/stripe-node) instances in Fastify.

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

@@ -8,7 +8,39 @@ work after upgrading.
 
 ## Breaking Changes
 
-### Deprecation of `app.use()`
+### Error handling composition ([#3261](https://github.com/fastify/fastify/pull/3261))
+
+When an error is thrown in a async error handler function, 
+the upper-level error handler is executed if set.
+If there is not a upper-level error handler, the default will 
+be executed as it was previously.
+
+```
+import Fastify from 'fastify'
+
+const fastify = Fastify()
+
+fastify.register(async fastify => {
+  fastify.setErrorHandler(async err => {
+    console.log(err.message) // 'kaboom'
+    throw new Error('caught')
+  })
+  
+  fastify.get('/encapsulated', async () => {
+    throw new Error('kaboom')
+  })
+})
+
+fastify.setErrorHandler(async err => {
+  console.log(err.message) // 'caught' 
+  throw new Error('wrapped')
+})
+
+const res = await fastify.inject('/encapsulated')
+console.log(res.json().message) // 'wrapped'
+```
+
+### Deprecation of `app.use()` ([#3506](https://github.com/fastify/fastify/pull/3506))
 
 Starting this version of Fastify, we have deprecated the use of `app.use()`. We
 have decided not to support the use of middlewares. Both
@@ -16,12 +48,29 @@ have decided not to support the use of middlewares. Both
 [`@fastify/express`](https://github.com/fastify/fastify-express) will still be
 there and maintained. Use Fastify's [hooks](../Reference/Hooks.md) instead.
 
+### `reply.res` moved to `reply.raw`
+
+If you previously used the `reply.res` attribute to access the underlying Request
+object you'll instead need to depend on `reply.raw`.
+
+### Need to `return reply` to signal a "fork" of the promise chain
+
+In some situations, like when a response is sent asynchronously or when you're
+just not explicitly returning a response, you'll need to return the `reply`
+argument from your router handler.
+
+### `exposeHeadRoutes` true by default
+
+Starting from v4, all the `GET` routes will create a sibling `HEAD` route.
+You can revert this behaviour by setting the server's option `exposeHeadRoutes`
+to `false`.
+
 ## Non Breaking Changes
 
 ### Change of schema for multiple types
 
 
-Since Fastiy v4 has upgraded to Ajv v8. The "type" keywords with multiple types
+Since Fastify v4 has upgraded to Ajv v8. The "type" keywords with multiple types
 (other than with "null") are prohibited. Read more
 ['here'](https://ajv.js.org/strict-mode.html#strict-types)
 
@@ -53,3 +102,10 @@ properties: {
   }
 }
 ```
+
+### Add `reply.trailers` methods ([#3794](https://github.com/fastify/fastify/pull/3794))
+
+Fastify now supports the [HTTP Trailer] response headers.
+
+
+[HTTP Trailer]: https://developer.mozilla.org/en-US/docs/Web/HTTP/Headers/Trailer

package/docs/Guides/Serverless.md

@@ -24,23 +24,31 @@ snippet of code.
 
 ### Contents
 
-- [AWS Lambda](#aws-lambda)
+- [AWS](#aws)
 - [Google Cloud Functions](#google-cloud-functions)
 - [Google Cloud Run](#google-cloud-run)
 - [Netlify Lambda](#netlify-lambda)
 - [Vercel](#vercel)
 
-## AWS Lambda
+## AWS
+
+To integrate with AWS, you have two choices of library:
+
+- Using [@fastify/aws-lambda](https://github.com/fastify/aws-lambda-fastify) 
+  which only adds API Gateway support but has heavy optimizations for fastify.
+- Using [@h4ad/serverless-adapter](https://github.com/H4ad/serverless-adapter) 
+  which is a little slower as it creates an HTTP request for each AWS event but 
+  has support for more AWS services such as: AWS SQS, AWS SNS and others.
+
+So you can decide which option is best for you, but you can test both libraries.
+
+### Using @fastify/aws-lambda
 
 The sample provided allows you to easily build serverless web
 applications/services and RESTful APIs using Fastify on top of AWS Lambda and
 Amazon API Gateway.
 
-*Note: Using
-[@fastify/aws-lambda](https://github.com/fastify/aws-lambda-fastify) is just one
-possible way.*
-
-### app.js
+#### app.js
 
 ```js
 const fastify = require('fastify');
@@ -71,7 +79,7 @@ When you execute your Fastify application like always, i.e. `node app.js` *(the
 detection for this could be `require.main === module`)*, you can normally listen
 to your port, so you can still run your Fastify function locally.
 
-### lambda.js
+#### lambda.js
 
 ```js
 const awsLambdaFastify = require('@fastify/aws-lambda')
@@ -99,14 +107,13 @@ signature to be used as a lambda `handler` function. This way all the incoming
 events (API Gateway requests) are passed to the `proxy` function of
 [@fastify/aws-lambda](https://github.com/fastify/aws-lambda-fastify).
 
-### Example
+#### Example
 
 An example deployable with
 [claudia.js](https://claudiajs.com/tutorials/serverless-express.html) can be
 found
 [here](https://github.com/claudiajs/example-projects/tree/master/fastify-app-lambda).
 
-
 ### Considerations
 
 - API Gateway does not support streams yet, so you are not able to handle
@@ -114,6 +121,12 @@ found
 - API Gateway has a timeout of 29 seconds, so it is important to provide a reply
   during this time.
 
+#### Beyond API Gateway
+
+If you need to integrate with more AWS services, take a look at
+[@h4ad/serverless-adapter](https://viniciusl.com.br/serverless-adapter/docs/main/frameworks/fastify)
+on Fastify to find out how to integrate.
+
 ## Google Cloud Functions
 
 ### Creation of Fastify instance

package/docs/Reference/Hooks.md

@@ -28,6 +28,7 @@ are Request/Reply hooks and application hooks:
   - [onRegister](#onregister)
 - [Scope](#scope)
 - [Route level hooks](#route-level-hooks)
+- [Using Hooks to Inject Custom Properties](#using-hooks-to-inject-custom-properties)
 - [Diagnostics Channel Hooks](#diagnostics-channel-hooks)
 
 **Notice:** the `done` callback is not available when using `async`/`await` or
@@ -649,6 +650,57 @@ fastify.route({
 
 **Note**: both options also accept an array of functions.
 
+## Using Hooks to Inject Custom Properties
+<a id="using-hooks-to-inject-custom-properties"></a>
+
+You can use a hook to inject custom properties into incoming requests.
+This is useful for reusing processed data from hooks in controllers.
+
+A very common use case is, for example, checking user authentication based
+on their token and then storing their recovered data into
+the [Request](./Request.md) instance. This way, your controllers can read it
+easily with `request.authenticatedUser` or whatever you want to call it.
+That's how it might look like:
+
+```js
+fastify.addHook('preParsing', async (request) => {
+  request.authenticatedUser = {
+    id: 42,
+    name: 'Jane Doe',
+    role: 'admin'
+  }
+})
+
+fastify.get('/me/is-admin', async function (req, reply) {
+  return { isAdmin: req.authenticatedUser?.role === 'admin' || false }
+})
+```
+
+Note that `.authenticatedUser` could actually be any property name
+choosen by yourself. Using your own custom property prevents you
+from mutating existing properties, which
+would be a dangerous and destructive operation. So be careful and
+make sure your property is entirely new, also using this approach
+only for very specific and small cases like this example.
+
+Regarding TypeScript in this example, you'd need to update the
+`FastifyRequest` core interface to include your new property typing
+(for more about it, see [TypeScript](./TypeScript.md) page), like:
+
+```ts
+interface AuthenticatedUser { /* ... */ }
+
+declare module 'fastify' {
+  export interface FastifyRequest {
+    authenticatedUser?: AuthenticatedUser;
+  }
+}
+```
+
+Although this is a very pragmatic approach, if you're trying to do
+something more complex that changes these core objects, then
+consider creating a custom [Plugin](./Plugins.md) instead.
+
 ## Diagnostics Channel Hooks
 
 > **Note:** The `diagnostics_channel` is currently experimental on Node.js, so

package/docs/Reference/LTS.md

@@ -47,8 +47,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   | TBD             | 10, 12, 14, 16, 18   |
-| 4.0.0   | TBD          | TBD             | 14, 16, 18           |
+| 3.0.0   | 2020-07-07   | 2023-06-30      | 10, 12, 14, 16, 18   |
+| 4.0.0   | 2022-06-08   | TBD             | 14, 16, 18           |
 
 ### CI tested operating systems
 <a id="supported-os"></a>

package/docs/Reference/Plugins.md

@@ -13,7 +13,7 @@ way we create a *directed acyclic graph* (DAG) and we will not have issues
 caused by cross dependencies.
 
 You may have already seen in the [Getting
-Started]((../Guides/Getting-Started.md#your-first-plugin)) guide how easy it is
+Started](../Guides/Getting-Started.md#your-first-plugin) guide how easy it is
 to use this API:
 ```
 fastify.register(plugin, [options])

package/docs/Reference/Server.md

@@ -1278,7 +1278,7 @@ const fastify = Fastify({
      */
     bucket: function factory (parentSchemas) {
       return {
-        addSchema (inputSchema) {
+        add (inputSchema) {
           // This function must store the schema added by the user.
           // This function is invoked when `fastify.addSchema()` is called.
         },

package/docs/Reference/Type-Providers.md

@@ -30,11 +30,11 @@ $ npm i @fastify/type-provider-json-schema-to-ts
 ```
 
 ```typescript
-import { JsonSchemaToTsTypeProvider } from '@fastify/type-provider-json-schema-to-ts'
+import { JsonSchemaToTsProvider } from '@fastify/type-provider-json-schema-to-ts'
 
 import fastify from 'fastify'
 
-const server = fastify().withTypeProvider<JsonSchemaToTsTypeProvider>()
+const server = fastify().withTypeProvider<JsonSchemaToTsProvider>()
 
 server.get('/route', {
     schema: {
@@ -65,7 +65,8 @@ $ npm i @fastify/type-provider-typebox
 ```
 
 ```typescript
-import { TypeBoxTypeProvider, Type } from '@fastify/type-provider-typebox'
+import { TypeBoxTypeProvider } from '@fastify/type-provider-typebox'
+import { Type } from '@sinclair/typebox'
 
 import fastify from 'fastify'
 

package/docs/Reference/TypeScript.md

@@ -199,17 +199,18 @@ Below is how to setup schema validation using vanilla `typebox` and
 #### typebox
 
 A useful library for building types and a schema at once is
-[typebox](https://www.npmjs.com/package/@sinclair/typebox). With typebox you
-define your schema within your code and use them directly as types or schemas as
-you need them.
+[typebox](https://www.npmjs.com/package/@sinclair/typebox) along with 
+[fastify-type-provider-typebox](https://github.com/fastify/fastify-type-provider-typebox).
+With typebox you define your schema within your code and use them
+directly as types or schemas as you need them.
 
 When you want to use it for validation of some payload in a fastify route you
 can do it as follows:
 
-1. Install `typebox` in your project.
+1. Install `typebox` and `fastify-type-provider-typebox` in your project.
 
     ```bash
-    npm i @sinclair/typebox
+    npm i @sinclair/typebox @fastify/type-provider-typebox
     ```
 
 2. Define the schema you need with `Type` and create the respective type  with
@@ -218,40 +219,52 @@ can do it as follows:
     ```typescript
     import { Static, Type } from '@sinclair/typebox'
 
-    const User = Type.Object({
+    export const User = Type.Object({
       name: Type.String(),
-      mail: Type.Optional(Type.String({ format: "email" })),
-    });
-    type UserType = Static<typeof User>;
+      mail: Type.Optional(Type.String({ format: 'email' })),
+    })
+
+    export type UserType = Static<typeof User>
     ```
 
 3. Use the defined type and schema during the definition of your route
 
     ```typescript
-    const app = fastify();
+    import Fastify from 'fastify'
+    import { TypeBoxTypeProvider } from '@fastify/type-provider-typebox'
+    // ...
+
+    const fastify = Fastify().withTypeProvider<TypeBoxTypeProvider>()
 
-    app.post<{ Body: UserType; Reply: UserType }>(
-      "/",
+    app.post<{ Body: UserType, Reply: UserType }>(
+      '/',
       {
         schema: {
           body: User,
           response: {
-            200: User,
+            200: User
           },
         },
       },
       (request, reply) => {
-        const { body: user } = request;
-        /* user has type
-        * const user: StaticProperties<{
-        *  name: TString;
-        *  mail: TOptional<TString>;
-        * }>
-        */
-        //...
-        reply.status(200).send(user);
+        // The `name` and `mail` types are automatically inferred
+        const { name, mail } = request.body;
+        reply.status(200).send({ name, mail });
+      }
+    )
+    ```
+
+     **Note** For Ajv version 7 and above is required to use the `ajvTypeBoxPlugin`:
+
+    ```typescript
+    import Fastify from 'fastify'
+    import { ajvTypeBoxPlugin, TypeBoxTypeProvider } from '@fastify/type-provider-typebox'
+
+    const fastify = Fastify({
+      ajv: {
+        plugins: [ajvTypeBoxPlugin]
       }
-    );
+    }).withTypeProvider<TypeBoxTypeProvider>()
     ```
 
 #### Schemas in JSON Files
@@ -1359,7 +1372,7 @@ A method for checking the existence of a type parser of a certain content type
 
 ##### fastify.FastifyError
 
-[src](https://github.com/fastify/fastify/blob/main/types/error.d.ts#L17)
+[src](https://github.com/fastify/fastify/blob/main/fastify.d.ts#L179)
 
 FastifyError is a custom error object that includes status code and validation
 results.
@@ -1369,7 +1382,7 @@ properties: `statusCode: number` and `validation: ValiationResult[]`.
 
 ##### fastify.ValidationResult
 
-[src](https://github.com/fastify/fastify/blob/main/types/error.d.ts#L4)
+[src](https://github.com/fastify/fastify/blob/main/fastify.d.ts#L184)
 
 The route validation internally relies upon Ajv, which is a high-performance
 JSON schema validator.

package/docs/Reference/Validation-and-Serialization.md

@@ -484,6 +484,17 @@ fastify.post('/the/url', {
 }, handler)
 ```
 
+##### .statusCode property
+
+All validation errors will be added a `.statusCode` property set to `400`. This guarantees
+that the default error handler will set the status code of the response to `400`.
+
+```js
+fastify.setErrorHandler(function (error, request, reply) {
+  request.log.error(error, `This error has status code ${error.statusCode}`)
+  reply.status(error.statusCode).send(error)
+})
+```
 
 ##### Validation messages with other validation libraries
 

package/docs/index.md

@@ -16,7 +16,7 @@ Complete newcomers to Fastify should first read our [Getting
 Started](./Guides/Getting-Started.md) guide.
 
 Developers experienced with Fastify should consult the [reference
-documentation](./Reference/index.md) directly to find the topic they are seeking
+documentation](./Reference/Index.md) directly to find the topic they are seeking
 more information about.
 
 ## Additional Documentation

package/fastify.d.ts

@@ -146,7 +146,7 @@ export type FastifyServerOptions<
   },
   schemaController?: {
     bucket?: (parentSchemas?: unknown) => {
-      addSchema(schema: unknown): FastifyInstance;
+      add(schema: unknown): FastifyInstance;
       getSchema(schemaId: string): unknown;
       getSchemas(): Record<string, unknown>;
     };
@@ -183,10 +183,10 @@ declare module '@fastify/error' {
 
 export interface ValidationResult {
   keyword: string;
-  dataPath: string;
+  instancePath: string;
   schemaPath: string;
   params: Record<string, string | string[]>;
-  message: string;
+  message?: string;
 }
 
 /* Export all additional types */

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.0.2'
+const VERSION = '4.2.0'
 
 const Avvio = require('avvio')
 const http = require('http')
@@ -237,35 +237,35 @@ function fastify (options) {
     getDefaultRoute: router.getDefaultRoute.bind(router),
     setDefaultRoute: router.setDefaultRoute.bind(router),
     // routes shorthand methods
-    delete: function _delete (url, opts, handler) {
-      return router.prepareRoute.call(this, 'DELETE', url, opts, handler)
+    delete: function _delete (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'DELETE', url, options, handler })
     },
-    get: function _get (url, opts, handler) {
-      return router.prepareRoute.call(this, 'GET', url, opts, handler)
+    get: function _get (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'GET', url, options, handler })
     },
-    head: function _head (url, opts, handler) {
-      return router.prepareRoute.call(this, 'HEAD', url, opts, handler)
+    head: function _head (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'HEAD', url, options, handler })
     },
-    patch: function _patch (url, opts, handler) {
-      return router.prepareRoute.call(this, 'PATCH', url, opts, handler)
+    patch: function _patch (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'PATCH', url, options, handler })
     },
-    post: function _post (url, opts, handler) {
-      return router.prepareRoute.call(this, 'POST', url, opts, handler)
+    post: function _post (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'POST', url, options, handler })
     },
-    put: function _put (url, opts, handler) {
-      return router.prepareRoute.call(this, 'PUT', url, opts, handler)
+    put: function _put (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'PUT', url, options, handler })
     },
-    options: function _options (url, opts, handler) {
-      return router.prepareRoute.call(this, 'OPTIONS', url, opts, handler)
+    options: function _options (url, options, handler) {
+      return router.prepareRoute.call(this, { method: 'OPTIONS', url, options, handler })
     },
-    all: function _all (url, opts, handler) {
-      return router.prepareRoute.call(this, supportedMethods, url, opts, handler)
+    all: function _all (url, options, handler) {
+      return router.prepareRoute.call(this, { method: supportedMethods, url, options, handler })
     },
     // extended route
-    route: function _route (opts) {
+    route: function _route (options) {
       // we need the fastify object that we are producing so we apply a lazy loading of the function,
       // otherwise we should bind it after the declaration
-      return router.route.call(this, opts)
+      return router.route.call(this, { options })
     },
     // expose logger instance
     log: logger,

package/integration/server.js

@@ -0,0 +1,27 @@
+const Fastify = require('../fastify')
+
+const fastify = Fastify()
+
+fastify.listen({
+  host: '::',
+  port: 3000
+})
+
+fastify.get('/', async function (request, reply) {
+  reply.code(200).send({ data: 'home page' })
+})
+
+fastify.post('/post/:id', async function (request, reply) {
+  const { id } = request.params
+  reply.code(201).send({ data: `${id}` })
+})
+
+fastify.put('/put/:id', async function (request, reply) {
+  const { id } = request.params
+  reply.code(200).send({ data: `${id}` })
+})
+
+fastify.delete('/delete/:id', async function (request, reply) {
+  const { id } = request.params
+  reply.code(204).send({ data: `${id}` })
+})