Security News
Cloudflare Adds Security.txt Setup Wizard
Cloudflare has launched a setup wizard allowing users to easily create and manage a security.txt file for vulnerability disclosure on their websites.
jsonschema
Advanced tools
The jsonschema npm package is a JSON Schema validator that can validate JavaScript objects using JSON Schemas. It is commonly used to ensure that data conforms to a predefined schema, and it can be used to validate data at runtime, as part of a testing suite, or during development to ensure data integrity.
Validation
This feature allows you to validate a JavaScript object against a JSON Schema. The code sample creates a new Validator instance, defines a schema with required properties, and validates a sample data object against this schema. It outputs an empty array if the data is valid or a list of errors if it is invalid.
{"const Validator = require('jsonschema').Validator; const v = new Validator(); const schema = { 'type': 'object', 'properties': { 'name': { 'type': 'string' }, 'age': { 'type': 'integer', 'minimum': 0 } }, 'required': ['name', 'age'] }; const sampleData = { 'name': 'John Doe', 'age': 25 }; const validation = v.validate(sampleData, schema); console.log(validation.errors); // [] if valid, or list of errors if invalid."}
Custom Formats
This feature allows you to define custom formats for validation. The code sample shows how to add a custom format to the Validator instance and then use it in a schema to validate data.
{"const Validator = require('jsonschema').Validator; const v = new Validator(); v.customFormats.myFormat = function(input) { return input === 'specialValue'; }; const schema = { 'type': 'string', 'format': 'myFormat' }; const sampleData = 'specialValue'; const validation = v.validate(sampleData, schema); console.log(validation.valid); // true if valid, or false if invalid."}
Asynchronous Validation
This feature allows for asynchronous validation, which can be useful when dealing with complex validations that may require I/O operations. The code sample demonstrates how to perform validation asynchronously using a callback function.
{"const Validator = require('jsonschema').Validator; const v = new Validator(); const schema = { 'type': 'object', 'properties': { 'name': { 'type': 'string' }, 'age': { 'type': 'integer', 'minimum': 0 } }, 'required': ['name', 'age'] }; const sampleData = { 'name': 'John Doe', 'age': 25 }; v.validate(sampleData, schema, function(errors, valid) { console.log(valid); // true if valid, or false if invalid });"}
Ajv is another popular JSON Schema validator that is known for its performance and being compliant with the JSON Schema specification. It supports all JSON Schema versions and includes features like compiling schemas for faster validation, adding custom keywords, and more. Compared to jsonschema, Ajv may offer better performance and more features.
Tiny Validator (tv4) is a lightweight JSON Schema validator. It supports draft v4 of the JSON Schema specification and is designed to be simple and easy to use. While it may not have as many features as jsonschema, it is a good choice for projects that require a minimalistic approach.
Joi is a powerful schema description language and data validator for JavaScript. Unlike jsonschema, which uses JSON Schema format, Joi allows you to create validation schemas using a fluent API. It is often used for validating data in REST APIs and can be more intuitive to use for those who prefer a code-based schema definition over JSON.
JSON schema validator, which is designed to be fast and simple to use. The latest IETF published draft is v6, this library is mostly v4 compatible.
Please fork the repository, make the changes in your fork and include tests. Once you're done making changes, send in a pull request.
Please include a test which shows why the code fails.
Simple object validation using JSON schemas.
var Validator = require('jsonschema').Validator;
var v = new Validator();
var instance = 4;
var schema = {"type": "number"};
console.log(v.validate(instance, schema));
var validate = require('jsonschema').validate;
console.log(validate(4, {"type": "number"}));
var Validator = require('jsonschema').Validator;
var v = new Validator();
// Address, to be embedded on Person
var addressSchema = {
"id": "/SimpleAddress",
"type": "object",
"properties": {
"lines": {
"type": "array",
"items": {"type": "string"}
},
"zip": {"type": "string"},
"city": {"type": "string"},
"country": {"type": "string"}
},
"required": ["country"]
};
// Person
var schema = {
"id": "/SimplePerson",
"type": "object",
"properties": {
"name": {"type": "string"},
"address": {"$ref": "/SimpleAddress"},
"votes": {"type": "integer", "minimum": 1}
}
};
var p = {
"name": "Barack Obama",
"address": {
"lines": [ "1600 Pennsylvania Avenue Northwest" ],
"zip": "DC 20500",
"city": "Washington",
"country": "USA"
},
"votes": "lots"
};
v.addSchema(addressSchema, '/SimpleAddress');
console.log(v.validate(p, schema));
For a comprehensive, annotated example illustrating all possible validation options, see examples/all.js
All schema definitions are supported, $schema is ignored.
All types are supported
You may disable format validation by providing disableFormat: true
to the validator
options.
All formats are supported, phone numbers are expected to follow the E.123 standard.
You may add your own custom format functions. Format functions accept the input
being validated and return a boolean value. If the returned value is true
, then
validation succeeds. If the returned value is false
, then validation fails.
Validator.prototype.customFormats
do not affect previously instantiated
Validators. This is to prevent validator instances from being altered once created.
It is conceivable that multiple validators may be created to handle multiple schemas
with different formats in a program.validator.customFormats
affect only that Validator instance.Here is an example that uses custom formats:
Validator.prototype.customFormats.myFormat = function(input) {
return input === 'myFormat';
};
var validator = new Validator();
validator.validate('myFormat', {type: 'string', format: 'myFormat'}).valid; // true
validator.validate('foo', {type: 'string', format: 'myFormat'}).valid; // false
The first error found will be thrown as an Error
object if options.throwError
is true
. Otherwise all results will be appended to the result.errors
array which also contains the success flag result.valid
.
When oneOf
or anyOf
validations fail, errors that caused any of the sub-schemas referenced therein to fail are not reported, unless options.nestedErrors
is truthy. This option may be useful when troubleshooting validation errors in complex schemas.
Specify your own JSON Schema properties with the validator.attributes property:
validator.attributes.contains = function validateContains(instance, schema, options, ctx) {
if(typeof instance!='string') return;
if(typeof schema.contains!='string') throw new jsonschema.SchemaError('"contains" expects a string', schema);
if(instance.indexOf(schema.contains)<0){
return 'does not contain the string ' + JSON.stringify(schema.contains);
}
}
var result = validator.validate("i am an instance", { type:"string", contains: "i am" });
// result.valid === true;
The instance passes validation if the function returns nothing. A single validation error is produced
if the fuction returns a string. Any number of errors (maybe none at all) may be returned by passing a
ValidatorResult
object, which may be used like so:
var result = new ValidatorResult(instance, schema, options, ctx);
while(someErrorCondition()){
result.addError('fails some validation test');
}
return result;
Sometimes you may want to download schemas from remote sources, like a database, or over HTTP. When importing a schema,
unknown references are inserted into the validator.unresolvedRefs
Array. Asynchronously shift elements off this array and import
them:
var Validator = require('jsonschema').Validator;
var v = new Validator();
v.addSchema(initialSchema);
function importNextSchema(){
var nextSchema = v.unresolvedRefs.shift();
if(!nextSchema){ done(); return; }
databaseGet(nextSchema, function(schema){
v.addSchema(schema);
importNextSchema();
});
}
importNextSchema();
Uses JSON Schema Test Suite as well as our own tests. You'll need to update and init the git submodules:
git submodule update --init
npm test
This library would not be possible without the valuable contributions by:
... and many others!
jsonschema is licensed under MIT license.
Copyright (C) 2012-2015 Tom de Grunt <tom@degrunt.nl>
Permission is hereby granted, free of charge, to any person obtaining a copy of
this software and associated documentation files (the "Software"), to deal in
the Software without restriction, including without limitation the rights to
use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
of the Software, and to permit persons to whom the Software is furnished to do
so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
FAQs
A fast and easy to use JSON Schema validator
The npm package jsonschema receives a total of 2,643,718 weekly downloads. As such, jsonschema popularity was classified as popular.
We found that jsonschema demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 2 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Cloudflare has launched a setup wizard allowing users to easily create and manage a security.txt file for vulnerability disclosure on their websites.
Security News
The Socket Research team breaks down a malicious npm package targeting the legitimate DOMPurify library. It uses obfuscated code to hide that it is exfiltrating browser and crypto wallet data.
Security News
ENISA’s 2024 report highlights the EU’s top cybersecurity threats, including rising DDoS attacks, ransomware, supply chain vulnerabilities, and weaponized AI.