Product
Introducing Java Support in Socket
We're excited to announce that Socket now supports the Java programming language.
The tv4 npm package is a JSON Schema validator. It allows you to validate JSON data against a JSON Schema to ensure that the data structure conforms to a specified format. This is particularly useful for data validation, configuration management, and ensuring data integrity across systems.
Basic Validation
This feature allows you to validate a simple piece of data against a schema. In this example, a string is validated against a schema that requires a string type, resulting in a successful validation.
{"var tv4 = require('tv4');\nvar schema = {\"type\": \"string\"};\nvar result = tv4.validateResult('I am a string', schema);\nconsole.log(result.valid); // true"}
Complex Schema Validation
This feature demonstrates validating a more complex JSON object against a detailed schema. The schema specifies that the object must have a 'name' property of type string and an 'age' property of type integer with a minimum value of 0. The validation passes as the data meets these criteria.
{"var tv4 = require('tv4');\nvar schema = {\"type\": \"object\", \"properties\": {\"name\": {\"type\": \"string\"}, \"age\": {\"type\": \"integer\", \"minimum\": 0}}};\nvar data = {\"name\": \"John Doe\", \"age\": 30};\nvar result = tv4.validateResult(data, schema);\nconsole.log(result.valid); // true"}
Validation with Error Reporting
This feature showcases how tv4 can report errors when validation fails. In this example, attempting to validate a string against a schema that expects a number results in a validation error, which is then logged.
{"var tv4 = require('tv4');\nvar schema = {\"type\": \"number\"};\nvar result = tv4.validateResult('not a number', schema);\nif (!result.valid) {\n console.error(result.error);\n}"}
Ajv is another popular JSON Schema validator that is known for its performance and support for the latest JSON Schema standards. Compared to tv4, Ajv offers better performance and more comprehensive support for JSON Schema Draft 6 and Draft 7 features.
Joi is a powerful schema description language and data validator for JavaScript. Unlike tv4, which focuses on JSON Schema, Joi provides a fluent API for describing data schemas and includes built-in types and validation rules, making it more intuitive for some developers.
The jsonschema package is another validator for JSON Schema. It aims to provide a simple and straightforward implementation of JSON Schema validation. While similar in functionality to tv4, jsonschema may have differences in API design and error reporting.
Use json-schema draft v4 to validate simple values and complex objects using a rich validation vocabulary (examples).
There is support for $ref
with JSON Pointer fragment paths (other-schema.json#/properties/myKey
).
var valid = tv4.validate(data, schema);
If validation returns false
, then an explanation of why validation failed can be found in tv4.error
.
The error object will look something like:
{
"code": 0,
"message": "Invalid type: string",
"dataPath": "/intKey",
"schemaPath": "/properties/intKey/type"
}
The "code"
property will refer to one of the values in tv4.errorCodes
- in this case, tv4.errorCodes.INVALID_TYPE
.
To enable external schema to be referenced, you use:
tv4.addSchema(url, schema);
If schemas are referenced ($ref
) but not known, then validation will return true
and the missing schema(s) will be listed in tv4.missing
. For more info see the API documentation below.
Storing the error and missing schemas does not work well in multi-threaded environments, so there is an alternative syntax:
var result = tv4.validateResult(data, schema);
The result will look something like:
{
"valid": false,
"error": {...},
"missing": [...]
}
Normally, tv4
stops when it encounters the first validation error. However, you can collect an array of validation errors using:
var result = tv4.validateMultiple(data, schema);
The result will look something like:
{
"valid": false,
"errors": [
{...},
...
],
"missing": [...]
}
Support for asynchronous validation (where missing schemas are fetched) can be added by including an extra JavaScript file. Currently, the only version requires jQuery (tv4.async-jquery.js
), but the code is very short and should be fairly easy to modify for other libraries (such as MooTools).
Usage:
tv4.validate(data, schema, function (isValid, validationError) { ... });
validationError
is simply taken from tv4.error
.
While they don't occur in proper JSON, JavaScript does support self-referencing objects. Any of the above calls support an optional third argument: checkRecursive
. If true, tv4 will handle self-referencing objects properly - this slows down validation slightly, but that's better than a hanging script.
Consider this data, notice how both a
and b
refer to each other:
var a = {};
var b = { a: a };
a.b = b;
var aSchema = { properties: { b: { $ref: 'bSchema' }}};
var bSchema = { properties: { a: { $ref: 'aSchema' }}};
tv4.addSchema('aSchema', aSchema);
tv4.addSchema('bSchema', bSchema);
If the checkRecursive
argument were missing, this would throw a "too much recursion" error.
To enable support for this, pass true
as additional argument to any of the regular validation methods:
tv4.validate(a, aSchema, true);
tv4.validateResult(data, aSchema, true);
tv4.validateMultiple(data, aSchema, true);
banUnknownProperties
flagSometimes, it is desirable to flag all unknown properties as an error. This is especially useful during development, to catch typos and the like, even when extra custom-defined properties are allowed.
As such, tv4 implements "ban unknown properties" mode, enabled by a fourth-argument flag:
tv4.validate(data, schema, checkRecursive, true);
tv4.validateResult(data, schema, checkRecursive, true);
tv4.validateMultiple(data, schema, checkRecursive, true);
There are additional api commands available for more complex use-cases:
Pre-register a schema for reference by other schema and synchronous validation.
tv4.addSchema('http://example.com/schema', { ... });
uri
the uri to identify this schema.schema
the schema object.Schemas that have their id
property set can be added directly.
tv4.addSchema({ ... });
Return a schema from the cache.
uri
the uri of the schema (may contain a #
fragment)var schema = tv4.getSchema('http://example.com/schema');
Return a shallow copy of the schema cache, mapping schema document URIs to schema objects.
var map = tv4.getSchemaMap();
var schema = map[uri];
Return an Array with known schema document URIs.
filter
optional RegExp to filter URIsvar arr = tv4.getSchemaUris();
// optional filter using a RegExp
var arr = tv4.getSchemaUris(/^https?://example.com/);
Return an Array with schema document URIs that are used as $ref
in known schemas but which currently have no associated schema data.
Use this in combination with tv4.addSchema(uri, schema)
to preload the cache for complete synchronous validation with.
filter
optional RegExp to filter URIsvar arr = tv4.getMissingUris();
// optional filter using a RegExp
var arr = tv4.getMissingUris(/^https?://example.com/);
Drop all known schema document URIs from the cache.
tv4.dropSchemas();
Return a new tv4 instance with no shared state.
var otherTV4 = tv4.freshApi();
Manually reset validation status from the simple tv4.validate(data, schema)
. Although tv4 will self reset on each validation there are some implementation scenarios where this is useful.
tv4.reset();
Sets a custom error reporter. This is a function that accepts three arguments, and returns an error message (string):
tv4.setErrorReporter(function (error, data, schema) {
return "Error code: " + error.code;
});
The error
object already has everything aside from the .message
property filled in (so you can use error.params
, error.dataPath
, error.schemaPath
etc.).
If nothing is returned (or the empty string), then it falls back to the default error reporter. To remove a custom error reporter, call tv4.setErrorReporter(null)
.
Sets the language used by the default error reporter.
code
is a language code, like 'en'
or 'en-gb'
tv4.language('en-gb');
If you specify a multi-level language code (e.g. fr-CH
), then it will fall back to the generic version (fr
) if needed.
Add a new template-based language map for the default error reporter (used by tv4.language(code)
)
code
is new language codemap
is an object mapping error IDs or constant names (e.g. 103
or "NUMBER_MAXIMUM"
) to language strings.tv4.addLanguage('fr', { ... });
// select for use
tv4.language('fr')
If you register a multi-level language code (e.g. fr-FR
), then it will also be registered for plain fr
if that does not already exist.
Add a custom format validator. (There are no built-in format validators. Several common ones can be found here though)
format
is a string, corresponding to the "format"
value in schemas.validationFunction
is a function that either returns:
null
(meaning no error)tv4.addFormat('decimal-digits', function (data, schema) {
if (typeof data === 'string' && !/^[0-9]+$/.test(data)) {
return null;
}
return "must be string of decimal digits";
});
Alternatively, multiple formats can be added at the same time using an object:
tv4.addFormat({
'my-format': function () {...},
'other-format': function () {...}
});
Add a custom keyword validator.
keyword
is a string, corresponding to a schema keywordvalidationFunction
is a function that either returns:
null
(meaning no error)code
/message
/dataPath
/schemaPath
)tv4.defineKeyword('my-custom-keyword', function (data, value, schema) {
if (simpleFailure()) {
return "Failure";
} else if (detailedFailure()) {
return {code: tv4.errorCodes.MY_CUSTOM_CODE, message: {param1: 'a', param2: 'b'}};
} else {
return null;
}
});
schema
is the schema upon which the keyword is defined. In the above example, value === schema['my-custom-keyword']
.
If an object is returned from the custom validator, and its message
is a string, then that is used as the message result. If message
is an object, then that is used to populate the (localisable) error template.
Defines a custom error code.
codeName
is a string, all-caps underscore separated, e.g. "MY_CUSTOM_ERROR"
codeNumber
is an integer > 10000, which will be stored in tv4.errorCodes
(e.g. tv4.errorCodes.MY_CUSTOM_ERROR
)defaultMessage
is an error message template to use (assuming translations have not been provided for this code)An example of defaultMessage
might be: "Incorrect moon (expected {expected}, got {actual}"
). This is filled out if a custom keyword returns a object message
(see above). Translations will be used, if associated with the correct code name/number.
var schema = { "items": { "type": "boolean" } }; var data1 = [true, false]; var data2 = [true, 123];alert("data 1: " + tv4.validate(data1, schema)); // true alert("data 2: " + tv4.validate(data2, schema)); // false alert("data 2 error: " + JSON.stringify(tv4.error, null, 4));
$ref
var schema = { "type": "array", "items": {"$ref": "#"} }; var data1 = [[], [[]]]; var data2 = [[], [true, []]];alert("data 1: " + tv4.validate(data1, schema)); // true alert("data 2: " + tv4.validate(data2, schema)); // false
var schema = { "type": "array", "items": {"$ref": "http://example.com/schema" } }; var data = [1, 2, 3];alert("Valid: " + tv4.validate(data, schema)); // true alert("Missing schemas: " + JSON.stringify(tv4.missing));
tv4.addSchema("http://example.com/schema", { "definitions": { "arrayItem": {"type": "boolean"} } }); var schema = { "type": "array", "items": {"$ref": "http://example.com/schema#/definitions/arrayItem" } }; var data1 = [true, false, true]; var data2 = [1, 2, 3];alert("data 1: " + tv4.validate(data1, schema)); // true alert("data 2: " + tv4.validate(data2, schema)); // false
You can manually download tv4.js
or the minified tv4.min.js
and include it in your html to create the global tv4
variable.
Alternately use it as a CommonJS module:
var tv4 = require('tv4');
or as an AMD module (e.g. with requirejs):
require('tv4', function(tv4){
//use tv4 here
});
There is a command-line tool that wraps this library: tv4-cmd.
$ npm install tv4
$ bower install tv4
$ component install geraintluff/tv4
You can rebuild and run the node and browser tests using node.js and grunt:
Make sure you have the global grunt cli command:
$ npm install grunt-cli -g
Clone the git repos, open a shell in the root folder and install the development dependencies:
$ npm install
Rebuild and run the tests:
$ grunt
It will run a build and display one Spec-style report for the node.js and two Dot-style reports for both the plain and minified browser tests (via phantomJS). You can also use your own browser to manually run the suites by opening test/index.html
and test/index-min.html
.
Pull-requests for fixes and expansions are welcome. Edit the partial files in /source
and add your tests in a suitable suite or folder under /test/tests
and run grunt
to rebuild and run the test suite. Try to maintain an idiomatic coding style and add tests for any new features. It is recommend to discuss big changes in an Issue.
Do you speak another language? tv4
needs internationalisation - please contribute language files to /lang
!
The code is available as "public domain", meaning that it is completely free to use, without any restrictions at all. Read the full license here.
It's also available under an MIT license.
FAQs
A public domain JSON Schema validator for JavaScript
The npm package tv4 receives a total of 1,741,861 weekly downloads. As such, tv4 popularity was classified as popular.
We found that tv4 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.
Product
We're excited to announce that Socket now supports the Java programming language.
Security News
Socket detected a malicious Python package impersonating a popular browser cookie library to steal passwords, screenshots, webcam images, and Discord tokens.
Security News
Deno 2.0 is now available with enhanced package management, full Node.js and npm compatibility, improved performance, and support for major JavaScript frameworks.