Fluent Schema

The Validation and Serialization documentation outlines all parameters accepted by Fastify to set up JSON Schema Validation in order to validate the input, and JSON Schema Serialization in order to optimize the output.

fluent-json-schema can be used to simplify this task while allowing the reuse of constants.

Basic settings

  1. const S = require('fluent-json-schema')
  3. // You can have an object like this, or query a DB to get the values
  4. const MY_KEYS = {
  5.   KEY1: 'ONE',
  6.   KEY2: 'TWO'
  7. }
  9. const bodyJsonSchema = S.object()
  10.   .prop('someKey', S.string())
  11.   .prop('someOtherKey', S.number())
  12.   .prop('requiredKey', S.array().maxItems(3).items(S.integer()).required())
  13.   .prop('nullableKey', S.mixed([S.TYPES.NUMBER, S.TYPES.NULL]))
  14.   .prop('multipleTypesKey', S.mixed([S.TYPES.BOOLEAN, S.TYPES.NUMBER]))
  15.   .prop('multipleRestrictedTypesKey', S.oneOf([S.string().maxLength(5), S.number().minimum(10)]))
  16.   .prop('enumKey', S.enum(Object.values(MY_KEYS)))
  17.   .prop('notTypeKey', S.not(S.array()))
  19. const queryStringJsonSchema = S.object()
  20.   .prop('name', S.string())
  21.   .prop('excitement', S.integer())
  23. const paramsJsonSchema = S.object()
  24.   .prop('par1', S.string())
  25.   .prop('par2', S.integer())
  27. const headersJsonSchema = S.object()
  28.   .prop('x-foo', S.string().required())
  30. // Note that there is no need to call `.valueOf()`!
  31. const schema = {
  32.   body: bodyJsonSchema,
  33.   querystring: queryStringJsonSchema, // (or) query: queryStringJsonSchema
  34.   params: paramsJsonSchema,
  35.   headers: headersJsonSchema
  36. }
  38. fastify.post('/the/url', { schema }, handler)

Reuse

With fluent-json-schema you can manipulate your schemas in an easier and programmatic way and then reuse them thanks to the addSchema() method. You can refer to the schema in two different manners that are detailed in the Validation-and-Serialization.md documentation.

Here are some usage examples:

$ref-way: refer to an external schema.

  1. const addressSchema = S.object()
  2.   .id('#address')
  3.   .prop('line1').required()
  4.   .prop('line2')
  5.   .prop('country').required()
  6.   .prop('city').required()
  7.   .prop('zipcode').required()
  9. const commonSchemas = S.object()
  10.   .id('https://fastify/demo')
  11.   .definition('addressSchema', addressSchema)
  12.   .definition('otherSchema', otherSchema) // You can add any schemas you need
  14. fastify.addSchema(commonSchemas)
  16. const bodyJsonSchema = S.object()
  17.   .prop('residence', S.ref('https://fastify/demo#address')).required()
  18.   .prop('office', S.ref('https://fastify/demo#/definitions/addressSchema')).required()
  20. const schema = { body: bodyJsonSchema }
  22. fastify.post('/the/url', { schema }, handler)

replace-way: refer to a shared schema to replace before the validation process.

  1. const sharedAddressSchema = {
  2.   $id: 'sharedAddress',
  3.   type: 'object',
  4.   required: ['line1', 'country', 'city', 'zipcode'],
  5.   properties: {
  6.     line1: { type: 'string' },
  7.     line2: { type: 'string' },
  8.     country: { type: 'string' },
  9.     city: { type: 'string' },
  10.     zipcode: { type: 'string' }
  11.   }
  12. }
  13. fastify.addSchema(sharedAddressSchema)
  15. const bodyJsonSchema = {
  16.   type: 'object',
  17.   properties: {
  18.     vacation: 'sharedAddress#'
  19.   }
  20. }
  22. const schema = { body: bodyJsonSchema }
  24. fastify.post('/the/url', { schema }, handler)

NB: you can mix up the $ref-way and the replace-way when using fastify.addSchema.