fastify 3.11.0 → 3.14.1

package/docs/TypeScript.md

@@ -37,7 +37,7 @@ This example will get you up and running with Fastify and TypeScript. It results
   ```
 3. Initialize a TypeScript configuration file:
   ```bash
-  npx typescript --init
+  npx tsc --init
   ```
   or use one of the [recommended ones](https://github.com/tsconfig/bases#node-10-tsconfigjson).
 
@@ -82,7 +82,7 @@ The type system heavily relies on generic properties to provide the most accurat
    }
 
    interface IHeaders {
-     'H-Custom': string;
+     'h-Custom': string;
    }
    ```
 3. Using the two interfaces, define a new API route and pass them as generics. The shorthand route methods (i.e. `.get`) accept a generic object `RequestGenericInterface` containing four named properties: `Body`, `Querystring`, `Params`, and `Headers`. The interfaces will be passed down through the route method into the route method handler `request` instance.
@@ -92,12 +92,13 @@ The type system heavily relies on generic properties to provide the most accurat
      Headers: IHeaders
    }>('/auth', async (request, reply) => {
      const { username, password } = request.query
-     const customerHeader = request.headers['H-Custom']
+     const customerHeader = request.headers['h-Custom']
      // do something with request data
 
      return `logged in!`
    })
    ```
+
 4. Build and run the server code with `npm run build` and `npm run start`
 5. Query the api
    ```bash
@@ -115,7 +116,7 @@ The type system heavily relies on generic properties to provide the most accurat
        done(username !== 'admin' ? new Error('Must be admin') : undefined) // only validate `admin` account
      }
    }, async (request, reply) => {
-     const customerHeader = request.headers['H-Custom']
+     const customerHeader = request.headers['h-Custom']
      // do something with request data
      return `logged in!`
    })
@@ -126,25 +127,92 @@ The type system heavily relies on generic properties to provide the most accurat
 
 ### JSON Schema
 
+To validate your requests and responses you can use JSON Schema files. If you didn't know already, defining schemas for your Fastify routes can increase their throughput! Check out the [Validation and Serialization](Validation-and-Serialization.md) documentation for more info.
+
+Also it has the advantage to use the defined type within your handlers (including pre-validation, etc.).
+
+Here are some options how to achieve this.
+
+
+#### 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.
+
+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.
+
+    ```bash
+    npm i @sinclair/typebox
+    ```
+
+2. Define the schema you need with `Type` and create the respective type  with `Static`.
+  
+    ```typescript
+    import { Static, Type } from '@sinclair/typebox'
+
+    const User = Type.Object({
+      name: Type.String(),
+      mail: Type.Optional(Type.String({ format: "email" })),
+    });
+    type UserType = Static<typeof User>;
+    ```
+
+3. Use the defined type and schema during the definition of your route
+
+    ```typescript
+    const app = fastify();
+
+    app.post<{ Body: UserType; Response: UserType }>(
+      "/",
+      {
+        schema: {
+          body: User,
+          response: {
+            200: User,
+          },
+        },
+      },
+      (req, rep) => {
+        const { body: user } = req;
+        /* user has type
+        * const user: StaticProperties<{
+        *  name: TString;
+        *  mail: TOptional<TString>;
+        * }>
+        */
+        //...
+        rep.status(200).send(user);
+      }
+    );
+    ```
+
+#### Schemas in JSON Files
+
 In the last example we used interfaces to define the types for the request querystring and headers. Many users will already be using JSON Schemas to define these properties, and luckily there is a way to transform existing JSON Schemas into TypeScript interfaces!
 
 1. If you did not complete the 'Getting Started' example, go back and follow steps 1-4 first.
 2. Install the `json-schema-to-typescript` module:
-   ```
+
+   ```bash
    npm i -D json-schema-to-typescript
    ```
+
 3. Create a new folder called `schemas` and add two files `headers.json` and `querystring.json`. Copy and paste the following schema definitions into the respective files:
+
    ```json
    {
      "title": "Headers Schema",
      "type": "object",
      "properties": {
-       "H-Custom": { "type": "string" }
+       "h-Custom": { "type": "string" }
      },
      "additionalProperties": false,
-     "required": ["H-Custom"]
+     "required": ["h-Custom"]
    }
    ```
+
    ```json
    {
      "title": "Querystring Schema",
@@ -157,18 +225,22 @@ In the last example we used interfaces to define the types for the request query
      "required": ["username", "password"]
    }
    ```
+
 4. Add a `compile-schemas` script to the package.json:
-   ```json
+
+```json
    {
      "scripts": {
        "compile-schemas": "json2ts -i schemas -o types"
      }
    }
-   ```
+```
+
    `json2ts` is a CLI utility included in `json-schema-to-typescript`. `schemas` is the input path, and `types` is the output path.
 5. Run `npm run compile-schemas`. Two new files should have been created in the `types` directory.
 6. Update `index.ts` to have the following code:
-   ```typescript
+
+```typescript
    import fastify from 'fastify'
 
    // import json schemas as normal
@@ -194,7 +266,7 @@ In the last example we used interfaces to define the types for the request query
        done(username !== 'admin' ? new Error('Must be admin') : undefined)
      }
    }, async (request, reply) => {
-     const customerHeader = request.headers['H-Custom']
+     const customerHeader = request.headers['h-Custom']
      // do something with request data
      return `logged in!`
    })
@@ -211,11 +283,11 @@ In the last example we used interfaces to define the types for the request query
      },
      preHandler: (request, reply) => {
        const { username, password } = request.query
-       const customerHeader = request.headers['H-Custom']
+       const customerHeader = request.headers['h-Custom']
      },
      handler: (request, reply) => {
        const { username, password } = request.query
-       const customerHeader = request.headers['H-Custom']
+       const customerHeader = request.headers['h-Custom']
      }
    })
 
@@ -229,10 +301,67 @@ In the last example we used interfaces to define the types for the request query
    ```
    Pay special attention to the imports at the top of this file. It might seem redundant, but you need to import both the schema files and the generated interfaces.
 
-Great work! Now you can make use of both JSON Schemas and TypeScript definitions. If you didn't know already, defining schemas for your Fastify routes can increase their throughput! Check out the [Validation and Serialization](Validation-and-Serialization.md) documentation for more info.
+Great work! Now you can make use of both JSON Schemas and TypeScript definitions.
+
+#### json-schema-to-ts
+
+If you do not want to generate types from your schemas, but want to use them diretly from your code, you can use the package
+[json-schema-to-ts](https://www.npmjs.com/package/json-schema-to-ts).
+
+You can install it as dev-dependency.
+
+```bash
+npm install -D json-schema-to-ts
+```
+
+In your code you can define your schema like a normal object. But be aware of making it *const* like explained in the docs of the module.
+
+```typescript
+const todo = {
+  type: 'object',
+  properties: {
+    name: { type: 'string' },
+    description: { type: 'string' },
+    done: { type: 'boolean' },
+  },
+  required: ['name'],
+} as const;
+```
+
+With the provided type `FromSchema` you can build a type from your schema and use it in your handler.
 
-Some additional notes:
-- Currently, there is no type definition support for inline JSON schemas. If you can come up with a solution please open a PR!
+```typescript
+fastify.post<{ Body: FromSchema<typeof todo> }>(
+  '/todo',
+  {
+    schema: {
+      body: todo,
+      response: {
+        201: {
+          type: 'string',
+        },
+      },
+    }
+  },
+  async (request, reply): Promise<void> => {
+
+    /*
+    request.body has type 
+    {
+      [x: string]: unknown;
+      description?: string;
+      done?: boolean;
+      name: string;
+    }
+    */
+
+    request.body.name // will not throw type error
+    request.body.notthere // will throw type error
+    
+    reply.status(201).send();
+  },
+);
+```
 
 ### Plugins
 
@@ -393,6 +522,19 @@ However, there are a couple of suggestions to help improve this experience:
 - Make sure the `no-unused-vars` rule is enabled in [ESLint](https://eslint.org/docs/rules/no-unused-vars) and any imported plugin are actually being loaded.
 - Use a module such as [depcheck](https://www.npmjs.com/package/depcheck) or [npm-check](https://www.npmjs.com/package/npm-check) to verify plugin dependencies are being used somewhere in your project.
 
+## Code Completion In Vanilla JavaScript
+
+Vanilla JavaScript can use the published types to provide code completion (e.g. [Intellisense](https://code.visualstudio.com/docs/editor/intellisense)) by following the [TypeScript JSDoc Reference](https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html).
+
+For example:
+
+```js
+/**  @type {import('fastify').FastifyPluginAsync<{ optionA: boolean, optionB: string }>} */
+module.exports = async function (fastify, { optionA, optionB }) {
+  fastify.get('/look', () => 'at me');
+}
+```
+
 ## API Type System Documentation
 
 This section is a detailed account of all the types available to you in Fastify version 3.x
@@ -704,7 +846,7 @@ import fastify, { RequestGenericInterface } from 'fastify'
 
 const server = fastify()
 
-const requestGeneric: RequestGenericInterface = {
+interface requestGeneric extends RequestGenericInterface {
   Querystring: {
     name: string
   }

package/docs/Validation-and-Serialization.md

@@ -101,7 +101,7 @@ As usual, the function `getSchemas` is encapsulated and returns the shared schem
 ```js
 fastify.addSchema({ $id: 'one', my: 'hello' })
 // will return only `one` schema
-fastify.get('/', (request, reply) => { reply.send(fastify.getSchemas()) }) 
+fastify.get('/', (request, reply) => { reply.send(fastify.getSchemas()) })
 
 fastify.register((instance, opts, done) => {
   instance.addSchema({ $id: 'two', my: 'ciao' })
@@ -198,6 +198,62 @@ fastify.post('/the/url', { schema }, handler)
 
 *Note that Ajv will try to [coerce](https://github.com/epoberezkin/ajv#coercing-data-types) the values to the types specified in your schema `type` keywords, both to pass the validation and to use the correctly typed data afterwards.*
 
+The Ajv default configuration in Fastify doesn't support coercing array parameters in querystring. However, Fastify allows [`customOptions`](Server.md#ajv) in Ajv instance. The `coerceTypes: 'array'` will coerce one parameter to a single element in array. Example:
+
+```js
+const opts = {
+  schema: {
+    querystring: {
+      type: 'object',
+      properties: {
+        ids: {
+          type: 'array',
+          default: []
+        },
+      },
+    }
+  }
+}
+
+fastify.get('/', opts, (request, reply) => {
+  reply.send({ params: request.query })
+})
+
+fastify.listen(3000, (err) => {
+  if (err) throw err
+})
+```
+
+Using Fastify defaults the following request will result in `400` status code:
+
+```sh
+curl -X GET "http://localhost:3000/?ids=1
+
+{"statusCode":400,"error":"Bad Request","message":"querystring/hello should be array"}
+```
+
+Using `coerceTypes` as 'array' should fix it:
+
+```js
+const ajv = new Ajv({
+  removeAdditional: true,
+  useDefaults: true,
+  coerceTypes: 'array', // This line
+  allErrors: true
+})
+
+fastify.setValidatorCompiler(({ schema, method, url, httpPart }) => {
+  return ajv.compile(schema)
+})
+```
+
+```sh
+curl -X GET "http://localhost:3000/?ids=1
+
+{"params":{"hello":["1"]}}
+```
+
+For further information see [here](https://ajv.js.org/docs/coercion.html)
 
 <a name="ajv-plugins"></a>
 #### Ajv Plugins
@@ -488,10 +544,10 @@ const schema = {
 and fail to satisfy it, the route will immediately return a response with the following payload
 
 ```js
-{ 
+{
   "statusCode": 400,
   "error": "Bad Request",
-  "message": "body should have required property 'name'" 
+  "message": "body should have required property 'name'"
 }
 ```
 
@@ -519,7 +575,7 @@ The context function will be the Fastify server instance.
 ```js
 const fastify = Fastify({
   schemaErrorFormatter: (errors, dataVar) => {
-    // ... my formatting logic 
+    // ... my formatting logic
     return new Error(myErrorMessage)
   }
 })
@@ -527,7 +583,7 @@ const fastify = Fastify({
 // or
 fastify.setSchemaErrorFormatter(function (errors, dataVar) {
   this.log.error({ err: errors }, 'Validation failed')
-  // ... my formatting logic 
+  // ... my formatting logic
   return new Error(myErrorMessage)
 })
 ```
@@ -542,7 +598,7 @@ fastify.setErrorHandler(function (error, request, reply) {
 })
 ```
 
-If you want custom error response in schema without headaches and quickly, you can take a look at [`ajv-errors`](https://github.com/epoberezkin/ajv-errors). Checkout the [example](https://github.com/fastify/example/blob/master/validation-messages/custom-errors-messages.js) usage.
+If you want custom error response in schema without headaches and quickly, you can take a look at [`ajv-errors`](https://github.com/epoberezkin/ajv-errors). Checkout the [example](https://github.com/fastify/example/blob/HEAD/validation-messages/custom-errors-messages.js) usage.
 
 Below is an example showing how to add **custom error messages for each property** of a schema by supplying custom AJV options.
 Inline comments in the schema below describe how to configure it to show a different error message for each case:

package/docs/Write-Plugin.md

@@ -41,12 +41,12 @@ It is not mandatory, but we highly recommend you use a code linter in your plugi
 We use [`standard`](https://standardjs.com/) since it works without the need to configure it and is very easy integrate in a test suite.
 
 ## Continuous Integration
-It is not mandatory, but if you release your code as open source it helps to use Continuous Integration to ensure contributions do not break your plugin and to show that the plugin works as intended. Both [CircleCI](https://circleci.com/) and [GitHub Actions](https://github.com/features/actions) are free for open source projects and easy to setup.<br>
-In addition you can enable services like [Dependabot](https://dependabot.com/) or [Snyk](https://snyk.io/), that will help you keep your dependencies up to date and discover if a new release of Fastify has some issues with your plugin.
+It is not mandatory, but if you release your code as open source, it helps to use Continuous Integration to ensure contributions do not break your plugin and to show that the plugin works as intended. Both [CircleCI](https://circleci.com/) and [GitHub Actions](https://github.com/features/actions) are free for open source projects and easy to setup.<br>
+In addition, you can enable services like [Dependabot](https://dependabot.com/) or [Snyk](https://snyk.io/), which will help you keep your dependencies up to date and discover if a new release of Fastify has some issues with your plugin.
 
 ## Let's start!
 Awesome, now you know everything you need to know about how to write a good plugin for Fastify!
-After you've built one (or more!) let us know! We will add it to the [ecosystem](https://github.com/fastify/fastify#ecosystem) section of our documentation!
+After you have built one (or more!) let us know! We will add it to the [ecosystem](https://github.com/fastify/fastify#ecosystem) section of our documentation!
 
 If you want to see some real world examples, checkout:
 - [`point-of-view`](https://github.com/fastify/point-of-view)

package/fastify.d.ts

@@ -2,6 +2,7 @@ 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'
 import { RawServerBase, RawServerDefault, RawRequestDefaultExpression, RawReplyDefaultExpression } from './types/utils'
@@ -12,6 +13,7 @@ import * as ajv from 'ajv'
 import { FastifyError } from 'fastify-error'
 import { FastifyReply } from './types/reply'
 import { FastifySchemaValidationError } from './types/schema'
+import { ConstructorAction, ProtoAction } from "./types/content-type-parser";
 
 /**
  * Fastify factory function for the standard fastify http, https, or http2 server instance.
@@ -69,6 +71,9 @@ export type FastifyHttpsOptions<
 > = FastifyServerOptions<Server, Logger> & {
   https: https.ServerOptions
 }
+
+type FindMyWayVersion<RawServer extends RawServerBase> = RawServer extends http.Server ? HTTPVersion.V1 : HTTPVersion.V2
+
 /**
  * Options for a fastify server instance. Utilizes conditional logic on the generic server parameter to enforce certain https and http2
  */
@@ -84,8 +89,8 @@ export type FastifyServerOptions<
   maxParamLength?: number,
   disableRequestLogging?: boolean,
   exposeHeadRoutes?: boolean,
-  onProtoPoisoning?: 'error' | 'remove' | 'ignore',
-  onConstructorPoisoning?: 'error' | 'remove' | 'ignore',
+  onProtoPoisoning?: ProtoAction,
+  onConstructorPoisoning?: ConstructorAction,
   logger?: boolean | FastifyLoggerOptions<RawServer> | Logger,
   serverFactory?: FastifyServerFactory<RawServer>,
   caseSensitive?: boolean,
@@ -94,6 +99,9 @@ export type FastifyServerOptions<
   genReqId?: <RequestGeneric extends RequestGenericInterface = RequestGenericInterface>(req: FastifyRequest<RequestGeneric, RawServer, RawRequestDefaultExpression<RawServer>>) => string,
   trustProxy?: boolean | string | string[] | number | TrustProxyFunction,
   querystringParser?: (str: string) => { [key: string]: unknown },
+  /**
+   * @deprecated Prefer using the `constraints.version` property
+   */
   versioning?: {
     storage(): {
       get(version: string): string | null,
@@ -103,6 +111,9 @@ export type FastifyServerOptions<
     },
     deriveVersion<Context>(req: Object, ctx?: Context): string // not a fan of using Object here. Also what is Context? Can either of these be better defined?
   },
+  constraints?: {
+    [name: string]: ConstraintStrategy<FindMyWayVersion<RawServer>>,
+  },
   return503OnClosing?: boolean,
   ajv?: {
     customOptions?: ajv.Options,
@@ -142,7 +153,7 @@ export { FastifyLoggerOptions, FastifyLoggerInstance, FastifyLogFn, LogLevel } f
 export { FastifyContext } from './types/context'
 export { RouteHandler, RouteHandlerMethod, RouteOptions, RouteShorthandMethod, RouteShorthandOptions, RouteShorthandOptionsWithHandler } from './types/route'
 export * from './types/register'
-export { FastifyBodyParser, FastifyContentTypeParser, AddContentTypeParser, hasContentTypeParser } from './types/content-type-parser'
+export { FastifyBodyParser, FastifyContentTypeParser, AddContentTypeParser, hasContentTypeParser, getDefaultJsonParser, ProtoAction, ConstructorAction } from './types/content-type-parser'
 export { FastifyError } from 'fastify-error'
 export { FastifySchema, FastifySchemaCompiler } from './types/schema'
 export { HTTPMethods, RawServerBase, RawRequestDefaultExpression, RawReplyDefaultExpression, RawServerDefault, ContextConfigDefault, RequestBodyDefault, RequestQuerystringDefault, RequestParamsDefault, RequestHeadersDefault } from './types/utils'

package/fastify.js

@@ -15,9 +15,7 @@ const {
   kLogLevel,
   kLogSerializers,
   kHooks,
-  kSchemas,
-  kValidatorCompiler,
-  kSerializerCompiler,
+  kSchemaController,
   kReplySerializerDefault,
   kContentTypeParser,
   kReply,
@@ -36,8 +34,8 @@ const Request = require('./lib/request')
 const supportedMethods = ['DELETE', 'GET', 'HEAD', 'PATCH', 'POST', 'PUT', 'OPTIONS']
 const decorator = require('./lib/decorate')
 const ContentTypeParser = require('./lib/contentTypeParser')
+const SchemaController = require('./lib/schema-controller')
 const { Hooks, hookRunnerApplication } = require('./lib/hooks')
-const { Schemas } = require('./lib/schemas')
 const { createLogger } = require('./lib/logger')
 const pluginUtils = require('./lib/pluginUtils')
 const reqIdGenFactory = require('./lib/reqIdGenFactory')
@@ -45,6 +43,7 @@ const { buildRouting, validateBodyLimitOption } = require('./lib/route')
 const build404 = require('./lib/fourOhFour')
 const getSecuredInitialConfig = require('./lib/initialConfigValidation')
 const override = require('./lib/pluginOverride')
+const warning = require('./lib/warnings')
 const { defaultInitOptions } = getSecuredInitialConfig
 
 const {
@@ -86,6 +85,10 @@ function fastify (options) {
     throw new Error(`querystringParser option should be a function, instead got '${typeof options.querystringParser}'`)
   }
 
+  if (options.schemaController && options.schemaController.bucket && typeof options.schemaController.bucket !== 'function') {
+    throw new Error(`schemaController.bucket option should be a function, instead got '${typeof options.schemaController.bucket}'`)
+  }
+
   validateBodyLimitOption(options.bodyLimit)
 
   const requestIdHeader = options.requestIdHeader || defaultInitOptions.requestIdHeader
@@ -132,15 +135,34 @@ function fastify (options) {
 
   const initialConfig = getSecuredInitialConfig(options)
 
+  let constraints = options.constraints
+  if (options.versioning) {
+    warning.emit('FSTDEP009')
+    constraints = {
+      ...constraints,
+      version: {
+        name: 'version',
+        mustMatchWhenDerived: true,
+        storage: options.versioning.storage,
+        deriveConstraint: options.versioning.deriveVersion,
+        validate (value) {
+          if (typeof value !== 'string') {
+            throw new Error('Version constraint should be a string.')
+          }
+        }
+      }
+    }
+  }
+
   // Default router
   const router = buildRouting({
     config: {
       defaultRoute: defaultRoute,
       onBadUrl: onBadUrl,
+      constraints: constraints,
       ignoreTrailingSlash: options.ignoreTrailingSlash || defaultInitOptions.ignoreTrailingSlash,
       maxParamLength: options.maxParamLength || defaultInitOptions.maxParamLength,
-      caseSensitive: options.caseSensitive,
-      versioning: options.versioning
+      caseSensitive: options.caseSensitive
     }
   })
 
@@ -155,7 +177,7 @@ function fastify (options) {
   const { server, listen } = createServer(options, httpHandler)
 
   const setupResponseListeners = Reply.setupResponseListeners
-  const schemas = new Schemas()
+  const schemaController = SchemaController.buildSchemaController(null, options.schemaController)
 
   // Public API
   const fastify = {
@@ -172,11 +194,9 @@ function fastify (options) {
     [kLogLevel]: '',
     [kLogSerializers]: null,
     [kHooks]: new Hooks(),
-    [kSchemas]: schemas,
-    [kValidatorCompiler]: null,
+    [kSchemaController]: schemaController,
     [kSchemaErrorFormatter]: null,
     [kErrorHandler]: defaultErrorHandler,
-    [kSerializerCompiler]: null,
     [kReplySerializerDefault]: null,
     [kContentTypeParser]: new ContentTypeParser(
       bodyLimit,
@@ -230,10 +250,11 @@ function fastify (options) {
     addHook: addHook,
     // schemas
     addSchema: addSchema,
-    getSchema: schemas.getSchema.bind(schemas),
-    getSchemas: schemas.getSchemas.bind(schemas),
+    getSchema: schemaController.getSchema.bind(schemaController),
+    getSchemas: schemaController.getSchemas.bind(schemaController),
     setValidatorCompiler: setValidatorCompiler,
     setSerializerCompiler: setSerializerCompiler,
+    setSchemaController: setSchemaController,
     setReplySerializer: setReplySerializer,
     setSchemaErrorFormatter: setSchemaErrorFormatter,
     // custom parsers
@@ -247,6 +268,7 @@ function fastify (options) {
     ready: null,
     onClose: null,
     close: null,
+    printPlugins: null,
     // http server
     listen: listen,
     server: server,
@@ -281,10 +303,10 @@ function fastify (options) {
       get () { return this[kRoutePrefix] }
     },
     validatorCompiler: {
-      get () { return this[kValidatorCompiler] }
+      get () { return this[kSchemaController].getValidatorCompiler() }
     },
     serializerCompiler: {
-      get () { return this[kSerializerCompiler] }
+      get () { return this[kSchemaController].getSerializerCompiler() }
     },
     version: {
       get () {
@@ -330,6 +352,8 @@ function fastify (options) {
   avvio.on('start', () => (fastify[kState].started = true))
   fastify[kAvvioBoot] = fastify.ready // the avvio ready function
   fastify.ready = ready // overwrite the avvio ready function
+  fastify.printPlugins = avvio.prettyPrint.bind(avvio)
+
   // cache the closing value, since we are checking it in an hot path
   avvio.once('preReady', () => {
     fastify.onClose((instance, done) => {
@@ -495,7 +519,7 @@ function fastify (options) {
   // wrapper that we expose to the user for schemas handling
   function addSchema (schema) {
     throwIfAlreadyStarted('Cannot call "addSchema" when fastify instance is already started!')
-    this[kSchemas].add(schema)
+    this[kSchemaController].add(schema)
     this[kChildren].forEach(child => child.addSchema(schema))
     return this
   }
@@ -516,7 +540,7 @@ function fastify (options) {
 
     // Most devs do not know what to do with this error.
     // In the vast majority of cases, it's a network error and/or some
-    // config issue on the the load balancer side.
+    // config issue on the load balancer side.
     this.log.trace({ err }, 'client error')
 
     // If the socket is not writable, there is no reason to try to send data.
@@ -562,7 +586,7 @@ function fastify (options) {
 
   function setValidatorCompiler (validatorCompiler) {
     throwIfAlreadyStarted('Cannot call "setValidatorCompiler" when fastify instance is already started!')
-    this[kValidatorCompiler] = validatorCompiler
+    this[kSchemaController].setValidatorCompiler(validatorCompiler)
     return this
   }
 
@@ -575,7 +599,17 @@ function fastify (options) {
 
   function setSerializerCompiler (serializerCompiler) {
     throwIfAlreadyStarted('Cannot call "setSerializerCompiler" when fastify instance is already started!')
-    this[kSerializerCompiler] = serializerCompiler
+    this[kSchemaController].setSerializerCompiler(serializerCompiler)
+    return this
+  }
+
+  function setSchemaController (schemaControllerOpts) {
+    throwIfAlreadyStarted('Cannot call "setSchemaController" when fastify instance is already started!')
+    const old = this[kSchemaController]
+    const schemaController = SchemaController.buildSchemaController(old.parent, Object.assign({}, old.opts, schemaControllerOpts))
+    this[kSchemaController] = schemaController
+    this.getSchema = schemaController.getSchema.bind(schemaController)
+    this.getSchemas = schemaController.getSchemas.bind(schemaController)
     return this
   }