Package Exports

@middy/validator

This package does not declare an exports field, so the exports above have been automatically detected and optimized by JSPM instead. If any package subpath is missing, it is recommended to post an issue to the original package (@middy/validator) to support the "exports" field. If that is not possible, create a JSPM override to customize the exports field for this package.

Readme

Middy validator middleware

Validator middleware for the middy framework, the stylish Node.js middleware engine for AWS Lambda

This middleware automatically validates incoming events and outgoing responses against custom schemas defined with the JSON schema syntax.

If an incoming event fails validation a BadRequest error is raised. If an outgoing response fails validation a InternalServerError error is raised.

This middleware can be used in combination with httpErrorHandler to automatically return the right response to the user.

It can also be used in combination with httpcontentnegotiation to load localised translations for the error messages (based on the currently requested language). This feature uses internally ajv-i18n module, so reference to this module for options and more advanced use cases. By default the language used will be English (en), but you can redefine the default language by passing it in the ajvOptions options with the key defaultLanguage and specifying as value one of the supported locales.

Also, this middleware accepts an object with plugins to be applied to customize the internal ajv instance. Out-of-the-box, ajv-i18n, ajv-errors and ajv-keywords are being used.

Install

To install this middleware you can use NPM:

npm install --save @middy/validator

Options

inputSchema (object) (optional): The JSON schema object that will be used to validate the input (handler.event) of the Lambda handler.
outputSchema (object) (optional): The JSON schema object that will be used to validate the output (handler.response) of the Lambda handler.
ajvOptions (object) (optional): Options to pass to ajv class constructor. Defaults are {v5: true, coerceTypes: 'array', $data: true, allErrors: true, useDefaults: true, defaultLanguage: 'en', jsonPointers: true}. Note that jsonPointers is needed by ajv-errors.
ajvPlugins (object) (optional): Plugin names (without ajv- prefix) as key and its options for the value, to apply to ajv once instantiated. You can pass in {} to not include the modules. Defaults are {keywords: null, errors: null, i18n: null}. Note that for no options null / {} is used as value.

Sample usage

Example for input validation:

const middy = require('@middy/core')
const validator = require('@middy/validator')

const handler = middy((event, context, cb) => {
  cb(null, {})
})

const schema = {
  required: ['body', 'foo'],
  properties: {
    // this will pass validation
    body: {
      type: 'string'
    },
    // this won't as it won't be in the event
    foo: {
      type: 'string'
    }
  }
}

handler.use(validator({
  inputSchema: schema
}))

// invokes the handler, note that property foo is missing
const event = {
  body: JSON.stringify({something: 'somethingelse'})
}
handler(event, {}, (err, res) => {
  expect(err.message).toEqual('Event object failed validation')
})

Example for output validation:

const middy = require('@middy/core')
const validator = require('@middy/validator')

const handler = middy((event, context, cb) => {
  cb(null, {})
})

const schema = {
  required: ['body', 'statusCode'],
  properties: {
    body: {
      type: 'object'
    },
    statusCode: {
      type: 'number'
    }
  }
}

handler.use(validator({outputSchema: schema}))

handler({}, {}, (err, response) => {
  expect(err).not.toBe(null)
  expect(err.message).toEqual('Response object failed validation')
  expect(response).not.toBe(null) // it doesn't destroy the response so it can be used by other middlewares
})

Example for plugins applied with ajv-bsontype:

const middy = require('@middy/core')
const validator = require('@middy/validator')

const handler = middy((event, context, cb) => {
  cb(null, {})
})

const schema = {
  required: ["name", "gpa"],
  properties: {
    name: {
      bsonType: "string"
    },
    gpa: {
      bsonType: [ "double" ]
    }
  }
}

handler.use(validator({ inputSchema: schema, ajvPlugins: { bsontype: null } }))

// invokes the handler, note that property foo is string and should be integer
const event = {
  body: JSON.stringify({ name: "Leo", gpa: "4" })
}
handler(event, {}, (err, response) => {
  expect(err.details[0].message).toEqual('should be double got 4')
})

Middy documentation and examples

For more documentation and examples, refers to the main Middy monorepo on GitHub or Middy official website.

Contributing

Everyone is very welcome to contribute to this repository. Feel free to raise issues or to submit Pull Requests.

License