Transcordia/z-schema

JSON Schema validator written in JavaScript for NodeJS and Browsers

#z-schema validator

##Version 3.0 has been rewritten from scratch.

• it runs in the browser now, run tests yourself here
• it is much faster than the 2.x, see below

#Topics

• Usage
• Features
• Options
• Benchmarks
• Contributors

#Usage

Validator will try to perform sync validation when possible for speed, but supports async callbacks when they are necessary.

##NodeJS:

var ZSchema = require("z-schema");
var options = ... // see below for possible option values
var validator = new ZSchema(options);

##Sync mode:

var valid = validator.validate(json, schema);
var err = validator.getLastErrors();
...

##Async mode:

validator.validate(json, schema, function (err, valid) {
    ...
});

##Browser:

<script type="text/javascript" src="../dist/ZSchema-browser-min.js"></script>
<script type="text/javascript">
    var ZSchema = require("ZSchema");
	var validator = new ZSchema();
	var valid = validator.validate("string", { "type": "string" });
	console.log(valid);
</script>

##Remote references and schemas:

In case you have some remote references in your schemas, you have to download those schemas before using validator. Otherwise you'll get UNRESOLVABLE_REFERENCE error when trying to compile a schema.

var validator = new ZSchema();
var json = {};
var schema = { "$ref": "http://json-schema.org/draft-04/schema#" };

var valid = validator.validate(json, schema);
var errors = validator.getLastErrors();
// valid === false
// errors.length === 1
// errors[0].code === "UNRESOLVABLE_REFERENCE"

var requiredUrl = "http://json-schema.org/draft-04/schema";
request(requiredUrl, function (error, response, body) {

    validator.setRemoteReference(requiredUrl, JSON.parse(body));

    var valid = validator.validate(json, schema);
    var errors = validator.getLastErrors();
    // valid === true
    // errors === undefined

}

#Features

• Compile arrays of schemas and use references between them
• Register a custom format
• Automatic downloading of remote schemas
• Prefill default values to object using format
• Define a custom timeout for all async operations
• Disallow validation of empty arrays as arrays
• Disallow validation of empty strings as strings
• Disallow schemas that don't have a type specified
• Disallow schemas that contain unrecognized keywords and are not validated by parent schemas
• Assume additionalItems/additionalProperties are defined in schemas as false
• Force additionalItems/additionalProperties to be defined in schemas
• Force items to be defined in array type schemas
• Force maxLength to be defined in string type schemas
• Force properties or patternProperties to be defined in object type schemas
• Ignore remote references to schemas that are not cached or resolvable
• Only allow strictly absolute URIs to be used in schemas
• Turn on z-schema strict mode

##Compile arrays of schemas and use references between them

You can use validator to compile an array of schemas that have references between them and then validate against one of those schemas:

var schemas = [
    {
        id: "personDetails",
        type: "object",
        properties: {
            firstName: { type: "string" },
            lastName: { type: "string" }
        },
        required: ["firstName", "lastName"]
    },
    {
        id: "addressDetails",
        type: "object",
        properties: {
            street: { type: "string" },
            city: { type: "string" }
        },
        required: ["street", "city"]
    },
    {
        id: "personWithAddress",
        allOf: [
            { $ref: "personDetails" },
            { $ref: "addressDetails" }
        ]
    }
];

var data = {
    firstName: "Martin",
    lastName: "Zagora",
    street: "George St",
    city: "Sydney"
};

var validator = new ZSchema();

// compile & validate schemas first, z-schema will automatically handle array
var allSchemasValid = validator.validateSchema(schemas);
// allSchemasValid === true

// now validate our data against the last schema
var valid = validator(data, schemas[2]);
// valid === true

##Register a custom format

You can register any format of your own, sync validator function should always respond with boolean:

ZSchema.registerFormat("xstring", function (str) {
    return str === "xxx";
});

Async format validators are also supported, they should accept two arguments, value and a callback to which they need to respond:

ZSchema.registerFormat("xstring", function (str, callback) {
    setTimeout(function () {
        callback(str === "xxx");
    }, 1);
});

##Automatic downloading of remote schemas

Automatic downloading of remote schemas was removed from version 3.x but is still possible with a bit of extra code, see this test for more information on this.

##Prefill default values to object using format

Using format, you can pre-fill values of your choosing into the objects like this:

ZSchema.registerFormat("fillHello", function (obj) {
    obj.hello = "world";
    return true;
});

var data = {};

var schema = {
    "type": "object",
    "format": "fillHello"
};

validator.validate(data, schema);
// data.hello === "world"

#Options

##asyncTimeout

Defines a time limit, which should be used when waiting for async tasks like async format validators to perform their validation, before the validation fails with an ASYNC_TIMEOUT error.

var validator = new ZSchema({
    asyncTimeout: 2000
});

##noEmptyArrays

When true, validator will assume that minimum count of items in any array is 1, except when minItems: 0 is explicitly defined.

var validator = new ZSchema({
    noEmptyArrays: true
});

##noEmptyStrings

When true, validator will assume that minimum length of any string to pass type string validation is 1, except when minLength: 0 is explicitly defined.

var validator = new ZSchema({
    noEmptyStrings: true
});

##noTypeless

When true, validator will fail validation for schemas that don't specify a type of object that they expect.

var validator = new ZSchema({
    noTypeless: true
});

##noExtraKeywords

When true, validator will fail for schemas that use keywords not defined in JSON Schema specification and doesn't provide a parent schema in $schema property to validate the schema.

var validator = new ZSchema({
    noExtraKeywords: true
});

##assumeAdditional

When true, validator assumes that additionalItems/additionalProperties are defined as false so you don't have to manually fix all your schemas.

var validator = new ZSchema({
    assumeAdditional: true
});

##forceAdditional

When true, validator doesn't validate schemas where additionalItems/additionalProperties should be defined to either true or false.

var validator = new ZSchema({
    forceAdditional: true
});

##forceItems

When true, validator doesn't validate schemas where items are not defined for array type schemas. This is to avoid passing anything through an array definition.

var validator = new ZSchema({
    forceItems: true
});

##forceMaxLength

When true, validator doesn't validate schemas where maxLength is not defined for string type schemas. This is to avoid passing extremly large strings which application doesn't expect to handle.

var validator = new ZSchema({
    forceMaxLength: true
});

##forceProperties

When true, validator doesn't validate schemas where properties or patternProperties is not defined for object type schemas. This is to avoid having objects with unexpected properties in application.

var validator = new ZSchema({
    forceProperties: true
});

##ignoreUnresolvableReferences

When true, validator doesn't end with error when a remote reference is unreachable. This setting is not recommended in production outside of testing.

var validator = new ZSchema({
    ignoreUnresolvableReferences: true
});

##strictUris

When true, all strings of format uri must be an absolute URIs and not only URI references. See more details in this issue.

var validator = new ZSchema({
    strictUris: true
});

##strictMode

Strict mode of z-schema is currently equal to the following:

var validator = new ZSchema({
    strictMode: true
});

##reportPathAsArray

Report error paths as an array of path segments instead of a string:

var validator = new ZSchema({
    reportPathAsArray: true
});

if (this.options.strictMode === true) {
    this.options.forceAdditional  = true;
    this.options.forceItems       = true;
    this.options.forceMaxLength   = true;
    this.options.forceProperties  = true;
    this.options.noExtraKeywords  = true;
    this.options.noTypeless       = true;
    this.options.noEmptyStrings   = true;
    this.options.noEmptyArrays    = true;
}

#Benchmarks

So how does it compare to version 2.x and others?

NOTE: these tests are purely orientational, they don't consider extra features any of the validator may support and implement

rawgithub.com/zaggino/z-schema/master/benchmark/results.html

#Contributors

Thanks for contributing to:

• Jeremy Whitlock
• Oleksiy Krivoshey

and to everyone submitting issues on GitHub