jsonschemaparse
Advanced tools
Streaming JSON validation with integrated validation and error reporting tools
Parse a JSON Document into an object structure, validating it against a JSON Schema
Features:
Parses text and turns it into a native value.
For reading a Uint8Array/Buffer, specify charset in the options (see the parse(text, options) form below).
Parses text and turns it into a native value. The reviver argument is applied to each value, compatible with ECMAScript JSON.parse.
Equivalent to ECMAScript JSON.parse(text, reviver).
Parses text while validating it against the Schema instance in the schema argument. Parsing will terminate at the first validation error.
try {
const schema = new lib.Schema({ type: 'string' });
const value = lib.parse(jsonText, schema);
}catch(e){
// handle SchemaError or ValidationError
}
Parses text, and accepts an object options as found in StreamParser, except for the "parse" options, which are called with the following values: parseValue:true, parseAnnotations:false, parseInfo:false.
try {
const value = lib.parse(jsonText, {
schema: { type: 'string' },
charset: 'UTF-8',
});
}catch(e){
// handle SchemaError or ValidationError
}
Parses text and returns an Instance instance. Use it when you need to know additional information about the JSON document, including JSON Schema annotations on each value, or the line/character position information of each value.
options is an object with any of the following properties:
JSON.parse compatible reviving function.text is a Uint8Array/Buffer. ASCII and UTF-8 values permitted.The returned object will have the following properties:
StreamParser is a writable stream that accepts a byte stream or string stream, and outputs events.
It outputs an "end" event when the document has been fully parsed.
options is an object with any of the following properties:
schema: A schema instance or plain object, to be validated against the incoming document.throw: Treat a validation error as a syntax error; stops consumption of the stream and emits the first ValidationError encountered.charset: The character set used to decode a Buffer/Uint8Array. Valid values: ASCII, UTF-8reviver: A function that consumes and maps values immediately after validation (same interface as ECMAScript).parseValue: if true, return value will include a value property with the JSON.parse equivalent parsed value. Default false.parseAnnotations: If true, return value will include annotations/links properties, with JSON Schema annotations (e.g. the "title", "description" keywords.)parseInfo: If true, return value will include properties/keys/map properties with StreamParser output from child instances.maxKeyLength: Enforces a limit on object keys, in UTF-16 characters, for memory purposesmaxStringLength: Enforces a limit on strings (except keys), in UTF-16 characters, for memory purposesmaxNumberLength: Enforces a limit on the lexical representation of numbers, in characters, for memory purposes when "bigNumber" is enabled.maxItems: Enforces a limit on number of items in each array, for memory purposesmaxProperties: Enforces a limit on number of properties in each object, for memory purposesmaxUniqueItems: Enforces a limit on size of all arrays tested by uniqueItems (since this is an O(n²) operation)interoperable: Raise an error if the document is outside the I-JSON (RFC 7493) subset of JSON.bigNumber: Determines behavior for numbers too large to represent in an ECMAScript number without loss of precision. See "bigNumber" section below for possible values.niceNumber: Determines behavior for all other numbers (numbers accurately represented in an ECMAScript number).syntaxLineComment: Treats // as whitespace until the end of the linesyntaxHashComment: Treats # as whitespace until the end of the linesyntaxBlockComment: Treats /* as whitespace until a */ sequence (no nested comments)syntaxNestedComment: Treats /* as whitespace until a */ sequence (allows nesting, overrides syntaxBlockComment)syntaxUnquotedKeys: Permits a bare, unqouted ECMAScript 5.1 IdentifierName as a property keysyntaxTrailingComma: Allows arrays and objects to end with a trailing comma (by configuring the parser so a comma doesn't imply another property/item)syntaxSingleQuote: Permits single quotes for strings, including property keyssyntaxEscapeLF: A backslash linefeed sequence (i.e. a backslash as the last character on a line) will ignore the newline. (The backslash and LF character will both be discarded entirely.) This allows a ␊ character to be broken across multiple lines as the four-character string "\n\␊" (instead of the two character-string "\n" all on a single line).syntaxUTF32: Permits \Uxxxxxxxx or \u{x...} sequences (where x is a hex digit) for representing Unicode code points outside the BMP (Basic Multilingual Plane), that would normally only be escaped via a UTF-16 surrogate pair.syntaxHexadecimal: Permits numbers starting with 0x to be interpreted as hexadeciamal. Only integers can be expressed with this form.syntaxBareDecimal: Permits numbers to start or end with a decimal (otherwise, a 0 would have to come before or after it).syntaxInf: Permits Infinity and -Infinity. This is not compatible with JSON Schema, use with caution.syntaxNaN: Permits NaN as a number value. This is not compatible with JSON Schema, use with caution.syntaxPlus: Permits a leading + before a number.Values for "bigNumber" (all these options are performed after JSON Schema validation):
default: Use nearest floating point representation, same behavior as JSON.parseerror: Treat as a validation errorfunction(json, validator) that returns the value to use.json: Use the raw JSON in a string. This may be in exponential notation, depending on how it was present in the original document.string: Cast to a decimal number. There will be an optional minus sign, one or more digits, a decimal point, and one or more digits. The maxNumberLength will be enforced on this new string, if present.intstr: Encode as a string, but only guarantees the accuracy of the integer part. This is best used with the type: "integer" keyword.fraction: will return an array with two BitInt numbers: the numerator, and denominator. The denominator will always be a non-negative exponent of 10, with one zero for each number past the decimal point.properfraction: will return an array with three BitInt numbers: the whole part, the fractional part numerator, and the fractional part denominator. The denominator will always be a non-negative exponent of 10, with one zero for each number past the decimal point.var parser = new StreamParser(new Schema('http://localhost/schema.json', {type: 'array'}), {parseValue:true});
fs.createReadStream('file.json')
.pipe(parser)
.on('finish', function(err, res){
console.log(parser.errors);
console.log(parser.value);
});
A Promise that resolves to the StreamParser when it parses and validates a document.
An Array of ValidationError instances representing accumulated validation errors. Parsing will end when an error is detected, not all errors in the document may be listed.
If parseValue: true was passed in options, the parsed value will be available here.
Emitted when an object is opened (when { is observed).
Emitted when an object is closed (when } is observed).
Emitted when an array is opened (when [ is observed).
Emitted when an array is closed (when ] is observed).
Emitted inside an object when a key is fully parsed.
Emitted when a string value is parsed.
Emitted when a boolean value is parsed.
Emitted when a null is parsed.
Emitted when the incoming stream been fully consumed, parsed, and a final result is available.
JSON.parse to generate a compatible object.var schema = new Schema('http://localhost/schema.json', { type: 'array' });
var parser = schema.createParser({parseValue:true});
fs.createReadStream('file.json')
.pipe(parser)
.on('finish', function(err, res){
console.log(parser.errors);
console.log(parser.value);
});
Use SchemaRegistry if one schema references another.
Import a schema so that it may be referenced by its given URI by other schemas.
var registry = new SchemaRegistry();
var baseSchema = registry.import('http://localhost/schema.json', { type: 'array', items:{$ref:'http://localhost/item.json'} });
var stringSchema = registry.import('http://localhost/item.json', { type: 'string' });
// Alternatively:
// var schema = new Schema('http://localhost/schema.json', { type: 'array' }, registry);
var parser = baseSchema.createParser({parseValue:true});
fs.createReadStream('file.json')
.pipe(parser)
.on('finish', function(err, res){
console.log(parser.errors);
console.log(parser.value);
});
Stores information about a failed validation of a keyword against an instance. Contains the following properties:
A Validator is the paradigm used to validate information from the JSON parser as it is streaming. It validates a single instance against a single schema by reading SAX events from the parser, as well as listening to results from subordinate validators (Validator instances for child instances and subschemas), and comparing them to the range of events permitted by the schema.
It is an ECMAScript object that consumes information about a single layer in the parser stack as it tokenizes input. A validator only evaluates over a single layer in the stack (like an object or a string), it is not notified of events that happen in children or grandchildren layers. Instead, when a child is encountered (like an array item), a function is called requesting a list of validators that can process that sub-instance. When the child finishes parsing, the validator can then examine the return value and act on it.
A new validator does not yet know the type of incoming value, and may not know until e.g. all whitespace is consumed. You must wait for a start{type} call.
Called to create a validator, whenever a new layer in the parsing stack is entered.
Optionally pass an outside array that errors will be pushed to. Normally, this will be the instance of StreamParser#errors, so that errors from all validators get gathered together at the parser. Otherwise, a local array will be created.
The parser will call the following methods, depending on the tokens it encounters during parsing:
Use lib.parse in place of JSON.parse.
This library only parses, so there is no equivalent to JSON.stringify
Homepage: https://github.com/json5/json5
JSON5 is a library that supports a superset of the JSON syntax, with a JSON.parse compatible API.
In place of JSON5.parse, use lib.parse as follows:
const JSON5opts = {
syntaxUnquotedKeys: true,
syntaxTrailingComma: true,
syntaxSingleQuote: true,
syntaxEscapeLF: true,
syntaxHexadecimal: true,
syntaxBareDecimal: true,
syntaxInf: true,
syntaxNaN: true,
syntaxPlus: true,
}
const parsed = lib.parse(text, JSON5Opts);
If you need the reviver function, add a "reviver" property to the options.
This library only parses, so there is no equivalent to JSON5.stringify.
Homepage: https://github.com/dscape/clarinet
Clarinet is a SAX-like streaming parser for JSON.
Homepage: http://oboejs.com/
Oboe.js is a streaming parser for JSON, derived from Clarinet, that supports retrieval over the network, and an API to split a (potentially very large) document into subdocuments, for easier processing by the application.
This library does not perform any network or filesystem functions; get a readable stream, somehow, and pipe it into a . For example in Node.js, use fs.createReadStream.
FAQs
Streaming JSON validation with integrated validation and error reporting tools
We found that jsonschemaparse demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 1 open source maintainer 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
Research
A malicious npm package disguised as a WhatsApp client is exploiting authentication flows with a remote kill switch to exfiltrate data and destroy files.
Security News
PyPI now supports digital attestations, enhancing security and trust by allowing package maintainers to verify the authenticity of Python packages.
Security News
GitHub removed 27 malicious pull requests attempting to inject harmful code across multiple open source repositories, in another round of low-effort attacks.