Validation and Serialization

Fastify uses a schema-based approach, and even if it is not mandatory we recommend using JSON Schema to validate your routes and serialize your outputs. Internally, Fastify compiles the schema into a highly performant function.

⚠ Security Notice

Treat the schema definition as application code. As both validation and serialization features dynamically evaluate code with new Function(), it is not safe to use user-provided schemas. See Ajv and fast-json-stringify for more details.

Validation

The route validation internally relies upon Ajv, which is a high-performance JSON schema validator. Validating the input is very easy: just add the fields that you need inside the route schema, and you are done! The supported validations are:

  • body: validates the body of the request if it is a POST or a PUT.
  • querystring or query: validates the query string. This can be a complete JSON Schema object (with a type property of 'object' and a 'properties' object containing parameters) or a simpler variation in which the type and properties attributes are forgone and the query parameters are listed at the top level (see the example below).
  • params: validates the route params.
  • headers: validates the request headers.

Example:

  1. const bodyJsonSchema = {
  2. type: 'object',
  3. required: ['requiredKey'],
  4. properties: {
  5. someKey: { type: 'string' },
  6. someOtherKey: { type: 'number' },
  7. requiredKey: {
  8. type: 'array',
  9. maxItems: 3,
  10. items: { type: 'integer' }
  11. },
  12. nullableKey: { type: ['number', 'null'] }, // or { type: 'number', nullable: true }
  13. multipleTypesKey: { type: ['boolean', 'number'] },
  14. multipleRestrictedTypesKey: {
  15. oneOf: [
  16. { type: 'string', maxLength: 5 },
  17. { type: 'number', minimum: 10 }
  18. ]
  19. },
  20. enumKey: {
  21. type: 'string',
  22. enum: ['John', 'Foo']
  23. },
  24. notTypeKey: {
  25. not: { type: 'array' }
  26. }
  27. }
  28. }
  29. const queryStringJsonSchema = {
  30. name: { type: 'string' },
  31. excitement: { type: 'integer' }
  32. }
  33. const paramsJsonSchema = {
  34. type: 'object',
  35. properties: {
  36. par1: { type: 'string' },
  37. par2: { type: 'number' }
  38. }
  39. }
  40. const headersJsonSchema = {
  41. type: 'object',
  42. properties: {
  43. 'x-foo': { type: 'string' }
  44. },
  45. required: ['x-foo']
  46. }
  47. const schema = {
  48. body: bodyJsonSchema,
  49. querystring: queryStringJsonSchema,
  50. params: paramsJsonSchema,
  51. headers: headersJsonSchema
  52. }
  53. fastify.post('/the/url', { schema }, handler)

Note that Ajv will try to coerce the values to the types specified in your schema type keywords, both to pass the validation and to use the correctly typed data afterwards.

Adding a shared schema

Thanks to the addSchema API, you can add multiple schemas to the Fastify instance and then reuse them in multiple parts of your application. As usual, this API is encapsulated.

There are two ways to reuse your shared schemas:

  • $ref-way: as described in the standard, you can refer to an external schema. To use it you have to addSchema with a valid $id absolute URI.
  • replace-way: this is a Fastify utility that lets you to substitute some fields with a shared schema. To use it you have to addSchema with an $id having a relative URI fragment which is a simple string that applies only to alphanumeric chars [A-Za-z0-9].

Here an overview on how to set an $id and how references to it:

More examples:

$ref-way usage examples:

  1. fastify.addSchema({
  2. $id: 'http://example.com/common.json',
  3. type: 'object',
  4. properties: {
  5. hello: { type: 'string' }
  6. }
  7. })
  8. fastify.route({
  9. method: 'POST',
  10. url: '/',
  11. schema: {
  12. body: {
  13. type: 'array',
  14. items: { $ref: 'http://example.com/common.json#/properties/hello' }
  15. }
  16. },
  17. handler: () => {}
  18. })

replace-way usage examples:

  1. const fastify = require('fastify')()
  2. fastify.addSchema({
  3. $id: 'greetings',
  4. type: 'object',
  5. properties: {
  6. hello: { type: 'string' }
  7. }
  8. })
  9. fastify.route({
  10. method: 'POST',
  11. url: '/',
  12. schema: {
  13. body: 'greetings#'
  14. },
  15. handler: () => {}
  16. })
  17. fastify.register((instance, opts, done) => {
  18. /**
  19. * In children's scope can use schemas defined in upper scope like 'greetings'.
  20. * Parent scope can't use the children schemas.
  21. */
  22. instance.addSchema({
  23. $id: 'framework',
  24. type: 'object',
  25. properties: {
  26. fastest: { type: 'string' },
  27. hi: 'greetings#'
  28. }
  29. })
  30. instance.route({
  31. method: 'POST',
  32. url: '/sub',
  33. schema: {
  34. body: 'framework#'
  35. },
  36. handler: () => {}
  37. })
  38. done()
  39. })

You can use the shared schema everywhere, as top level schema or nested inside other schemas:

  1. const fastify = require('fastify')()
  2. fastify.addSchema({
  3. $id: 'greetings',
  4. type: 'object',
  5. properties: {
  6. hello: { type: 'string' }
  7. }
  8. })
  9. fastify.route({
  10. method: 'POST',
  11. url: '/',
  12. schema: {
  13. body: {
  14. type: 'object',
  15. properties: {
  16. greeting: 'greetings#',
  17. timestamp: { type: 'number' }
  18. }
  19. }
  20. },
  21. handler: () => {}
  22. })

Retrieving a copy of shared schemas

The function getSchemas returns the shared schemas available in the selected scope:

  1. fastify.addSchema({ $id: 'one', my: 'hello' })
  2. fastify.get('/', (request, reply) => { reply.send(fastify.getSchemas()) })
  3. fastify.register((instance, opts, done) => {
  4. instance.addSchema({ $id: 'two', my: 'ciao' })
  5. instance.get('/sub', (request, reply) => { reply.send(instance.getSchemas()) })
  6. instance.register((subinstance, opts, done) => {
  7. subinstance.addSchema({ $id: 'three', my: 'hola' })
  8. subinstance.get('/deep', (request, reply) => { reply.send(subinstance.getSchemas()) })
  9. done()
  10. })
  11. done()
  12. })

This example will returns:

URLSchemas
/one
/subone, two
/deepone, two, three

Schema Compiler

The schemaCompiler is a function that returns a function that validates the body, url parameters, headers, and query string. The default schemaCompiler returns a function that implements the ajv validation interface. Fastify uses it internally to speed the validation up.

Fastify's baseline ajv configuration is:

  1. {
  2. removeAdditional: true, // remove additional properties
  3. useDefaults: true, // replace missing properties and items with the values from corresponding default keyword
  4. coerceTypes: true, // change data type of data to match type keyword
  5. allErrors: true, // check for all errors
  6. nullable: true // support keyword "nullable" from Open API 3 specification.
  7. }

This baseline configuration cannot be modified. If you want to change or set additional config options, you will need to create your own instance and override the existing one like:

  1. const fastify = require('fastify')()
  2. const Ajv = require('ajv')
  3. const ajv = new Ajv({
  4. // the fastify defaults (if needed)
  5. removeAdditional: true,
  6. useDefaults: true,
  7. coerceTypes: true,
  8. allErrors: true,
  9. nullable: true,
  10. // any other options
  11. // ...
  12. })
  13. fastify.setSchemaCompiler(function (schema) {
  14. return ajv.compile(schema)
  15. })
  16. // -------
  17. // Alternatively, you can set the schema compiler using the setter property:
  18. fastify.schemaCompiler = function (schema) { return ajv.compile(schema) })

Note: If you use a custom instance of any validator (even Ajv), you have to add schemas to the validator instead of fastify, since fastify's default validator is no longer used, and fastify's addSchema method has no idea what validator you are using.

But maybe you want to change the validation library. Perhaps you like Joi. In this case, you can use it to validate the url parameters, body, and query string!

  1. const Joi = require('joi')
  2. fastify.post('/the/url', {
  3. schema: {
  4. body: Joi.object().keys({
  5. hello: Joi.string().required()
  6. }).required()
  7. },
  8. schemaCompiler: schema => data => Joi.validate(data, schema)
  9. }, handler)

In that case the function returned by schemaCompiler returns an object like:

  • error: filled with an instance of Error or a string that describes the validation error
  • value: the coerced value that passed the validation

Schema Resolver

The schemaResolver is a function that works together with the schemaCompiler: you can't use it with the default schema compiler. This feature is useful when you use complex schemas with $ref keyword in your routes and a custom validator.

This is needed because all the schemas you add to your custom compiler are unknown to Fastify but it need to resolve the $ref paths.

  1. const fastify = require('fastify')()
  2. const Ajv = require('ajv')
  3. const ajv = new Ajv()
  4. ajv.addSchema({
  5. $id: 'urn:schema:foo',
  6. definitions: {
  7. foo: { type: 'string' }
  8. },
  9. type: 'object',
  10. properties: {
  11. foo: { $ref: '#/definitions/foo' }
  12. }
  13. })
  14. ajv.addSchema({
  15. $id: 'urn:schema:response',
  16. type: 'object',
  17. required: ['foo'],
  18. properties: {
  19. foo: { $ref: 'urn:schema:foo#/definitions/foo' }
  20. }
  21. })
  22. ajv.addSchema({
  23. $id: 'urn:schema:request',
  24. type: 'object',
  25. required: ['foo'],
  26. properties: {
  27. foo: { $ref: 'urn:schema:foo#/definitions/foo' }
  28. }
  29. })
  30. fastify.setSchemaCompiler(schema => ajv.compile(schema))
  31. fastify.setSchemaResolver((ref) => {
  32. return ajv.getSchema(ref).schema
  33. })
  34. fastify.route({
  35. method: 'POST',
  36. url: '/',
  37. schema: {
  38. body: ajv.getSchema('urn:schema:request').schema,
  39. response: {
  40. '2xx': ajv.getSchema('urn:schema:response').schema
  41. }
  42. },
  43. handler (req, reply) {
  44. reply.send({ foo: 'bar' })
  45. }
  46. })

Serialization

Usually you will send your data to the clients via JSON, and Fastify has a powerful tool to help you, fast-json-stringify, which is used if you have provided an output schema in the route options. We encourage you to use an output schema, as it will increase your throughput by 100-400% depending on your payload and will prevent accidental disclosure of sensitive information.

Example:

  1. const schema = {
  2. response: {
  3. 200: {
  4. type: 'object',
  5. properties: {
  6. value: { type: 'string' },
  7. otherValue: { type: 'boolean' }
  8. }
  9. }
  10. }
  11. }
  12. fastify.post('/the/url', { schema }, handler)

As you can see, the response schema is based on the status code. If you want to use the same schema for multiple status codes, you can use '2xx', for example:

  1. const schema = {
  2. response: {
  3. '2xx': {
  4. type: 'object',
  5. properties: {
  6. value: { type: 'string' },
  7. otherValue: { type: 'boolean' }
  8. }
  9. },
  10. 201: {
  11. type: 'object',
  12. properties: {
  13. value: { type: 'string' }
  14. }
  15. }
  16. }
  17. }
  18. fastify.post('/the/url', { schema }, handler)

If you need a custom serializer in a very specific part of your code, you can set one with reply.serializer(…).

Error Handling

When schema validation fails for a request, Fastify will automtically return a status 400 response including the result from the validator in the payload. As an example, if you have the following schema for your route

  1. const schema = {
  2. body: {
  3. type: 'object',
  4. properties: {
  5. name: { type: 'string' }
  6. },
  7. required: ['name']
  8. }
  9. }

and fail to satisfy it, the route will immediately return a response with the following payload

  1. {
  2. "statusCode": 400,
  3. "error": "Bad Request",
  4. "message": "body should have required property 'name'"
  5. }

If you want to handle errors inside the route, you can specify the attachValidation option for your route. If there is a validation error, the validationError property of the request will contain the Error object with the raw validation result as shown below

  1. const fastify = Fastify()
  2. fastify.post('/', { schema, attachValidation: true }, function (req, reply) {
  3. if (req.validationError) {
  4. // `req.validationError.validation` contains the raw validation error
  5. reply.code(400).send(req.validationError)
  6. }
  7. })

You can also use setErrorHandler to define a custom response for validation errors such as

  1. fastify.setErrorHandler(function (error, request, reply) {
  2. if (error.validation) {
  3. reply.status(422).send(new Error('validation failed'))
  4. }
  5. })

If you want custom error response in schema without headaches and quickly, you can take a look at here

JSON Schema and Shared Schema support

JSON Schema has some type of utilities in order to optimize your schemas that, in conjuction with the Fastify's shared schema, let you reuse all your schemas easily.

Use CaseValidatorSerializer
shared schema✔️✔️
$ref to $id️️✔️✔️
$ref to /definitions✔️✔️
$ref to shared schema $id✔️✔️
$ref to shared schema /definitions✔️✔️

Examples

  1. // Usage of the Shared Schema feature
  2. fastify.addSchema({
  3. $id: 'sharedAddress',
  4. type: 'object',
  5. properties: {
  6. city: { 'type': 'string' }
  7. }
  8. })
  9. const sharedSchema = {
  10. type: 'object',
  11. properties: {
  12. home: 'sharedAddress#',
  13. work: 'sharedAddress#'
  14. }
  15. }
  1. // Usage of $ref to $id in same JSON Schema
  2. const refToId = {
  3. type: 'object',
  4. definitions: {
  5. foo: {
  6. $id: '#address',
  7. type: 'object',
  8. properties: {
  9. city: { 'type': 'string' }
  10. }
  11. }
  12. },
  13. properties: {
  14. home: { $ref: '#address' },
  15. work: { $ref: '#address' }
  16. }
  17. }
  1. // Usage of $ref to /definitions in same JSON Schema
  2. const refToDefinitions = {
  3. type: 'object',
  4. definitions: {
  5. foo: {
  6. $id: '#address',
  7. type: 'object',
  8. properties: {
  9. city: { 'type': 'string' }
  10. }
  11. }
  12. },
  13. properties: {
  14. home: { $ref: '#/definitions/foo' },
  15. work: { $ref: '#/definitions/foo' }
  16. }
  17. }
  1. // Usage $ref to a shared schema $id as external schema
  2. fastify.addSchema({
  3. $id: 'http://foo/common.json',
  4. type: 'object',
  5. definitions: {
  6. foo: {
  7. $id: '#address',
  8. type: 'object',
  9. properties: {
  10. city: { 'type': 'string' }
  11. }
  12. }
  13. }
  14. })
  15. const refToSharedSchemaId = {
  16. type: 'object',
  17. properties: {
  18. home: { $ref: 'http://foo/common.json#address' },
  19. work: { $ref: 'http://foo/common.json#address' }
  20. }
  21. }
  1. // Usage $ref to a shared schema /definitions as external schema
  2. fastify.addSchema({
  3. $id: 'http://foo/common.json',
  4. type: 'object',
  5. definitions: {
  6. foo: {
  7. type: 'object',
  8. properties: {
  9. city: { 'type': 'string' }
  10. }
  11. }
  12. }
  13. })
  14. const refToSharedSchemaDefinitions = {
  15. type: 'object',
  16. properties: {
  17. home: { $ref: 'http://foo/common.json#/definitions/foo' },
  18. work: { $ref: 'http://foo/common.json#/definitions/foo' }
  19. }
  20. }

Resources