Is it possible for the request.validateInput (and other such funcs) add the errors property by analogy as ajv does?

[budarin]

Prerequisites

• I have written a descriptive issue title
• I have searched existing issues to ensure the feature has not already been requested

🚀 Feature Proposal

I suggest adding to request.ValidateInput, as well as the functions returned by compilerValidationSchema and getValidationFunction, the errors property after performing the validation, as does ajv:

const validate = ajv.compile({
  type: 'object', 
  properties: { 
    foo: { 
      type: 'string' 
    } 
  } 
})

validate({ foo: 1 }) // false
validate.errors  // validation errors

Motivation

It is important for us to receive not only the result of the check, but also errors of data inconsistency with the scheme

Example

for getValidationFunction:

const validate = request.getValidationFunction({
  type: 'object', 
  properties: { 
    foo: { 
      type: 'string' 
    } 
  } 
})

validate.errors // undefined
validate({ foo: 0.5 }) // false
validate.errors // validation errors 

validate({ foo: 'bar' }) // true
validate.errors // undefined

for compileValidationSchema:

const validate = request.compileValidationSchema({
  type: 'object', 
  properties: { 
    foo: { 
      type: 'string' 
    } 
  } 
})

validate.errors // undefined
validate({ hello: 'world' }) // false
validate.errors // validation errors

for request.validateInput:

request.validateInput.errors // undefined
request.validateInput({ foo: 'bar'}, {  
  type: 'object', 
  properties: { 
    foo: { 
      type: 'string' 
    } 
  } 
}) // true
request.validateInput.errors // undefined

request.validateInput({ hello: 'world'}, 'query') // false
request.validateInput.errors //validation errors

[metcoder95]

Hey! That should be already possible as the new APIs don't mess with the Ajv or any other validation function compiled, meaning that you can still access such errors and result properties.

Here's an example:

const fastify = require('fastify')

const app = fastify({ logger: true })

app.post(
  '/',
  {
    schema: {
      body: {
        type: 'object',
        required: ['name'],
        properties: {
          name: { type: 'string' }
        }
      }
    }
  },
  (request, reply) => {
    const customCompiled = request.compileValidationSchema({
      type: 'object',
      required: ['something'],
      properties: {
        name: { type: 'string' },
        something: { type: 'string' }
      }
    })
    const routeValidation = request.getValidationFunction('body')

    const result = routeValidation({ something: 'something' })
    const customResult = customCompiled({ name: 'John' })

    // console.log(routeValidation)
    console.log(routeValidation.errors)
    console.log(customCompiled.errors)

    reply.send({ hello: 'world' })
  }
)

app.inject({
    method: 'POST',
    url: '/',
    payload: {
        name: 'John'
    }
}).then(() => console.log('done'))

and then prints:

[budarin]

To be honest, I haven't tried with compilerValidationSchema and getValidationFunction - I checked with request.ValidateInput and in this case there are definitely no errors, which is why I assumed that other methods have the same situation

[budarin]

the description of the types of these functions also reflects the fact that functions do not have this property

  getValidationFunction(httpPart: HTTPRequestPart): (input: any) => boolean
  getValidationFunction(schema: {[key: string]: any}): (input: any) => boolean
  compileValidationSchema(schema: {[key: string]: any}, httpPart?: HTTPRequestPart): (input: any) => boolean
  validateInput(input: any, schema: {[key: string]: any}, httpPart?: HTTPRequestPart): boolean
  validateInput(input: any, httpPart?: HTTPRequestPart): boolean

[climba03003]

validateInput shouldn't have the errors property and never should be there.
It will mess up with multiple usage of same function.

If the problem is only incorrect typings. Would you like to send a PR to address the issue?

[budarin]

here is the PR #4283