fastify 4.5.3 → 4.6.0

package/docs/Guides/Ecosystem.md

@@ -75,6 +75,9 @@ section.
   connection pool across every part of your server.
 - [`@fastify/multipart`](https://github.com/fastify/fastify-multipart) Multipart
   support for Fastify.
+- [`@fastify/nextjs`](https://github.com/fastify/fastify-nextjs) React
+  server-side rendering support for Fastify with
+  [Next](https://github.com/zeit/next.js/).
 - [`@fastify/oauth2`](https://github.com/fastify/fastify-oauth2) Wrap around
   [`simple-oauth2`](https://github.com/lelylan/simple-oauth2).
 - [`@fastify/postgres`](https://github.com/fastify/fastify-postgres) Fastify
@@ -82,6 +85,11 @@ section.
   connection pool in every part of your server.
 - [`@fastify/rate-limit`](https://github.com/fastify/fastify-rate-limit) A low
   overhead rate limiter for your routes.
+- [`@fastify/redis`](https://github.com/fastify/fastify-redis) Fastify Redis
+  connection plugin, with which you can share the same Redis connection across
+  every part of your server.
+- [`@fastify/reply-from`](https://github.com/fastify/fastify-reply-from) Plugin
+  to forward the current HTTP request to another server.
 - [`@fastify/request-context`](https://github.com/fastify/fastify-request-context)
   Request-scoped storage, based on
   [AsyncLocalStorage](https://nodejs.org/api/async_hooks.html#async_hooks_class_asynclocalstorage)
@@ -89,14 +97,6 @@ section.
   providing functionality similar to thread-local storages.
 - [`@fastify/response-validation`](https://github.com/fastify/fastify-response-validation)
   A simple plugin that enables response validation for Fastify.
-- [`@fastify/nextjs`](https://github.com/fastify/fastify-nextjs) React
-  server-side rendering support for Fastify with
-  [Next](https://github.com/zeit/next.js/).
-- [`@fastify/redis`](https://github.com/fastify/fastify-redis) Fastify Redis
-  connection plugin, with which you can share the same Redis connection across
-  every part of your server.
-- [`@fastify/reply-from`](https://github.com/fastify/fastify-reply-from) Plugin
-  to forward the current HTTP request to another server.
 - [`@fastify/routes`](https://github.com/fastify/fastify-routes) Plugin that
   provides a `Map` of routes.
 - [`@fastify/schedule`](https://github.com/fastify/fastify-schedule) Plugin for
@@ -146,6 +146,13 @@ section.
   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.
+- [`@ethicdevs/fastify-custom-session`](https://github.com/EthicDevs/fastify-custom-session)
+  A plugin that let you use session and decide only where to load/save from/to. Has
+  great TypeScript support + built-in adapters for common ORMs/databases (Firebase,
+  Prisma Client, Postgres (wip), InMemory) and you can easily make your own adapter!
+- [`@ethicdevs/fastify-git-server`](https://github.com/EthicDevs/fastify-git-server)
+  A plugin to easily create git server and make one/many Git repositories available
+  for clone/fetch/push through the standard `git` (over http) commands.
 - [`@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.
@@ -216,6 +223,12 @@ section.
 - [`fastify-autoroutes`](https://github.com/GiovanniCardamone/fastify-autoroutes)
   Plugin to scan and load routes based on filesystem path from a custom
   directory.
+- [`fastify-aws-sns`](https://github.com/gzileni/fastify-aws-sns) Fastify plugin
+  for AWS Simple Notification Service (AWS SNS) that coordinates and manages
+  the delivery or sending of messages to subscribing endpoints or clients.
+- [`fastify-aws-timestream`](https://github.com/gzileni/fastify-aws-timestream)
+  Fastify plugin for managing databases, tables, and querying and creating
+  scheduled queries with AWS Timestream.
 - [`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
@@ -574,6 +587,8 @@ section.
 - [`openapi-validator-middleware`](https://github.com/PayU/openapi-validator-middleware#fastify)
   Swagger and OpenAPI 3.0 spec-based request validation middleware that supports
   Fastify.
+- [`pubsub-http-handler`](https://github.com/cobraz/pubsub-http-handler) A Fastify
+  plugin to easily create Google Cloud PubSub endpoints.
 - [`sequelize-fastify`](https://github.com/hsynlms/sequelize-fastify) A simple
   and lightweight Sequelize plugin for Fastify.
 - [`typeorm-fastify-plugin`](https://github.com/jclemens24/fastify-typeorm) A simple

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

@@ -10,12 +10,11 @@ work after upgrading.
 
 ### 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.
+When an error is thrown in an async error handler function, the upper-level
+error handler is executed if set. If there is no upper-level error handler,
+the default will be executed as it was previously:
 
-```
+```js
 import Fastify from 'fastify'
 
 const fastify = Fastify()
@@ -40,75 +39,125 @@ const res = await fastify.inject('/encapsulated')
 console.log(res.json().message) // 'wrapped'
 ```
 
-### Deprecation of `app.use()` ([#3506](https://github.com/fastify/fastify/pull/3506))
+### 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
+no longer supported.
 
-Starting this version of Fastify, we have deprecated the use of `app.use()`. We
-have decided not to support the use of middlewares. Both
-[`@fastify/middie`](https://github.com/fastify/middie) and
-[`@fastify/express`](https://github.com/fastify/fastify-express) will still be
-there and maintained. Use Fastify's [hooks](../Reference/Hooks.md) instead.
+If you need to use middleware, use
+[`@fastify/middie`](https://github.com/fastify/middie) or
+[`@fastify/express`](https://github.com/fastify/fastify-express), which will
+continue to be maintained.
+However, it is strongly recommended that you migrate to Fastify's [hooks](../Reference/Hooks.md).
 
 ### `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`.
+object you will now need to use `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`
+In some situations, like when a response is sent asynchronously or when you are
+not explicitly returning a response, you will now 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`.
+Starting with v4, every `GET` route will create a sibling `HEAD` route.
+You can revert this behavior by setting `exposeHeadRoutes: false` in the server options.
 
-### Synchronous route definitions
+### Synchronous route definitions ([#2954](https://github.com/fastify/fastify/pull/2954))
 
-The route registration has been made synchronous from v4.
-This change was done to provide better error reporting for route definition.
-As a result if you specify an `onRoute` hook in a plugin you should either:
+To improve error reporting in route definitions, route registration is now synchronous.
+As a result, if you specify an `onRoute` hook in a plugin you should now either:
 * wrap your routes in a plugin (recommended)
+
+  For example, refactor this:
+  ```js
+  fastify.register((instance, opts, done) => {
+    instance.addHook('onRoute', (routeOptions) => {
+      const { path, method } = routeOptions;
+      console.log({ path, method });
+      done();
+    });
+  });
+
+  fastify.get('/', (request, reply) => { reply.send('hello') });
+  ```
+
+  Into this:
+  ```js
+  fastify.register((instance, opts, done) => {
+    instance.addHook('onRoute', (routeOptions) => {
+      const { path, method } = routeOptions;
+      console.log({ path, method });
+      done();
+    });
+  });
+
+  fastify.register((instance, opts, done) => {
+    instance.get('/', (request, reply) => { reply.send('hello') });
+    done();
+  });
+  ```
+
 * use `await register(...)`
 
-For example refactor this:
-```
-fastify.register((instance, opts, done) => {
-  instance.addHook('onRoute', (routeOptions) => {
-    const { path, method } = routeOptions;
-    console.log({ path, method });
+  For example, refactor this:
+  ```js
+  fastify.register((instance, opts, done) => {
+    instance.addHook('onRoute', (routeOptions) => {
+      const { path, method } = routeOptions;
+      console.log({ path, method });
+    });
+    done();
   });
-  done();
-});
-```
-Into this:
-```
-await fastify.register((instance, opts, done) => {
-  instance.addHook('onRoute', (routeOptions) => {
-    const { path, method } = routeOptions;
-    console.log({ path, method });
+  ```
+
+  Into this:
+  ```js
+  await fastify.register((instance, opts) => {
+    instance.addHook('onRoute', (routeOptions) => {
+      const { path, method } = routeOptions;
+      console.log({ path, method });
+    });
+    done();
   });
-  done();
-});
-```
+  ```
 
-## Non Breaking Changes
+## Non-Breaking Changes
 
-### Change of schema for multiple types
+### Deprecation of variadic `.listen()` signature
 
+The [variadic signature](https://en.wikipedia.org/wiki/Variadic_function) of the
+`fastify.listen()` method is now deprecated.
 
-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)
+Prior to this release, the following invocations of this method were valid:
 
-You may encounter a console warning such as
+  - `fastify.listen(8000)`
+  - `fastify.listen(8000, ‘127.0.0.1’)`
+  - `fastify.listen(8000, ‘127.0.0.1’, 511)`
+  - `fastify.listen(8000, (err) => { if (err) throw err })`
+  - `fastify.listen({ port: 8000 }, (err) => { if (err) throw err })`
 
-```
+With Fastify v4, only the following invocations are valid:
+
+  - `fastify.listen()`
+  - `fastify.listen({ port: 8000 })`
+  - `fastify.listen({ port: 8000 }, (err) => { if (err) throw err })`
+
+### Change of schema for multiple types
+
+Ajv has been upgraded to v8 in Fastify v4, meaning "type" keywords with multiple
+types other than "null"
+[are now prohibited](https://ajv.js.org/strict-mode.html#strict-types).
+
+You may encounter a console warning such as:
+```sh
 strict mode: use allowUnionTypes to allow union type keyword at "#/properties/image" (strictTypes)
 ```
-So schemas like below will need to be changed from
+
+As such, schemas like below will need to be changed from:
 ```
 type: 'object',
 properties: {
@@ -117,8 +166,8 @@ properties: {
   }
 }
 ```
-to
 
+Into:
 ```
 type: 'object',
 properties: {

package/docs/Guides/Write-Plugin.md

@@ -80,7 +80,7 @@ to show that the plugin works as intended. Both
 Actions](https://github.com/features/actions) are free for open source projects
 and easy to set up.
 
-In addition, you can enable services like [Dependabot](https://dependabot.com/),
+In addition, you can enable services like [Dependabot](https://github.com/dependabot),
 which will help you keep your dependencies up to date and discover if a new
 release of Fastify has some issues with your plugin.
 

package/docs/Reference/Logging.md

@@ -22,21 +22,24 @@ const fastify = require('fastify')({
 ```
 
 Enabling the logger with appropriate configuration for both local development
-and production environment requires bit more configuration:
+and production and test environment requires bit more configuration:
+
 ```js
+const envToLogger = {
+  development: {
+    transport: {
+      target: 'pino-pretty',
+      options: {
+        translateTime: 'HH:MM:ss Z',
+        ignore: 'pid,hostname',
+      },
+    },
+  },
+  production: true,
+  test: false,
+}
 const fastify = require('fastify')({
-  logger: {
-      transport:
-        environment === 'development'
-          ? {
-              target: 'pino-pretty',
-              options: {
-                translateTime: 'HH:MM:ss Z',
-                ignore: 'pid,hostname'
-              }
-            }
-          : undefined
-    }
+  logger: envToLogger[environment] ?? true // defaults to true if no entry matches in the map
 })
 ```
 ⚠️ `pino-pretty` needs to be installed as a dev dependency, it is not included

package/docs/Reference/Server.md

@@ -54,6 +54,7 @@ describes the properties available in that options object.
     - [setDefaultRoute](#setdefaultroute)
     - [routing](#routing)
     - [route](#route)
+    - [hasRoute](#hasRoute)
     - [close](#close)
     - [decorate*](#decorate)
     - [register](#register)
@@ -667,7 +668,7 @@ the incoming request as usual.
 
 Configure the Ajv v8 instance used by Fastify without providing a custom one.
 The default configuration is explained in the
-[#schema-validator](Validation-and-Serialization.md#schema-validator) section.
+[#schema-validator](./Validation-and-Serialization.md#schema-validator) section.
 
 ```js
 const fastify = require('fastify')({
@@ -1020,7 +1021,8 @@ const defaultRoute = fastify.getDefaultRoute()
 <a id="setDefaultRoute"></a>
 
 **Note**: The default 404 handler, or one set using `setNotFoundHandler`, will
-never trigger if the default route is overridden. Use
+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:
 
@@ -1048,6 +1050,26 @@ fastify.routing(req, res)
 Method to add routes to the server, it also has shorthand functions, check
 [here](./Routes.md).
 
+#### hasRoute
+<a id="hasRoute"></a>
+
+Method to check if a route is already registered to the internal router. It
+expects an object as payload. `url` and `method` are mandatory fields. It is
+possible to also specify `constraints`. The method returns true if the route is
+registered, and false if it is not registered.
+
+```js
+const routeExists = fastify.hasRoute({
+  url: '/',
+  method: 'GET',
+  constraints: { version: '1.0.0' } // optional
+})
+
+if (routeExists === false) {
+  // add route
+}
+```
+
 #### close
 <a id="close"></a>
 

package/docs/Reference/Type-Providers.md

@@ -155,14 +155,7 @@ import Fastify from 'fastify'
 import { TypeBoxTypeProvider } from '@fastify/type-provider-typebox'
 import { Type } from '@sinclair/typebox'
 
-const server = Fastify({
-    ajv: {
-        customOptions: {
-            strict: 'log',
-            keywords: ['kind', 'modifier'],
-        },
-    },
-}).withTypeProvider<TypeBoxTypeProvider>()
+const server = Fastify().withTypeProvider<TypeBoxTypeProvider>()
 
 server.register(plugin1) // wrong
 server.register(plugin2) // correct
@@ -213,14 +206,7 @@ import Fastify from 'fastify'
 import { TypeBoxTypeProvider } from '@fastify/type-provider-typebox'
 import { registerRoutes } from './routes'
 
-const server = Fastify({
-    ajv: {
-        customOptions: {
-            strict: 'log',
-            keywords: ['kind', 'modifier'],
-        },
-    },
-}).withTypeProvider<TypeBoxTypeProvider>()
+const server = Fastify().withTypeProvider<TypeBoxTypeProvider>()
 
 registerRoutes(server)
 

package/docs/Reference/TypeScript.md

@@ -61,6 +61,11 @@ in a blank http Fastify server.
 *Note: Set `target` property in `tsconfig.json` to `es2017` or greater to avoid
 [FastifyDeprecation](https://github.com/fastify/fastify/issues/3284) warning.*
 
+*Note 2: Avoid using ```"moduleResolution": "NodeNext"``` in tsconfig.json with 
+```"type": "module"``` in package.json. This combination is currently not 
+supported by fastify typing system.
+[ts(2349)](https://github.com/fastify/fastify/issues/4241) warning.*
+
 4. Create an `index.ts` file - this will contain the server code
 5. Add the following code block to your file:
    ```typescript
@@ -254,18 +259,6 @@ can do it as follows:
     )
     ```
 
-     **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
 
@@ -1237,8 +1230,8 @@ const plugin: FastifyPlugin<{
   option2: boolean;
 }> = function (instance, opts, done) { }
 
-fastify().register(plugin, {}) // Error - options object is missing required properties
-fastify().register(plugin, { option1: '', option2: true }) // OK - options object contains required properties
+server().register(plugin, {}) // Error - options object is missing required properties
+server().register(plugin, { option1: '', option2: true }) // OK - options object contains required properties
 ```
 
 See the Learn By Example, [Plugins](#plugins) section for more detailed examples

package/examples/typescript-server.ts

@@ -56,7 +56,7 @@ const opts: RouteShorthandOptions = {
 };
 
 // Add our route handler with correct types
-server.get<{
+server.post<{
   Querystring: PingQuerystring;
   Params: PingParams;
   Headers: PingHeaders;

package/fastify.d.ts

@@ -84,7 +84,7 @@ export type FastifyHttpsOptions<
   Server extends https.Server,
   Logger extends FastifyBaseLogger = FastifyLoggerInstance
 > = FastifyServerOptions<Server, Logger> & {
-  https: https.ServerOptions
+  https: https.ServerOptions | null
 }
 
 type FindMyWayVersion<RawServer extends RawServerBase> = RawServer extends http.Server ? HTTPVersion.V1 : HTTPVersion.V2
@@ -197,7 +197,7 @@ export { FastifyPluginCallback, FastifyPluginAsync, FastifyPluginOptions, Fastif
 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 } from './types/route'
+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'

package/fastify.js

@@ -1,6 +1,6 @@
 'use strict'
 
-const VERSION = '4.5.3'
+const VERSION = '4.6.0'
 
 const Avvio = require('avvio')
 const http = require('http')
@@ -267,6 +267,9 @@ function fastify (options) {
       // otherwise we should bind it after the declaration
       return router.route.call(this, { options })
     },
+    hasRoute: function _route (options) {
+      return router.hasRoute.call(this, { options })
+    },
     // expose logger instance
     log: logger,
     // type provider

package/lib/error-serializer.js

@@ -23,14 +23,6 @@ class Serializer {
     }
   }
 
-  asAny (i) {
-    return JSON.stringify(i)
-  }
-
-  asNull () {
-    return 'null'
-  }
-
   asInteger (i) {
     if (typeof i === 'bigint') {
       return i.toString()
@@ -47,10 +39,6 @@ class Serializer {
     }
   }
 
-  asIntegerNullable (i) {
-    return i === null ? 'null' : this.asInteger(i)
-  }
-
   asNumber (i) {
     const num = Number(i)
     if (Number.isNaN(num)) {
@@ -62,54 +50,43 @@ class Serializer {
     }
   }
 
-  asNumberNullable (i) {
-    return i === null ? 'null' : this.asNumber(i)
-  }
-
   asBoolean (bool) {
     return bool && 'true' || 'false' // eslint-disable-line
   }
 
-  asBooleanNullable (bool) {
-    return bool === null ? 'null' : this.asBoolean(bool)
-  }
-
   asDateTime (date) {
     if (date === null) return '""'
     if (date instanceof Date) {
       return '"' + date.toISOString() + '"'
     }
+    if (typeof date === 'string') {
+      return '"' + date + '"'
+    }
     throw new Error(`The value "${date}" cannot be converted to a date-time.`)
   }
 
-  asDateTimeNullable (date) {
-    return date === null ? 'null' : this.asDateTime(date)
-  }
-
   asDate (date) {
     if (date === null) return '""'
     if (date instanceof Date) {
       return '"' + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(0, 10) + '"'
     }
+    if (typeof date === 'string') {
+      return '"' + date + '"'
+    }
     throw new Error(`The value "${date}" cannot be converted to a date.`)
   }
 
-  asDateNullable (date) {
-    return date === null ? 'null' : this.asDate(date)
-  }
-
   asTime (date) {
     if (date === null) return '""'
     if (date instanceof Date) {
       return '"' + new Date(date.getTime() - (date.getTimezoneOffset() * 60000)).toISOString().slice(11, 19) + '"'
     }
+    if (typeof date === 'string') {
+      return '"' + date + '"'
+    }
     throw new Error(`The value "${date}" cannot be converted to a time.`)
   }
 
-  asTimeNullable (date) {
-    return date === null ? 'null' : this.asTime(date)
-  }
-
   asString (str) {
     const quotes = '"'
     if (str instanceof Date) {
@@ -129,10 +106,6 @@ class Serializer {
     }
   }
 
-  asStringNullable (str) {
-    return str === null ? 'null' : this.asString(str)
-  }
-
   // magically escape strings for json
   // relying on their charCodeAt
   // everything below 32 needs JSON.stringify()
@@ -200,7 +173,7 @@ class Serializer {
   }
 
         json += "\"statusCode\"" + ':'
-      json += serializer.asNumber.bind(serializer)(obj["statusCode"])
+      json += serializer.asNumber(obj["statusCode"])
       }
     
       if (obj["code"] !== undefined) {
@@ -212,7 +185,7 @@ class Serializer {
   }
 
         json += "\"code\"" + ':'
-      json += serializer.asString.bind(serializer)(obj["code"])
+      json += serializer.asString(obj["code"])
       }
     
       if (obj["error"] !== undefined) {
@@ -224,7 +197,7 @@ class Serializer {
   }
 
         json += "\"error\"" + ':'
-      json += serializer.asString.bind(serializer)(obj["error"])
+      json += serializer.asString(obj["error"])
       }
     
       if (obj["message"] !== undefined) {
@@ -236,7 +209,7 @@ class Serializer {
   }
 
         json += "\"message\"" + ':'
-      json += serializer.asString.bind(serializer)(obj["message"])
+      json += serializer.asString(obj["message"])
       }
     
       json += '}'

package/lib/route.js

@@ -83,6 +83,7 @@ function buildRouting (options) {
     },
     routing: router.lookup.bind(router), // router func to find the right handler to call
     route, // configure a route in the fastify instance
+    hasRoute,
     prepareRoute,
     getDefaultRoute: function () {
       return router.defaultRoute
@@ -141,6 +142,14 @@ function buildRouting (options) {
     return route.call(this, { options, isFastify })
   }
 
+  function hasRoute ({ options }) {
+    return router.find(
+      options.method,
+      options.url || '',
+      options.constraints
+    ) !== null
+  }
+
   // Route management
   function route ({ options, isFastify }) {
     // Since we are mutating/assigning only top level props, it is fine to have a shallow copy using the spread operator

package/lib/schemas.js

@@ -62,6 +62,7 @@ function normalizeSchema (routeSchemas, serverOptions) {
   // let's check if our schemas have a custom prototype
   for (const key of ['headers', 'querystring', 'params', 'body']) {
     if (typeof routeSchemas[key] === 'object' && Object.getPrototypeOf(routeSchemas[key]) !== Object.prototype) {
+      routeSchemas[kSchemaVisited] = true
       return routeSchemas
     }
   }