is-my-json-valid

Temporary fork from is-my-json-valid to have my fixes in

A JSONSchema validator that uses code generation to be extremely fast

npm install is-my-json-valid

It passes the entire JSONSchema v4 test suite except for remoteRefs and maxLength/minLength when using unicode surrogate pairs.

Usage

Simply pass a schema to compile it

1var validator = require('is-my-json-valid')
2
3var validate = validator({
4  required: true,
5  type: 'object',
6  properties: {
7    hello: {
8      required: true,
9      type: 'string'
10    }
11  }
12})
13
14console.log('should be valid', validate({hello: 'world'}))
15console.log('should not be valid', validate({}))
16
17// get the last list of errors by checking validate.errors
18// the following will print [{field: 'data.hello', message: 'is required'}]
19console.log(validate.errors)

You can also pass the schema as a string

1var validate = validator('{"type": ... }')

Optionally you can use the require submodule to load a schema from __dirname

1var validator = require('is-my-json-valid/require')
2var validate = validator('my-schema.json')

Custom formats

is-my-json-valid supports the formats specified in JSON schema v4 (such as date-time). If you want to add your own custom formats pass them as the formats options to the validator

1var validate = validator({
2  type: 'string',
3  required: true,
4  format: 'only-a'
5}, {
6  formats: {
7    'only-a': /^a+$/
8  }
9})
10
11console.log(validate('aa')) // true
12console.log(validate('ab')) // false

External schemas

You can pass in external schemas that you reference using the $ref attribute as the schemas option

1var ext = {
2  required: true,
3  type: 'string'
4}
5
6var schema = {
7  $ref: '#ext' // references another schema called ext
8}
9
10// pass the external schemas as an option
11var validate = validator(schema, {schemas: {ext: ext}})
12
13validate('hello') // returns true
14validate(42) // return false

Filtering away additional properties

is-my-json-valid supports filtering away properties not in the schema

1var filter = validator.filter({
2  required: true,
3  type: 'object',
4  properties: {
5    hello: {type: 'string', required: true}
6  },
7  additionalProperties: false
8})
9
10var doc = {hello: 'world', notInSchema: true}
11console.log(filter(doc)) // {hello: 'world'}

Verbose mode shows more information about the source of the error

When the verbose options is set to true, is-my-json-valid also outputs:

• value: The data value that caused the error
• schemaPath: an array of keys indicating which sub-schema failed

1var schema = {
2  required: true,
3  type: 'object',
4  properties: {
5    hello: {
6      required: true,
7      type: 'string'
8    }
9  }
10}
11var validate = validator(schema, {
12  verbose: true
13})
14
15validate({hello: 100});
16console.log(validate.errors)
17// [ { field: 'data.hello',
18//     message: 'is the wrong type',
19//     value: 100,
20//     type: 'string',
21//     schemaPath: [ 'properties', 'hello' ] } ]

Many popular libraries make it easy to retrieve the failing rule with the schemaPath:

var schemaPath = validate.errors[0].schemaPath
var R = require('ramda')

console.log( 'All evaluate to the same thing: ', R.equals(
  schema.properties.hello,
  { required: true, type: 'string' },
  R.path(schemaPath, schema),
  require('lodash').get(schema, schemaPath),
  require('jsonpointer').get(schema, [""].concat(schemaPath))
))
// All evaluate to the same thing: true

Greedy mode tries to validate as much as possible

By default is-my-json-valid bails on first validation error but when greedy is set to true it tries to validate as much as possible:

1var validate = validator({
2  type: 'object',
3  properties: {
4    x: {
5      type: 'number'
6    }
7  },
8  required: ['x', 'y']
9}, {
10  greedy: true
11});
12
13validate({x: 'string'});
14console.log(validate.errors) // [{field: 'data.y', message: 'is required'},
15                             //  {field: 'data.x', message: 'is the wrong type'}]

Error messages

Here is a list of possible message values for errors:

• is required
• is the wrong type
• has additional items
• must be FORMAT format (FORMAT is the format property from the schema)
• must be unique
• must be an enum value
• dependencies not set
• has additional properties
• referenced schema does not match
• negative schema matches
• pattern mismatch
• no schemas match
• no (or more than one) schemas match
• has a remainder
• has more properties than allowed
• has less properties than allowed
• has more items than allowed
• has less items than allowed
• has longer length than allowed
• has less length than allowed
• is less than minimum
• is more than maximum

Performance

is-my-json-valid uses code generation to turn your JSON schema into basic javascript code that is easily optimizeable by v8.

At the time of writing, is-my-json-valid is the fastest validator when running

• json-schema-benchmark
• cosmicreals.com benchmark
• jsck benchmark
• themis benchmark
• z-schema benchmark

If you know any other relevant benchmarks open a PR and I'll add them.

License

MIT