CODEWITHSUNDEEP
jsonschemafastify
Stephen Fricke
Stephen Fricke

Reputation: 193

Validate request body separately from request as a whole

I have a question for validating a PUT request. The body of the request is an array of objects. I want the request to succeed if the body contains an array of at least length one, but I also need to do a separate validation on each object in the array and pass that back in the response. So my put body would be:

[1, 2, {id: "thirdObject"}]

The response should be 200 even though the first two items are not even objects. The request just needs to succeed if an array of length 1 is passed in the body. The response needs to be something like:

[{id: firstObject, status: 400, error: should be object}, {id: secondObject, status: 400, error: should be object}, { id: thirdObject, status: 204 }]

Currently I am validating the body as such with fluent schema:

body: S.array().items(myObjectSchema) .minItems(1)

Which will result in a 400 if any of the items in the body don’t match the myObjectSchema. Was wondering if you have any idea how to achieve this?

Upvotes: 0

Views: 1833

Answers (2)

Manuel Spigolon
Manuel Spigolon

Reputation: 12900

The validation doesn't tell you if a schema is successful (eg { id: thirdObject, status: 204 }), so you need to manage it by yourself.

To do that, you need to create an error handler to read the validation error and merge with the request body:

const fastify = require('fastify')()
const S = require('fluent-schema')

fastify.put('/', {
  handler: () => { /** this will never executed if the schema validation fail */ },
  schema: {
    body: S.array().items(S.object()).minItems(1)
  }
})

const errorHandler = (error, request, reply) => {
  const { validation, validationContext } = error

  // check if we have a validation error
  if (validation) {
    // here the validation error
    console.log(validation)

    // here the body
    console.log(request.body)

    reply.send(validation)
  } else {
    reply.send(error)
  }
}

fastify.setErrorHandler(errorHandler)

fastify.inject({
  method: 'PUT',
  url: '/',
  payload: [1, 2, { id: 'thirdObject' }]
}, (_, res) => {
  console.log(res.json())
})

This will log:

[
  {
    keyword: 'type',
    dataPath: '[0]',
    schemaPath: '#/items/type',
    params: { type: 'object' },
    message: 'should be object'
  },
  {
    keyword: 'type',
    dataPath: '[1]',
    schemaPath: '#/items/type',
    params: { type: 'object' },
    message: 'should be object'
  }
]

[ 1, 2, { id: 'thirdObject' } ]

As you can see, thanks to validation[].dataPath you are able to understand which elements of the body array is not valid and merge the data to return your info.

Consider that the handler will be not executed in this scenario. If you need to execute it regardless the validation, you should do the validation job in a preHandler hook and avoid the default schema validation checks (since it is blocking)

edit

const fastify = require('fastify')()
const S = require('fluent-schema')

let bodyValidator
fastify.decorateRequest('hasError', function () {
  if (!bodyValidator) {
    bodyValidator = fastify.schemaCompiler(S.array().items(S.object()).minItems(1).valueOf())
  }

  const valid = bodyValidator(this.body)
  if (!valid) {
    return bodyValidator.errors
  }
  return true
})

fastify.addHook('preHandler', (request, reply, done) => {
  const errors = request.hasError()
  if (errors) {
    console.log(errors)
    // show the same errors as before
    // you can merge here or set request.errors = errors to let the handler read them
    reply.send('here merge errors and request.body')
    return
  }

  done() // needed to continue if you don't reply.send
})

fastify.put('/', { schema: { body: S.array() } }, (req, reply) => {
  console.log('handler')
  reply.send('handler')
})

fastify.inject({
  method: 'PUT',
  url: '/',
  payload: [1, 2, { id: 'thirdObject' }]
}, (_, res) => {
  console.log(res.json())
})

Upvotes: 1

Ether
Ether

Reputation: 53986

I don't know the schema syntax you are using, but using draft 7 of the JSON Schema (https://json-schema.org/specification-links.html, and see also https://json-schema.org/understanding-json-schema for some reference material), you can do:

{
  "type": "array",
  "minItems": 1
}

If you want to ensure that at least one, but not necessarily all items match your object type, then add the "contains" keyword:

{
  ...,
  "contains": ... reference to your object schema here
}

Upvotes: 0

Related Questions